Serializable, Point<Euclidean2D>, Vector<Euclidean2D>public class Cartesian2D extends Vector2D implements Point<Euclidean2D>
An instance of Cartesian2D represents the point with the corresponding coordinates.
An instance of Cartesian2D also represents the vector which begins at the origin and ends at the point corresponding to the coordinates.
Instances of this class are guaranteed to be immutable.
| Modifier and Type | Field | Description |
|---|---|---|
static Cartesian2D |
NaN |
A vector with all coordinates set to NaN.
|
static Cartesian2D |
NEGATIVE_INFINITY |
A vector with all coordinates set to negative infinity.
|
static Cartesian2D |
POSITIVE_INFINITY |
A vector with all coordinates set to positive infinity.
|
static Cartesian2D |
ZERO |
Origin (coordinates: 0, 0).
|
| Constructor | Description |
|---|---|
Cartesian2D(double[] v) |
Simple constructor.
|
Cartesian2D(double x,
double y) |
Simple constructor.
|
Cartesian2D(double a,
Cartesian2D u) |
Multiplicative constructor
Build a vector from another one and a scale factor.
|
Cartesian2D(double a1,
Cartesian2D u1,
double a2,
Cartesian2D u2) |
Linear constructor
Build a vector from two other ones and corresponding scale factors.
|
Cartesian2D(double a1,
Cartesian2D u1,
double a2,
Cartesian2D u2,
double a3,
Cartesian2D u3) |
Linear constructor
Build a vector from three other ones and corresponding scale factors.
|
Cartesian2D(double a1,
Cartesian2D u1,
double a2,
Cartesian2D u2,
double a3,
Cartesian2D u3,
double a4,
Cartesian2D u4) |
Linear constructor
Build a vector from four other ones and corresponding scale factors.
|
| Modifier and Type | Method | Description |
|---|---|---|
Cartesian2D |
add(double factor,
Vector<Euclidean2D> v) |
Add a scaled vector to the instance.
|
Cartesian2D |
add(Vector<Euclidean2D> v) |
Add a vector to the instance.
|
static double |
angle(Cartesian2D v1,
Cartesian2D v2) |
Compute the angular separation between two vectors.
|
double |
crossProduct(Cartesian2D p1,
Cartesian2D p2) |
Compute the cross-product of the instance and the given vector.
|
double |
distance(Cartesian2D c) |
Compute the distance between the instance and other coordinates.
|
static double |
distance(Cartesian2D p1,
Cartesian2D p2) |
Compute the distance between two points according to the L2 norm.
|
double |
distance(Point<Euclidean2D> p) |
Compute the distance between the instance and another point.
|
double |
distance(Vector<Euclidean2D> v) |
Compute the distance between the instance and another vector.
|
double |
distance1(Vector<Euclidean2D> p) |
Compute the distance between the instance and another vector according to the L1 norm.
|
static double |
distanceInf(Cartesian2D p1,
Cartesian2D p2) |
Compute the distance between two points according to the L∞ norm.
|
double |
distanceInf(Vector<Euclidean2D> p) |
Compute the distance between the instance and another vector according to the L∞ norm.
|
static double |
distanceSq(Cartesian2D p1,
Cartesian2D p2) |
Compute the square of the distance between two points.
|
double |
distanceSq(Vector<Euclidean2D> p) |
Compute the square of the distance between the instance and another vector.
|
double |
dotProduct(Vector<Euclidean2D> v) |
Compute the dot-product of the instance and another vector.
|
boolean |
equals(Object other) |
Test for the equality of two 2D instances.
|
double |
getNorm() |
Get the L2 norm for the vector.
|
double |
getNorm1() |
Get the L1 norm for the vector.
|
double |
getNormInf() |
Get the L∞ norm for the vector.
|
double |
getNormSq() |
Get the square of the norm for the vector.
|
Space |
getSpace() |
Get the space to which the point belongs.
|
double |
getX() |
Get the abscissa of the vector.
|
double |
getY() |
Get the ordinate of the vector.
|
Cartesian2D |
getZero() |
Get the null vector of the vectorial space or origin point of the affine space.
|
int |
hashCode() |
Get a hashCode for the 2D coordinates.
|
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 point is NaN; false otherwise
|
Cartesian2D |
negate() |
Get the opposite of the instance.
|
Cartesian2D |
normalize() |
Get a normalized vector aligned with the instance.
|
Cartesian2D |
scalarMultiply(double a) |
Multiply the instance by a scalar.
|
Cartesian2D |
subtract(double factor,
Vector<Euclidean2D> v) |
Subtract a scaled vector from the instance.
|
Cartesian2D |
subtract(Vector<Euclidean2D> p) |
Subtract a vector from the instance.
|
double[] |
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.
|
public static final Cartesian2D ZERO
public static final Cartesian2D NaN
public static final Cartesian2D POSITIVE_INFINITY
public static final Cartesian2D NEGATIVE_INFINITY
public Cartesian2D(double x,
double y)
public Cartesian2D(double[] v)
throws DimensionMismatchException
v - coordinates arrayDimensionMismatchException - if array does not have 2 elementstoArray()public Cartesian2D(double a,
Cartesian2D u)
a - scale factoru - base (unscaled) vectorpublic Cartesian2D(double a1,
Cartesian2D u1,
double a2,
Cartesian2D u2)
a1 - first scale factoru1 - first base (unscaled) vectora2 - second scale factoru2 - second base (unscaled) vectorpublic Cartesian2D(double a1,
Cartesian2D u1,
double a2,
Cartesian2D u2,
double a3,
Cartesian2D u3)
a1 - first scale factoru1 - first base (unscaled) vectora2 - second scale factoru2 - second base (unscaled) vectora3 - third scale factoru3 - third base (unscaled) vectorpublic Cartesian2D(double a1,
Cartesian2D u1,
double a2,
Cartesian2D u2,
double a3,
Cartesian2D u3,
double a4,
Cartesian2D 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 double getX()
getX in class Vector2DCartesian2D(double, double)public double getY()
getY in class Vector2DCartesian2D(double, double)public double[] toArray()
Cartesian2D(double[])public Space getSpace()
getSpace in interface Point<Euclidean2D>getSpace in interface Vector<Euclidean2D>public Cartesian2D getZero()
getZero in interface Vector<Euclidean2D>public double getNorm1()
getNorm1 in interface Vector<Euclidean2D>public double getNorm()
getNorm in interface Vector<Euclidean2D>public double getNormSq()
getNormSq in interface Vector<Euclidean2D>public double getNormInf()
getNormInf in interface Vector<Euclidean2D>public Cartesian2D add(Vector<Euclidean2D> v)
add in interface Vector<Euclidean2D>v - vector to addpublic Cartesian2D add(double factor, Vector<Euclidean2D> v)
add in interface Vector<Euclidean2D>factor - scale factor to apply to v before adding itv - vector to addpublic Cartesian2D subtract(Vector<Euclidean2D> p)
subtract in interface Vector<Euclidean2D>p - vector to subtractpublic Cartesian2D subtract(double factor, Vector<Euclidean2D> v)
subtract in interface Vector<Euclidean2D>factor - scale factor to apply to v before subtracting itv - vector to subtractpublic Cartesian2D normalize() throws MathArithmeticException
normalize in interface Vector<Euclidean2D>MathArithmeticException - if the norm is zeropublic static double angle(Cartesian2D v1, Cartesian2D v2) throws MathArithmeticException
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.
v1 - first vectorv2 - second vectorMathArithmeticException - if either vector has a null normpublic Cartesian2D negate()
negate in interface Vector<Euclidean2D>public Cartesian2D scalarMultiply(double a)
scalarMultiply in interface Vector<Euclidean2D>a - scalarpublic boolean isNaN()
isNaN in interface Point<Euclidean2D>isNaN in interface Vector<Euclidean2D>public boolean isInfinite()
isInfinite in interface Vector<Euclidean2D>public double distance1(Vector<Euclidean2D> p)
Calling this method is equivalent to calling:
q.subtract(p).getNorm1() except that no intermediate
vector is built
distance1 in interface Vector<Euclidean2D>p - second vectorpublic double distance(Point<Euclidean2D> p)
distance in interface Point<Euclidean2D>p - second pointpublic double distance(Vector<Euclidean2D> v)
distance in interface Vector<Euclidean2D>v - second vectorpublic double distance(Cartesian2D c)
c - other coordinatespublic double distanceInf(Vector<Euclidean2D> p)
Calling this method is equivalent to calling:
q.subtract(p).getNormInf() except that no intermediate
vector is built
distanceInf in interface Vector<Euclidean2D>p - second vectorpublic double distanceSq(Vector<Euclidean2D> p)
Calling this method is equivalent to calling:
q.subtract(p).getNormSq() except that no intermediate
vector is built
distanceSq in interface Vector<Euclidean2D>p - second vectorpublic double dotProduct(Vector<Euclidean2D> v)
dotProduct in interface Vector<Euclidean2D>v - second vectorpublic double crossProduct(Cartesian2D p1, Cartesian2D 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 double distance(Cartesian2D p1, Cartesian2D p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNorm() except that no intermediate
vector is built
p1 - first pointp2 - second pointpublic static double distanceInf(Cartesian2D p1, Cartesian2D p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormInf() except that no intermediate
vector is built
p1 - first pointp2 - second pointpublic static double distanceSq(Cartesian2D p1, Cartesian2D p2)
Calling this method is equivalent to calling:
p1.subtract(p2).getNormSq() except that no intermediate
vector is built
p1 - first pointp2 - second pointpublic boolean equals(Object other)
If all coordinates of two 2D vectors are exactly the same, and none are
Double.NaN, the two 2D instances 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) coordinates of the
2D vector are equal to Double.NaN, the 2D vector is equal to
NaN.
public int hashCode()
All NaN values have the same hash code.
public String toString()
public String toString(NumberFormat format)
toString in interface Vector<Euclidean2D>format - the custom format for componentsCopyright © 2003–2017 The Apache Software Foundation. All rights reserved.