public class Vector3D extends Object implements Serializable, Vector<Euclidean3D>
Instance of this class are guaranteed to be immutable.
Modifier and Type  Field and Description 

static Vector3D 
MINUS_I
Opposite of the first canonical vector (coordinates: 1, 0, 0).

static Vector3D 
MINUS_J
Opposite of the second canonical vector (coordinates: 0, 1, 0).

static Vector3D 
MINUS_K
Opposite of the third canonical vector (coordinates: 0, 0, 1).

static Vector3D 
NaN
A vector with all coordinates set to NaN.

static Vector3D 
NEGATIVE_INFINITY
A vector with all coordinates set to negative infinity.

static Vector3D 
PLUS_I
First canonical vector (coordinates: 1, 0, 0).

static Vector3D 
PLUS_J
Second canonical vector (coordinates: 0, 1, 0).

static Vector3D 
PLUS_K
Third canonical vector (coordinates: 0, 0, 1).

static Vector3D 
POSITIVE_INFINITY
A vector with all coordinates set to positive infinity.

static Vector3D 
ZERO
Null vector (coordinates: 0, 0, 0).

Constructor and Description 

Vector3D(double[] v)
Simple constructor.

Vector3D(double alpha,
double delta)
Simple constructor.

Vector3D(double x,
double y,
double z)
Simple constructor.

Vector3D(double a,
Vector3D u)
Multiplicative constructor
Build a vector from another one and a scale factor.

Vector3D(double a1,
Vector3D u1,
double a2,
Vector3D u2)
Linear constructor
Build a vector from two other ones and corresponding scale factors.

Vector3D(double a1,
Vector3D u1,
double a2,
Vector3D u2,
double a3,
Vector3D u3)
Linear constructor
Build a vector from three other ones and corresponding scale factors.

Vector3D(double a1,
Vector3D u1,
double a2,
Vector3D u2,
double a3,
Vector3D u3,
double a4,
Vector3D u4)
Linear constructor
Build a vector from four other ones and corresponding scale factors.

Modifier and Type  Method and Description 

Vector3D 
add(double factor,
Vector<Euclidean3D> v)
Add a scaled vector to the instance.

Vector3D 
add(Vector<Euclidean3D> v)
Add a vector to the instance.

static double 
angle(Vector3D v1,
Vector3D v2)
Compute the angular separation between two vectors.

Vector3D 
crossProduct(Vector<Euclidean3D> v)
Compute the crossproduct of the instance with another vector.

static Vector3D 
crossProduct(Vector3D v1,
Vector3D v2)
Compute the crossproduct of two vectors.

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

static double 
distance(Vector3D v1,
Vector3D v2)
Compute the distance between two vectors according to the L_{2} norm.

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

static double 
distance1(Vector3D v1,
Vector3D v2)
Compute the distance between two vectors according to the L_{1} norm.

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

static double 
distanceInf(Vector3D v1,
Vector3D v2)
Compute the distance between two vectors according to the L_{∞} norm.

double 
distanceSq(Vector<Euclidean3D> v)
Compute the square of the distance between the instance and another vector.

static double 
distanceSq(Vector3D v1,
Vector3D v2)
Compute the square of the distance between two vectors.

double 
dotProduct(Vector<Euclidean3D> v)
Compute the dotproduct of the instance and another vector.

static double 
dotProduct(Vector3D v1,
Vector3D v2)
Compute the dotproduct of two vectors.

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

double 
getAlpha()
Get the azimuth of the vector.

double 
getDelta()
Get the elevation of the vector.

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

double 
getNorm1()
Get the L_{1} 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 vector belongs.

double 
getX()
Get the abscissa of the vector.

double 
getY()
Get the ordinate of the vector.

double 
getZ()
Get the height of the vector.

Vector3D 
getZero()
Get the null vector of the vectorial space or origin point of the affine space.

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

Vector3D 
negate()
Get the opposite of the instance.

Vector3D 
normalize()
Get a normalized vector aligned with the instance.

Vector3D 
orthogonal()
Get a vector orthogonal to the instance.

Vector3D 
scalarMultiply(double a)
Multiply the instance by a scalar.

Vector3D 
subtract(double factor,
Vector<Euclidean3D> v)
Subtract a scaled vector from the instance.

Vector3D 
subtract(Vector<Euclidean3D> v)
Subtract a vector from the instance.

double[] 
toArray()
Get the vector coordinates as a dimension 3 array.

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

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

public static final Vector3D ZERO
public static final Vector3D PLUS_I
public static final Vector3D MINUS_I
public static final Vector3D PLUS_J
public static final Vector3D MINUS_J
public static final Vector3D PLUS_K
public static final Vector3D MINUS_K
public static final Vector3D NaN
public static final Vector3D POSITIVE_INFINITY
public static final Vector3D NEGATIVE_INFINITY
public Vector3D(double x, double y, double z)
public Vector3D(double[] v) throws DimensionMismatchException
v
 coordinates arrayDimensionMismatchException
 if array does not have 3 elementstoArray()
public Vector3D(double alpha, double delta)
alpha
 azimuth (α) around Z
(0 is +X, π/2 is +Y, π is X and 3π/2 is Y)delta
 elevation (δ) above (XY) plane, from π/2 to +π/2getAlpha()
,
getDelta()
public Vector3D(double a, Vector3D u)
a
 scale factoru
 base (unscaled) vectorpublic Vector3D(double a1, Vector3D u1, double a2, Vector3D u2)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectorpublic Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3)
a1
 first scale factoru1
 first base (unscaled) vectora2
 second scale factoru2
 second base (unscaled) vectora3
 third scale factoru3
 third base (unscaled) vectorpublic Vector3D(double a1, Vector3D u1, double a2, Vector3D u2, double a3, Vector3D u3, double a4, Vector3D 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()
Vector3D(double, double, double)
public double getY()
Vector3D(double, double, double)
public double getZ()
Vector3D(double, double, double)
public double[] toArray()
Vector3D(double[])
public Space getSpace()
getSpace
in interface Vector<Euclidean3D>
public Vector3D getZero()
getZero
in interface Vector<Euclidean3D>
public double getNorm1()
getNorm1
in interface Vector<Euclidean3D>
public double getNorm()
getNorm
in interface Vector<Euclidean3D>
public double getNormSq()
getNormSq
in interface Vector<Euclidean3D>
public double getNormInf()
getNormInf
in interface Vector<Euclidean3D>
public double getAlpha()
Vector3D(double, double)
public double getDelta()
Vector3D(double, double)
public Vector3D add(Vector<Euclidean3D> v)
add
in interface Vector<Euclidean3D>
v
 vector to addpublic Vector3D add(double factor, Vector<Euclidean3D> v)
add
in interface Vector<Euclidean3D>
factor
 scale factor to apply to v before adding itv
 vector to addpublic Vector3D subtract(Vector<Euclidean3D> v)
subtract
in interface Vector<Euclidean3D>
v
 vector to subtractpublic Vector3D subtract(double factor, Vector<Euclidean3D> v)
subtract
in interface Vector<Euclidean3D>
factor
 scale factor to apply to v before subtracting itv
 vector to subtractpublic Vector3D normalize()
normalize
in interface Vector<Euclidean3D>
public Vector3D orthogonal()
There are an infinite number of normalized vectors orthogonal to the instance. This method picks up one of them almost arbitrarily. It is useful when one needs to compute a reference frame with one of the axes in a predefined direction. The following example shows how to build a frame having the k axis aligned with the known vector u :
Vector3D k = u.normalize();
Vector3D i = k.orthogonal();
Vector3D j = Vector3D.crossProduct(k, i);
MathArithmeticException
 if the norm of the instance is nullpublic static double angle(Vector3D v1, Vector3D v2)
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 Vector3D negate()
negate
in interface Vector<Euclidean3D>
public Vector3D scalarMultiply(double a)
scalarMultiply
in interface Vector<Euclidean3D>
a
 scalarpublic boolean isNaN()
isNaN
in interface Vector<Euclidean3D>
public boolean isInfinite()
isInfinite
in interface Vector<Euclidean3D>
public boolean equals(Object other)
If all coordinates of two 3D vectors are exactly the same, and none are
Double.NaN
, the two 3D 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) coordinates of the
3D vector are equal to Double.NaN
, the 3D vector is equal to
NaN
.
public int hashCode()
All NaN values have the same hash code.
public double dotProduct(Vector<Euclidean3D> 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.
dotProduct
in interface Vector<Euclidean3D>
v
 second vectorMathArrays.linearCombination(double, double, double, double, double, double)
public Vector3D crossProduct(Vector<Euclidean3D> v)
v
 other vectorpublic double distance1(Vector<Euclidean3D> v)
Calling this method is equivalent to calling:
q.subtract(p).getNorm1()
except that no intermediate
vector is built
distance1
in interface Vector<Euclidean3D>
v
 second vectorpublic double distance(Vector<Euclidean3D> v)
Calling this method is equivalent to calling:
q.subtract(p).getNorm()
except that no intermediate
vector is built
distance
in interface Vector<Euclidean3D>
v
 second vectorpublic double distanceInf(Vector<Euclidean3D> v)
Calling this method is equivalent to calling:
q.subtract(p).getNormInf()
except that no intermediate
vector is built
distanceInf
in interface Vector<Euclidean3D>
v
 second vectorpublic double distanceSq(Vector<Euclidean3D> v)
Calling this method is equivalent to calling:
q.subtract(p).getNormSq()
except that no intermediate
vector is built
distanceSq
in interface Vector<Euclidean3D>
v
 second vectorpublic static double dotProduct(Vector3D v1, Vector3D v2)
v1
 first vectorv2
 second vectorpublic static Vector3D crossProduct(Vector3D v1, Vector3D v2)
v1
 first vectorv2
 second vectorpublic static double distance1(Vector3D v1, Vector3D v2)
Calling this method is equivalent to calling:
v1.subtract(v2).getNorm1()
except that no intermediate
vector is built
v1
 first vectorv2
 second vectorpublic static double distance(Vector3D v1, Vector3D v2)
Calling this method is equivalent to calling:
v1.subtract(v2).getNorm()
except that no intermediate
vector is built
v1
 first vectorv2
 second vectorpublic static double distanceInf(Vector3D v1, Vector3D v2)
Calling this method is equivalent to calling:
v1.subtract(v2).getNormInf()
except that no intermediate
vector is built
v1
 first vectorv2
 second vectorpublic static double distanceSq(Vector3D v1, Vector3D v2)
Calling this method is equivalent to calling:
v1.subtract(v2).getNormSq()
except that no intermediate
vector is built
v1
 first vectorv2
 second vectorpublic String toString()
public String toString(NumberFormat format)
toString
in interface Vector<Euclidean3D>
format
 the custom format for componentsCopyright © 20032012 The Apache Software Foundation. All Rights Reserved.