T
 the type of the field elementspublic class FieldVector2D<T extends RealFieldElement<T>> extends Object
Vector2D
using RealFieldElement
.
Instance of this class are guaranteed to be immutable.
Constructor and Description 

FieldVector2D(double a,
FieldVector2D<T> u)
Multiplicative constructor
Build a vector from another one and a scale factor.

FieldVector2D(double a1,
FieldVector2D<T> u1,
double a2,
FieldVector2D<T> u2)
Linear constructor.

FieldVector2D(double a1,
FieldVector2D<T> u1,
double a2,
FieldVector2D<T> u2,
double a3,
FieldVector2D<T> u3)
Linear constructor.

FieldVector2D(double a1,
FieldVector2D<T> u1,
double a2,
FieldVector2D<T> u2,
double a3,
FieldVector2D<T> u3,
double a4,
FieldVector2D<T> u4)
Linear constructor.

FieldVector2D(Field<T> field,
Vector2D v)
Build a
FieldVector2D from a Vector2D . 
FieldVector2D(T[] v)
Simple constructor.

FieldVector2D(T a,
FieldVector2D<T> u)
Multiplicative constructor
Build a vector from another one and a scale factor.

FieldVector2D(T a1,
FieldVector2D<T> u1,
T a2,
FieldVector2D<T> u2)
Linear constructor
Build a vector from two other ones and corresponding scale factors.

FieldVector2D(T a1,
FieldVector2D<T> u1,
T a2,
FieldVector2D<T> u2,
T a3,
FieldVector2D<T> u3)
Linear constructor.

FieldVector2D(T a1,
FieldVector2D<T> u1,
T a2,
FieldVector2D<T> u2,
T a3,
FieldVector2D<T> u3,
T a4,
FieldVector2D<T> u4)
Linear constructor.

FieldVector2D(T x,
T y)
Simple constructor.

FieldVector2D(T a,
Vector2D u)
Multiplicative constructor
Build a vector from another one and a scale factor.

FieldVector2D(T a1,
Vector2D u1,
T a2,
Vector2D u2)
Linear constructor.

FieldVector2D(T a1,
Vector2D u1,
T a2,
Vector2D u2,
T a3,
Vector2D u3)
Linear constructor.

FieldVector2D(T a1,
Vector2D u1,
T a2,
Vector2D u2,
T a3,
Vector2D u3,
T a4,
Vector2D u4)
Linear constructor.

Modifier and Type  Method and Description 

FieldVector2D<T> 
add(double factor,
FieldVector2D<T> v)
Add a scaled vector to the instance.

FieldVector2D<T> 
add(double factor,
Vector2D v)
Add a scaled vector to the instance.

FieldVector2D<T> 
add(FieldVector2D<T> v)
Add a vector to the instance.

FieldVector2D<T> 
add(T factor,
FieldVector2D<T> v)
Add a scaled vector to the instance.

FieldVector2D<T> 
add(T factor,
Vector2D v)
Add a scaled vector to the instance.

FieldVector2D<T> 
add(Vector2D v)
Add a vector to the instance.

static <T extends RealFieldElement<T>> 
angle(FieldVector2D<T> v1,
FieldVector2D<T> v2)
Compute the angular separation between two vectors.

static <T extends RealFieldElement<T>> 
angle(FieldVector2D<T> v1,
Vector2D v2)
Compute the angular separation between two vectors.

static <T extends RealFieldElement<T>> 
angle(Vector2D v1,
FieldVector2D<T> v2)
Compute the angular separation between two vectors.

T 
crossProduct(FieldVector2D<T> p1,
FieldVector2D<T> p2)
Compute the crossproduct of the instance and the given points.

T 
crossProduct(Vector2D p1,
Vector2D p2)
Compute the crossproduct of the instance and the given points.

T 
distance(FieldVector2D<T> v)
Compute the distance between the instance and another vector according to the L_{2} norm.

static <T extends RealFieldElement<T>> 
distance(FieldVector2D<T> p1,
FieldVector2D<T> p2)
Compute the distance between two vectors according to the L_{2} norm.

static <T extends RealFieldElement<T>> 
distance(FieldVector2D<T> p1,
Vector2D p2)
Compute the distance between two vectors according to the L_{2} norm.

T 
distance(Vector2D v)
Compute the distance between the instance and another vector according to the L_{2} norm.

static <T extends RealFieldElement<T>> 
distance(Vector2D p1,
FieldVector2D<T> p2)
Compute the distance between two vectors according to the L_{2} norm.

T 
distance1(FieldVector2D<T> v)
Compute the distance between the instance and another vector according to the L_{1} norm.

static <T extends RealFieldElement<T>> 
distance1(FieldVector2D<T> p1,
FieldVector2D<T> p2)
Compute the distance between two vectors according to the L_{2} norm.

static <T extends RealFieldElement<T>> 
distance1(FieldVector2D<T> p1,
Vector2D p2)
Compute the distance between two vectors according to the L_{2} norm.

T 
distance1(Vector2D v)
Compute the distance between the instance and another vector according to the L_{1} norm.

static <T extends RealFieldElement<T>> 
distance1(Vector2D p1,
FieldVector2D<T> p2)
Compute the distance between two vectors according to the L_{2} norm.

T 
distanceInf(FieldVector2D<T> v)
Compute the distance between the instance and another vector according to the L_{∞} norm.

static <T extends RealFieldElement<T>> 
distanceInf(FieldVector2D<T> p1,
FieldVector2D<T> p2)
Compute the distance between two vectors according to the L_{∞} norm.

static <T extends RealFieldElement<T>> 
distanceInf(FieldVector2D<T> p1,
Vector2D p2)
Compute the distance between two vectors according to the L_{∞} norm.

T 
distanceInf(Vector2D v)
Compute the distance between the instance and another vector according to the L_{∞} norm.

static <T extends RealFieldElement<T>> 
distanceInf(Vector2D p1,
FieldVector2D<T> p2)
Compute the distance between two vectors according to the L_{∞} norm.

T 
distanceSq(FieldVector2D<T> v)
Compute the square of the distance between the instance and another vector.

static <T extends RealFieldElement<T>> 
distanceSq(FieldVector2D<T> p1,
FieldVector2D<T> p2)
Compute the square of the distance between two vectors.

static <T extends RealFieldElement<T>> 
distanceSq(FieldVector2D<T> p1,
Vector2D p2)
Compute the square of the distance between two vectors.

T 
distanceSq(Vector2D v)
Compute the square of the distance between the instance and another vector.

static <T extends RealFieldElement<T>> 
distanceSq(Vector2D p1,
FieldVector2D<T> p2)
Compute the square of the distance between two vectors.

T 
dotProduct(FieldVector2D<T> v)
Compute the dotproduct of the instance and another vector.

T 
dotProduct(Vector2D v)
Compute the dotproduct of the instance and another vector.

boolean 
equals(Object other)
Test for the equality of two 2D vectors.

static <T extends RealFieldElement<T>> 
getMinusI(Field<T> field)
Get opposite of the first canonical vector (coordinates: 1).

static <T extends RealFieldElement<T>> 
getMinusJ(Field<T> field)
Get opposite of the second canonical vector (coordinates: 0, 1).

static <T extends RealFieldElement<T>> 
getNaN(Field<T> field)
Get a vector with all coordinates set to NaN.

static <T extends RealFieldElement<T>> 
getNegativeInfinity(Field<T> field)
Get a vector with all coordinates set to negative infinity.

T 
getNorm()
Get the L_{2} norm for the vector.

T 
getNorm1()
Get the L_{1} norm for the vector.

T 
getNormInf()
Get the L_{∞} norm for the vector.

T 
getNormSq()
Get the square of the norm for the vector.

static <T extends RealFieldElement<T>> 
getPlusI(Field<T> field)
Get first canonical vector (coordinates: 1, 0).

static <T extends RealFieldElement<T>> 
getPlusJ(Field<T> field)
Get second canonical vector (coordinates: 0, 1).

static <T extends RealFieldElement<T>> 
getPositiveInfinity(Field<T> field)
Get a vector with all coordinates set to positive infinity.

T 
getX()
Get the abscissa of the vector.

T 
getY()
Get the ordinate of the vector.

static <T extends RealFieldElement<T>> 
getZero(Field<T> field)
Get null vector (coordinates: 0, 0).

int 
hashCode()
Get a hashCode for the 3D vector.

boolean 
isInfinite()
Returns true if any coordinate of this vector is infinite and none are NaN;
false otherwise

boolean 
isNaN()
Returns true if any coordinate of this vector is NaN; false otherwise

FieldVector2D<T> 
negate()
Get the opposite of the instance.

FieldVector2D<T> 
normalize()
Get a normalized vector aligned with the instance.

static <T extends RealFieldElement<T>> 
orientation(FieldVector2D<T> p,
FieldVector2D<T> q,
FieldVector2D<T> r)
Compute the orientation of a triplet of points.

FieldVector2D<T> 
scalarMultiply(double a)
Multiply the instance by a scalar.

FieldVector2D<T> 
scalarMultiply(T a)
Multiply the instance by a scalar.

FieldVector2D<T> 
subtract(double factor,
FieldVector2D<T> v)
Subtract a scaled vector from the instance.

FieldVector2D<T> 
subtract(double factor,
Vector2D v)
Subtract a scaled vector from the instance.

FieldVector2D<T> 
subtract(FieldVector2D<T> v)
Subtract a vector from the instance.

FieldVector2D<T> 
subtract(T factor,
FieldVector2D<T> v)
Subtract a scaled vector from the instance.

FieldVector2D<T> 
subtract(T factor,
Vector2D v)
Subtract a scaled vector from the instance.

FieldVector2D<T> 
subtract(Vector2D v)
Subtract a vector from the instance.

T[] 
toArray()
Get the vector coordinates as a dimension 2 array.

String 
toString()
Get a string representation of this vector.

String 
toString(NumberFormat format)
Get a string representation of this vector.

Vector2D 
toVector2D()
Convert to a constant vector without extra field parts.

public FieldVector2D(T x, T y)
public FieldVector2D(T[] v) throws MathIllegalArgumentException
v
 coordinates arrayMathIllegalArgumentException
 if array does not have 2 elementstoArray()
public FieldVector2D(T a, FieldVector2D<T> u)
a
 scale factoru
 base (unscaled) vectorpublic FieldVector2D(T a, Vector2D u)
a
 scale factoru
 base (unscaled) vectorpublic FieldVector2D(double a, FieldVector2D<T> u)
a
 scale factoru
 base (unscaled) vectorpublic FieldVector2D(T a1, FieldVector2D<T> u1, T a2, FieldVector2D<T> u2)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectorpublic FieldVector2D(T a1, Vector2D u1, T a2, Vector2D u2)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectorpublic FieldVector2D(double a1, FieldVector2D<T> u1, double a2, FieldVector2D<T> u2)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectorpublic FieldVector2D(T a1, FieldVector2D<T> u1, T a2, FieldVector2D<T> u2, T a3, FieldVector2D<T> u3)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectora3
 third scale factoru3
 third base (unscaled) vectorpublic FieldVector2D(T a1, Vector2D u1, T a2, Vector2D u2, T a3, Vector2D u3)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectora3
 third scale factoru3
 third base (unscaled) vectorpublic FieldVector2D(double a1, FieldVector2D<T> u1, double a2, FieldVector2D<T> u2, double a3, FieldVector2D<T> u3)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectora3
 third scale factoru3
 third base (unscaled) vectorpublic FieldVector2D(T a1, FieldVector2D<T> u1, T a2, FieldVector2D<T> u2, T a3, FieldVector2D<T> u3, T a4, FieldVector2D<T> u4)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectora3
 third scale factoru3
 third base (unscaled) vectora4
 fourth scale factoru4
 fourth base (unscaled) vectorpublic FieldVector2D(T a1, Vector2D u1, T a2, Vector2D u2, T a3, Vector2D u3, T a4, Vector2D u4)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectora3
 third scale factoru3
 third base (unscaled) vectora4
 fourth scale factoru4
 fourth base (unscaled) vectorpublic FieldVector2D(double a1, FieldVector2D<T> u1, double a2, FieldVector2D<T> u2, double a3, FieldVector2D<T> u3, double a4, FieldVector2D<T> u4)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectora3
 third scale factoru3
 third base (unscaled) vectora4
 fourth scale factoru4
 fourth base (unscaled) vectorpublic FieldVector2D(Field<T> field, Vector2D v)
FieldVector2D
from a Vector2D
.field
 field for the componentsv
 vector to convertpublic static <T extends RealFieldElement<T>> FieldVector2D<T> getZero(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic static <T extends RealFieldElement<T>> FieldVector2D<T> getPlusI(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic static <T extends RealFieldElement<T>> FieldVector2D<T> getMinusI(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic static <T extends RealFieldElement<T>> FieldVector2D<T> getPlusJ(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic static <T extends RealFieldElement<T>> FieldVector2D<T> getMinusJ(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic static <T extends RealFieldElement<T>> FieldVector2D<T> getNaN(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic static <T extends RealFieldElement<T>> FieldVector2D<T> getPositiveInfinity(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic static <T extends RealFieldElement<T>> FieldVector2D<T> getNegativeInfinity(Field<T> field)
T
 the type of the field elementsfield
 field for the componentspublic T getX()
FieldVector2D(RealFieldElement, RealFieldElement)
public T getY()
FieldVector2D(RealFieldElement, RealFieldElement)
public T[] toArray()
FieldVector2D(RealFieldElement[])
public Vector2D toVector2D()
public T getNorm1()
public T getNorm()
public T getNormSq()
public T getNormInf()
public FieldVector2D<T> add(FieldVector2D<T> v)
v
 vector to addpublic FieldVector2D<T> add(Vector2D v)
v
 vector to addpublic FieldVector2D<T> add(T factor, FieldVector2D<T> v)
factor
 scale factor to apply to v before adding itv
 vector to addpublic FieldVector2D<T> add(T factor, Vector2D v)
factor
 scale factor to apply to v before adding itv
 vector to addpublic FieldVector2D<T> add(double factor, FieldVector2D<T> v)
factor
 scale factor to apply to v before adding itv
 vector to addpublic FieldVector2D<T> add(double factor, Vector2D v)
factor
 scale factor to apply to v before adding itv
 vector to addpublic FieldVector2D<T> subtract(FieldVector2D<T> v)
v
 vector to subtractpublic FieldVector2D<T> subtract(Vector2D v)
v
 vector to subtractpublic FieldVector2D<T> subtract(T factor, FieldVector2D<T> v)
factor
 scale factor to apply to v before subtracting itv
 vector to subtractpublic FieldVector2D<T> subtract(T factor, Vector2D v)
factor
 scale factor to apply to v before subtracting itv
 vector to subtractpublic FieldVector2D<T> subtract(double factor, FieldVector2D<T> v)
factor
 scale factor to apply to v before subtracting itv
 vector to subtractpublic FieldVector2D<T> subtract(double factor, Vector2D v)
factor
 scale factor to apply to v before subtracting itv
 vector to subtractpublic FieldVector2D<T> normalize() throws MathRuntimeException
MathRuntimeException
 if the norm is zeropublic static <T extends RealFieldElement<T>> T angle(FieldVector2D<T> v1, FieldVector2D<T> v2) throws MathRuntimeException
This method computes the angular separation between two vectors using the dot product for well separated vectors and the cross product for almost aligned vectors. This allows to have a good accuracy in all cases, even for vectors very close to each other.
T
 the type of the field elementsv1
 first vectorv2
 second vectorMathRuntimeException
 if either vector has a null normpublic static <T extends RealFieldElement<T>> T angle(FieldVector2D<T> v1, Vector2D v2) throws MathRuntimeException
This method computes the angular separation between two vectors using the dot product for well separated vectors and the cross product for almost aligned vectors. This allows to have a good accuracy in all cases, even for vectors very close to each other.
T
 the type of the field elementsv1
 first vectorv2
 second vectorMathRuntimeException
 if either vector has a null normpublic static <T extends RealFieldElement<T>> T angle(Vector2D v1, FieldVector2D<T> v2) throws MathRuntimeException
This method computes the angular separation between two vectors using the dot product for well separated vectors and the cross product for almost aligned vectors. This allows to have a good accuracy in all cases, even for vectors very close to each other.
T
 the type of the field elementsv1
 first vectorv2
 second vectorMathRuntimeException
 if either vector has a null normpublic FieldVector2D<T> negate()
public FieldVector2D<T> scalarMultiply(T a)
a
 scalarpublic FieldVector2D<T> scalarMultiply(double a)
a
 scalarpublic boolean isNaN()
public boolean isInfinite()
public boolean equals(Object other)
If all coordinates of two 2D vectors are exactly the same, and none of their
real part
are NaN
, the
two 2D vectors are considered to be equal.
NaN
coordinates are considered to affect globally the vector
and be equals to each other  i.e, if either (or all) real part of the
coordinates of the 3D vector are NaN
, the 2D vector is NaN
.
public int hashCode()
All NaN values have the same hash code.
public T distance1(FieldVector2D<T> v)
Calling this method is equivalent to calling:
q.subtract(p).getNorm1()
except that no intermediate
vector is built
v
 second vectorpublic T distance1(Vector2D v)
Calling this method is equivalent to calling:
q.subtract(p).getNorm1()
except that no intermediate
vector is built
v
 second vectorpublic T distance(FieldVector2D<T> v)
Calling this method is equivalent to calling:
q.subtract(p).getNorm()
except that no intermediate
vector is built
v
 second vectorpublic T distance(Vector2D v)
Calling this method is equivalent to calling:
q.subtract(p).getNorm()
except that no intermediate
vector is built
v
 second vectorpublic T distanceInf(FieldVector2D<T> v)
Calling this method is equivalent to calling:
q.subtract(p).getNormInf()
except that no intermediate
vector is built
v
 second vectorpublic T distanceInf(Vector2D v)
Calling this method is equivalent to calling:
q.subtract(p).getNormInf()
except that no intermediate
vector is built
v
 second vectorpublic T distanceSq(FieldVector2D<T> v)
Calling this method is equivalent to calling:
q.subtract(p).getNormSq()
except that no intermediate
vector is built
v
 second vectorpublic T distanceSq(Vector2D v)
Calling this method is equivalent to calling:
q.subtract(p).getNormSq()
except that no intermediate
vector is built
v
 second vectorpublic T dotProduct(FieldVector2D<T> v)
The implementation uses specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects. It should be very accurate even for nearly orthogonal vectors.
v
 second vectorMathArrays.linearCombination(double, double, double, double, double, double)
public T dotProduct(Vector2D v)
The implementation uses specific multiplication and addition algorithms to preserve accuracy and reduce cancellation effects. It should be very accurate even for nearly orthogonal vectors.
v
 second vectorMathArrays.linearCombination(double, double, double, double, double, double)
public T crossProduct(FieldVector2D<T> p1, FieldVector2D<T> p2)
The cross product can be used to determine the location of a point with regard to the line formed by (p1, p2) and is calculated as: \[ P = (x_2  x_1)(y_3  y_1)  (y_2  y_1)(x_3  x_1) \] with \(p3 = (x_3, y_3)\) being this instance.
If the result is 0, the points are collinear, i.e. lie on a single straight line L; if it is positive, this point lies to the left, otherwise to the right of the line formed by (p1, p2).
p1
 first point of the linep2
 second point of the linepublic T crossProduct(Vector2D p1, Vector2D p2)
The cross product can be used to determine the location of a point with regard to the line formed by (p1, p2) and is calculated as: \[ P = (x_2  x_1)(y_3  y_1)  (y_2  y_1)(x_3  x_1) \] with \(p3 = (x_3, y_3)\) being this instance.
If the result is 0, the points are collinear, i.e. lie on a single straight line L; if it is positive, this point lies to the left, otherwise to the right of the line formed by (p1, p2).
p1
 first point of the linep2
 second point of the linepublic static <T extends RealFieldElement<T>> T distance1(FieldVector2D<T> p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNorm()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distance1(FieldVector2D<T> p1, Vector2D p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNorm()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distance1(Vector2D p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNorm()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distance(FieldVector2D<T> p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNorm()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distance(FieldVector2D<T> p1, Vector2D p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNorm()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distance(Vector2D p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNorm()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distanceInf(FieldVector2D<T> p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormInf()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distanceInf(FieldVector2D<T> p1, Vector2D p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormInf()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distanceInf(Vector2D p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormInf()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distanceSq(FieldVector2D<T> p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormSq()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distanceSq(FieldVector2D<T> p1, Vector2D p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormSq()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T distanceSq(Vector2D p1, FieldVector2D<T> p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormSq()
except that no intermediate
vector is built
T
 the type of the field elementsp1
 first vectorp2
 second vectorpublic static <T extends RealFieldElement<T>> T orientation(FieldVector2D<T> p, FieldVector2D<T> q, FieldVector2D<T> r)
T
 the type of the field elementsp
 first vector of the tripletq
 second vector of the tripletr
 third vector of the tripletpublic String toString()
public String toString(NumberFormat format)
format
 the custom format for componentsCopyright © 2016–2020 Hipparchus.org. All rights reserved.