Type Parameters:

RV - is the type of vector that can be returned by this tuple.

RP - is the type of point that can be returned by this tuple.

All Superinterfaces:

Cloneable, JsonableObject, Serializable, Tuple3D<RV>

All Known Subinterfaces:

UnmodifiableVector3D<RV,RP>

All Known Implementing Classes:

ImmutableVector3D, InnerComputationVector3afp, InnerComputationVector3ai, Vector3d, Vector3dfx, Vector3i, Vector3ifx
```
public interface Vector3D<RV extends Vector3D<? super RV,? super RP>,RP extends Point3D<? super RP,? super RV>>
extends Tuple3D<RV>
```
3D Vector.

Version:

17.0 2020-01-04 14:41:43

Author:

Stéphane GALLAND

Maven Group Id:

org.arakhne.afc.core

Maven Artifact Id:

mathgeom

Nested Class Summary

Nested Classes
Modifier and Type Interface Description

static class Vector3D.PowerResult<T extends Vector3D<? super T,?>>
Result of the power of a Vector3D.

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	Description
`default void`	`add(Vector3D<?,?> vector)`	Sets the value of this tuple to the sum of itself and t1.
`default void`	`add(Vector3D<?,?> vector1, Vector3D<?,?> vector2)`	Sets the value of this tuple to the sum of tuples t1 and t2.
`default double`	`angle(Vector3D<?,?> v1)`	Returns the angle in radians between this vector and the vector parameter; the return value is constrained to the range [0, PI].
`default RV`	`cross(Vector3D<?,?> vector)`	Computes the cross product of the this vector and vector v1.
`default void`	`cross(Vector3D<?,?> vector1, Vector3D<?,?> vector2)`	Computes the cross product of the vectors v1 and v2 and put the result in this vector.
`default RV`	`crossLeftHand(Vector3D<?,?> vector)`	Computes the cross product of the this vector and vector v1 as if the vectors are inside a left-hand coordinate system.
`default void`	`crossLeftHand(Vector3D<?,?> vector1, Vector3D<?,?> vector2)`	Computes the cross product of the vectors v1 and v2 as if the vectors are inside a left-hand coordinate system; and put the result in this vector.
`static void`	`crossProduct(double x1, double y1, double z1, double x2, double y2, double z2, CoordinateSystem3D system, Vector3D<?,?> result)`	Computes the cross product of the vectors v1 and v2.
`static void`	`crossProduct(double x1, double y1, double z1, double x2, double y2, double z2, Vector3D<?,?> result)`	Computes the cross product of the vectors v1 and v2.
`static void`	`crossProductLeftHand(double x1, double y1, double z1, double x2, double y2, double z2, Vector3D<?,?> result)`	Computes the cross product of the vectors v1 and v2 as if the vectors are inside a left-hand coordinate system.
`static void`	`crossProductRightHand(double x1, double y1, double z1, double x2, double y2, double z2, Vector3D<?,?> result)`	Computes the cross product of the vectors v1 and v2 as if the vectors are inside a right-hand coordinate system.
`default Vector3D<?,?>`	`crossRightHand(Vector3D<?,?> vector)`	Computes the cross product of the this vector and vector v1 as if the vectors are inside a left-hand coordinate system.
`default void`	`crossRightHand(Vector3D<?,?> vector1, Vector3D<?,?> vector2)`	Computes the cross product of the vectors v1 and v2 as if the vectors are inside a left-hand coordinate system; and put the result in this vector.
`static double`	`determinant(double x1, double y1, double z1, double x2, double y2, double z2, double x3, double y3, double z3)`	Compute the determinant of three vectors.
`default double`	`dot(Vector3D<?,?> vector)`	Computes the dot product of the this vector and vector v1.
`static double`	`dotProduct(double x1, double y1, double z1, double x2, double y2, double z2)`	Compute the dot product of two vectors.
`GeomFactory3D<RV,RP>`	`getGeomFactory()`	Replies the geometry factory associated to this point.
`default double`	`getLength()`	Returns the length of this vector.
`default double`	`getLengthSquared()`	Returns the squared length of this vector.
`default boolean`	`isColinear(Vector3D<?,?> vector)`	Replies if this vector is colinear to the given vector.
`static boolean`	`isCollinearVectors(double x1, double y1, double z1, double x2, double y2, double z2)`	Replies if two vectors are colinear.
`default boolean`	`isUnitVector()`	Replies if this first is a unit vector.
`static boolean`	`isUnitVector(double x, double y, double z)`	Replies if the vector is a unit vector.
`static boolean`	`isUnitVector(double x, double y, double z, double epsilon)`	Replies if the vector is a unit vector.
`default void`	`normalize()`	Normalizes this vector in place.
`default void`	`normalize(Vector3D<?,?> vector)`	Sets the value of this vector to the normalization of vector v1.
`default void`	`operator_add(Vector3D<?,?> v)`	Add a vector to this vector: `this += v`
`default RV`	`operator_divide(double scale)`	Scale this vector: `this / f`.
`default double`	`operator_doubleDotLessThan(Vector3D<?,?> v)`	Replies the signed angle from v to this: `this ..< v`
`default Vector3D<? extends RV,? extends RP>`	`operator_elvis(Vector3D<? extends RV,? extends RP> v)`	If this vector is epsilon equal to zero then reply v else reply this: `this ?: v`
`default boolean`	`operator_equals(Tuple3D<?> v)`	Replies if this vector and the given vector are equal: `this == v`
`default double`	`operator_greaterThanDoubleDot(Vector3D<?,?> v)`	Replies the signed angle from this to v: `this >.. v`
`default RV`	`operator_minus()`	Negation of this vector: `-this`
`default RV`	`operator_minus(Vector3D<?,?> v)`	Subtract a vector to this vector: `this - v`
`default RV`	`operator_multiply(double scale)`	Scale this vector: `this * f`
`default double`	`operator_multiply(Vector3D<?,?> v)`	Dot product: `this * v`
`default boolean`	`operator_notEquals(Tuple3D<?> v)`	Replies if this vector and the given vector are different: `this != v`
`default RP`	`operator_plus(Point3D<?,?> point)`	Add this vector to a point: `this + p`
`default RV`	`operator_plus(Vector3D<?,?> v)`	Sum of this vector and the given vector: `this + v`
`default Vector3D.PowerResult<RV>`	`operator_power(int power)`	Compute the power of this vector: `this ** n`.
`default double`	`operator_power(Vector3D<?,?> v)`	Perp product of this vector and the given vector: `this ** v`.
`default void`	`operator_remove(Vector3D<?,?> v)`	Substract a vector to this vector: `this -= v`
`default double`	`operator_upTo(Vector3D<?,?> v)`	Replies if the absolute angle between this and v: `this .. b`
`default double`	`perp(Vector3D<?,?> vector)`	Compute the determinant of two vectors.
`static double`	`perpProduct(double x1, double y1, double z1, double x2, double y2, double z2)`	Compute the determinant of two vectors.
`default Vector3D.PowerResult<RV>`	`power(int power)`	Compute the power of this vector.
`default void`	`scaleAdd(double scale, Vector3D<?,?> vector)`	Sets the value of this tuple to the scalar multiplication of itself and then adds tuple t1 (this = s*this + t1).
`default void`	`scaleAdd(double scale, Vector3D<?,?> vector1, Vector3D<?,?> vector2)`	Sets the value of this tuple to the scalar multiplication of tuple t1 plus tuple t2 (this = s*t1 + t2).
`default void`	`scaleAdd(int scale, Vector3D<?,?> vector)`	Sets the value of this tuple to the scalar multiplication of itself and then adds tuple t1 (this = s*this + t1).
`default void`	`scaleAdd(int scale, Vector3D<?,?> vector1, Vector3D<?,?> vector2)`	Sets the value of this tuple to the scalar multiplication of tuple t1 plus tuple t2 (this = s*t1 + t2).
`default void`	`setLength(double newLength)`	Change the length of the vector.
`static double`	`signedAngle(double x1, double y1, double z1, double x2, double y2, double z2)`	Compute the signed angle between two vectors.
`default double`	`signedAngle(Vector3D<?,?> vector)`	Compute a signed angle between this vector and the given vector.
`default void`	`sub(Point3D<?,?> point1, Point3D<?,?> point2)`	Sets the value of this tuple to the difference of tuples t1 and t2 (this = t1 - t2).
`default void`	`sub(Vector3D<?,?> vector)`	Sets the value of this tuple to the difference of itself and t1 (this = this - t1).
`default void`	`sub(Vector3D<?,?> vector1, Vector3D<?,?> vector2)`	Sets the value of this tuple to the difference of tuples t1 and t2 (this = t1 - t2).
`default RV`	`toColinearVector(double length)`	Replies a vector of the given length that is colinear to this vector.
`default RV`	`toUnitVector()`	Replies the unit vector of this vector.
`UnmodifiableVector3D<RV,RP>`	`toUnmodifiable()`	Replies an unmodifiable copy of this vector.
`default void`	`turnVector(Vector3D<?,?> axis, double angle)`	Turn this vector about the given rotation angle.

Methods inherited from interface org.arakhne.afc.vmutil.json.JsonableObject
toJson

Methods inherited from interface org.arakhne.afc.math.geometry.d3.Tuple3D
absolute, absolute, add, add, addX, addX, addY, addY, addZ, addZ, clamp, clamp, clamp, clamp, clampMax, clampMax, clampMax, clampMax, clampMin, clampMin, clampMin, clampMin, clone, epsilonEquals, equals, equals, get, get, get, getX, getY, getZ, hashCode, interpolate, interpolate, ix, iy, iz, negate, negate, scale, scale, scale, scale, set, set, set, set, set, setX, setX, setY, setY, setZ, setZ, sub, sub, subX, subX, subY, subY, subZ, subZ

- Method Detail
  - isUnitVector
```
@Pure
static boolean isUnitVector(double x,
                            double y,
                            double z)
```
    Replies if the vector is a unit vector.
    Due to the precision on floating-point computations, the test of unit-vector must consider that the norm of the given vector is approximatively equal to 1. The precision (i.e. the number of significant decimals) is given by MathConstants#UNIT_VECTOR_EPSILON.
    
    Parameters:
    
    x - is the X coordinate of the vector.
    
    y - is the Y coordinate of the vector.
    
    z - is the Z coordinate of the vector.
    
    Returns:
    
    true if the two given vectors are colinear.
    
    See Also:
    
    MathUtil.isEpsilonEqual(double, double, double), MathConstants#UNIT_VECTOR_EPSILON, isUnitVector(double, double, double, double)
  - isUnitVector
```
@Pure
static boolean isUnitVector(double x,
                            double y,
                            double z,
                            double epsilon)
```
    Replies if the vector is a unit vector.
    Due to the precision on floating-point computations, the test of unit-vector must consider that the norm of the given vector is approximatively equal to 1. The precision (i.e. the number of significant decimals) is given by epsilon.
    
    Parameters:
    
    x - is the X coordinate of the vector.
    
    y - is the Y coordinate of the vector.
    
    z - is the Z coordinate of the vector.
    
    epsilon - the precision distance to assumed for equality.
    
    Returns:
    
    true if the two given vectors are colinear.
    
    Since:
    
    13.0
    
    See Also:
    
    MathUtil.isEpsilonEqual(double, double, double), isUnitVector(double, double, double)
  - isUnitVector
```
@Pure
default boolean isUnitVector()
```
    Replies if this first is a unit vector. A unit vector has a length equal to 1.
    This function approximates the test on the length of the vector. This approximation could be based on MathUtil.isEpsilonEqual(double, double).
    
    Returns:
    
    true if the vector has a length equal to 1. false otherwise.
  - determinant
```
@Pure
static double determinant(double x1,
                          double y1,
                          double z1,
                          double x2,
                          double y2,
                          double z2,
                          double x3,
                          double y3,
                          double z3)
```
    Compute the determinant of three vectors.
    
    Parameters:
    
    x1 - is the X coordinate of the first vector
    
    y1 - is the Y coordinate of the first vector
    
    z1 - is the Z coordinate of the first vector
    
    x2 - is the X coordinate of the second vector
    
    y2 - is the Y coordinate of the second vector
    
    z2 - is the Z coordinate of the second vector
    
    x3 - is the X coordinate of the third vector
    
    y3 - is the Y coordinate of the third vector
    
    z3 - is the Z coordinate of the third vector
    
    Returns:
    
    the determinant
    
    See Also:
    
    perpProduct(double, double, double, double, double, double)
  - perpProduct
```
@Pure
static double perpProduct(double x1,
                          double y1,
                          double z1,
                          double x2,
                          double y2,
                          double z2)
```
    Compute the determinant of two vectors.
    det(X1,X2) = |X1|.|X2|.sin(a)
    where X1 and X2 are two vectors and a is the angle between X1 and X2.
    Parameters:
    
    x1 - is the X coordinate of the first vector
    
    y1 - is the Y coordinate of the first vector
    
    z1 - is the Z coordinate of the first vector
    
    x2 - is the X coordinate of the second vector
    
    y2 - is the Y coordinate of the second vector
    
    z2 - is the Z coordinate of the second vector
    
    Returns:
    
    the determinant
    
    See Also:
    
    determinant(double, double, double, double, double, double, double, double, double)
  - isCollinearVectors
```
@Pure
static boolean isCollinearVectors(double x1,
                                  double y1,
                                  double z1,
                                  double x2,
                                  double y2,
                                  double z2)
```
    Replies if two vectors are colinear.
    This function uses the test MathUtil.isEpsilonZero(double).
    
    Parameters:
    
    x1 - is the X coordinate of the first vector
    
    y1 - is the Y coordinate of the first vector
    
    z1 - is the Z coordinate of the first vector
    
    x2 - is the X coordinate of the second vector
    
    y2 - is the Y coordinate of the second vector
    
    z2 - is the Z coordinate of the second vector
    
    Returns:
    
    true if the two given vectors are colinear.
    
    Since:
    
    3.0
    
    See Also:
    
    MathUtil.isEpsilonZero(double)
  - dotProduct
```
@Pure
static double dotProduct(double x1,
                         double y1,
                         double z1,
                         double x2,
                         double y2,
                         double z2)
```
    Compute the dot product of two vectors.
    
    Parameters:
    
    x1 - x coordinate of the first vector.
    
    y1 - y coordinate of the first vector.
    
    z1 - y coordinate of the first vector.
    
    x2 - x coordinate of the second vector.
    
    y2 - y coordinate of the second vector.
    
    z2 - z coordinate of the second vector.
    
    Returns:
    
    the dot product.
  - crossProduct
```
static void crossProduct(double x1,
                         double y1,
                         double z1,
                         double x2,
                         double y2,
                         double z2,
                         Vector3D<?,?> result)
```
    Computes the cross product of the vectors v1 and v2. This function uses the left-handed cross product if the default coordinate system is left-handed. Otherwise, it uses the right-handed cross product. The default coordinate system is given by CoordinateSystem3D.getDefaultCoordinateSystem().
    
    Parameters:
    
    x1 - x coordinate of the vector v1.
    
    y1 - y coordinate of the vector v1.
    
    z1 - z coordinate of the vector v1.
    
    x2 - x coordinate of the vector v2.
    
    y2 - y coordinate of the vector v2.
    
    z2 - z coordinate of the vector v2.
    
    result - is the result of the cross product.
  - crossProduct
```
static void crossProduct(double x1,
                         double y1,
                         double z1,
                         double x2,
                         double y2,
                         double z2,
                         CoordinateSystem3D system,
                         Vector3D<?,?> result)
```
    Computes the cross product of the vectors v1 and v2. This function uses the left-handed cross product if the given coordinate system is left-handed. Otherwise, it uses the right-handed cross product.
    
    Parameters:
    
    x1 - x coordinate of the vector v1.
    
    y1 - y coordinate of the vector v1.
    
    z1 - z coordinate of the vector v1.
    
    x2 - x coordinate of the vector v2.
    
    y2 - y coordinate of the vector v2.
    
    z2 - z coordinate of the vector v2.
    
    system - the coordinate system to consider for computing the cross product.
    
    result - is the result of the cross product.
  - crossProductLeftHand
```
static void crossProductLeftHand(double x1,
                                 double y1,
                                 double z1,
                                 double x2,
                                 double y2,
                                 double z2,
                                 Vector3D<?,?> result)
```
    Computes the cross product of the vectors v1 and v2 as if the vectors are inside a left-hand coordinate system.
    
    Parameters:
    
    x1 - x coordinate of the vector v1.
    
    y1 - y coordinate of the vector v1.
    
    z1 - z coordinate of the vector v1.
    
    x2 - x coordinate of the vector v2.
    
    y2 - y coordinate of the vector v2.
    
    z2 - z coordinate of the vector v2.
    
    result - is the result of the cross product.
  - crossProductRightHand
```
static void crossProductRightHand(double x1,
                                  double y1,
                                  double z1,
                                  double x2,
                                  double y2,
                                  double z2,
                                  Vector3D<?,?> result)
```
    Computes the cross product of the vectors v1 and v2 as if the vectors are inside a right-hand coordinate system.
    
    Parameters:
    
    x1 - x coordinate of the vector v1.
    
    y1 - y coordinate of the vector v1.
    
    z1 - z coordinate of the vector v1.
    
    x2 - x coordinate of the vector v2.
    
    y2 - y coordinate of the vector v2.
    
    z2 - z coordinate of the vector v2.
    
    result - is the result of the cross product.
  - signedAngle
```
@Pure
static double signedAngle(double x1,
                          double y1,
                          double z1,
                          double x2,
                          double y2,
                          double z2)
```
    Compute the signed angle between two vectors.
    
    Parameters:
    
    x1 - is the X coordinate of the first vector
    
    y1 - is the Y coordinate of the first vector
    
    z1 - is the Z coordinate of the first vector
    
    x2 - is the X coordinate of the second vector
    
    y2 - is the Y coordinate of the second vector
    
    z2 - is the Z coordinate of the second vector
    
    Returns:
    
    the angle between -PI and PI.
  - signedAngle
```
@Pure
default double signedAngle(Vector3D<?,?> vector)
```
    Compute a signed angle between this vector and the given vector.
    The signed angle between this vector and the given vector is the rotation angle to apply to this vector to be colinear to the given vector and pointing the same demi-plane. It means that the angle replied by this function is be negative if the rotation to apply is clockwise, and positive if the rotation is counterclockwise.
    The value replied by angle(Vector3D) is the absolute value of the vlaue replied by this function.
    
    Parameters:
    
    vector - is the vector to reach.
    
    Returns:
    
    the rotation angle to turn this vector to reach v.
  - add
```
default void add(Vector3D<?,?> vector1,
                 Vector3D<?,?> vector2)
```
    Sets the value of this tuple to the sum of tuples t1 and t2.
    
    Parameters:
    
    vector1 - the first tuple
    
    vector2 - the second tuple
  - add
```
default void add(Vector3D<?,?> vector)
```
    Sets the value of this tuple to the sum of itself and t1.
    
    Parameters:
    
    vector - the other tuple
  - scaleAdd
```
default void scaleAdd(int scale,
                      Vector3D<?,?> vector1,
                      Vector3D<?,?> vector2)
```
    Sets the value of this tuple to the scalar multiplication of tuple t1 plus tuple t2 (this = s*t1 + t2).
    
    Parameters:
    
    scale - the scalar value
    
    vector1 - the tuple to be multipled
    
    vector2 - the tuple to be added
  - scaleAdd
```
default void scaleAdd(double scale,
                      Vector3D<?,?> vector1,
                      Vector3D<?,?> vector2)
```
    Sets the value of this tuple to the scalar multiplication of tuple t1 plus tuple t2 (this = s*t1 + t2).
    
    Parameters:
    
    scale - the scalar value
    
    vector1 - the tuple to be multipled
    
    vector2 - the tuple to be added
  - scaleAdd
```
default void scaleAdd(int scale,
                      Vector3D<?,?> vector)
```
    Sets the value of this tuple to the scalar multiplication of itself and then adds tuple t1 (this = s*this + t1).
    
    Parameters:
    
    scale - the scalar value
    
    vector - the tuple to be added
  - scaleAdd
```
default void scaleAdd(double scale,
                      Vector3D<?,?> vector)
```
    Sets the value of this tuple to the scalar multiplication of itself and then adds tuple t1 (this = s*this + t1).
    
    Parameters:
    
    scale - the scalar value
    
    vector - the tuple to be added
  - sub
```
default void sub(Vector3D<?,?> vector1,
                 Vector3D<?,?> vector2)
```
    Sets the value of this tuple to the difference of tuples t1 and t2 (this = t1 - t2).
    
    Parameters:
    
    vector1 - the first tuple
    
    vector2 - the second tuple
  - sub
```
default void sub(Point3D<?,?> point1,
                 Point3D<?,?> point2)
```
    Sets the value of this tuple to the difference of tuples t1 and t2 (this = t1 - t2).
    
    Parameters:
    
    point1 - the first tuple
    
    point2 - the second tuple
  - sub
```
default void sub(Vector3D<?,?> vector)
```
    Sets the value of this tuple to the difference of itself and t1 (this = this - t1).
    
    Parameters:
    
    vector - the other tuple
  - power
```
@Pure
default Vector3D.PowerResult<RV> power(int power)
```
    Compute the power of this vector.
    If the power is even, the result is a scalar. If the power is odd, the result is a vector.
    
    Parameters:
    
    power - the power factor.
    
    Returns:
    
    the power of this vector.
    
    See Also:
    
    "http://www.euclideanspace.com/maths/algebra/vectors/vecAlgebra/powers/index.htm"
  - dot
```
@Pure
default double dot(Vector3D<?,?> vector)
```
    Computes the dot product of the this vector and vector v1.
    
    Parameters:
    
    vector - the other vector
    
    Returns:
    
    the dot product.
  - perp
```
@Pure
default double perp(Vector3D<?,?> vector)
```
    Compute the determinant of two vectors.
    det(this, V) = |this|.|V|.sin(a)
    where this and V are two vectors and a is the angle between this and V.
    Parameters:
    
    vector - the vector.
    
    Returns:
    
    the perp product.
  - cross
```
@Pure
default RV cross(Vector3D<?,?> vector)
```
    Computes the cross product of the this vector and vector v1. The coordinate system's standard depends on the underlying implementation of the API. One of crossLeftHand(Vector3D) or crossRightHand(Vector3D) will be invoked by this function.
    
    Parameters:
    
    vector - the other vector.
    
    Returns:
    
    the cross product.
    
    See Also:
    
    crossLeftHand(Vector3D), crossRightHand(Vector3D)
  - cross
```
default void cross(Vector3D<?,?> vector1,
                   Vector3D<?,?> vector2)
```
    Computes the cross product of the vectors v1 and v2 and put the result in this vector. The coordinate system's standard depends on the underlying implementation of the API. One of crossLeftHand(Vector3D, Vector3D) or crossRightHand(Vector3D, Vector3D) will be invoked by this function.
    
    Parameters:
    
    vector1 - the left operand.
    
    vector2 - the right operand.
    
    See Also:
    
    crossLeftHand(Vector3D, Vector3D), crossRightHand(Vector3D, Vector3D)
  - crossLeftHand
```
@Pure
default RV crossLeftHand(Vector3D<?,?> vector)
```
    Computes the cross product of the this vector and vector v1 as if the vectors are inside a left-hand coordinate system.
    
    Parameters:
    
    vector - the other vector
    
    Returns:
    
    the dot product.
  - crossLeftHand
```
default void crossLeftHand(Vector3D<?,?> vector1,
                           Vector3D<?,?> vector2)
```
    Computes the cross product of the vectors v1 and v2 as if the vectors are inside a left-hand coordinate system; and put the result in this vector.
    
    Parameters:
    
    vector1 - the left operand.
    
    vector2 - the right operand.
  - crossRightHand
```
@Pure
default Vector3D<?,?> crossRightHand(Vector3D<?,?> vector)
```
    Computes the cross product of the this vector and vector v1 as if the vectors are inside a left-hand coordinate system.
    
    Parameters:
    
    vector - the other vector
    
    Returns:
    
    the dot product.
  - crossRightHand
```
default void crossRightHand(Vector3D<?,?> vector1,
                            Vector3D<?,?> vector2)
```
    Computes the cross product of the vectors v1 and v2 as if the vectors are inside a left-hand coordinate system; and put the result in this vector.
    
    Parameters:
    
    vector1 - the left operand
    
    vector2 - the right operand
  - getLength
```
@Pure
default double getLength()
```
    Returns the length of this vector.
    
    Returns:
    
    the length of this vector
  - getLengthSquared
```
@Pure
default double getLengthSquared()
```
    Returns the squared length of this vector.
    
    Returns:
    
    the squared length of this vector
  - normalize
```
default void normalize(Vector3D<?,?> vector)
```
    Sets the value of this vector to the normalization of vector v1.
    
    Parameters:
    
    vector - the un-normalized vector
  - normalize
```
default void normalize()
```
    Normalizes this vector in place.
  - angle
```
@Pure
default double angle(Vector3D<?,?> v1)
```
    Returns the angle in radians between this vector and the vector parameter; the return value is constrained to the range [0, PI].
    
    Parameters:
    
    v1 - the other vector
    
    Returns:
    
    the angle in radians in the range [0, PI]
  - turnVector
```
default void turnVector(Vector3D<?,?> axis,
                        double angle)
```
    Turn this vector about the given rotation angle.
    
    Parameters:
    
    axis - is the axis of rotation.
    
    angle - is the rotation angle in radians.
  - isColinear
```
@Pure
default boolean isColinear(Vector3D<?,?> vector)
```
    Replies if this vector is colinear to the given vector.
    
    Parameters:
    
    vector - the vector
    
    Returns:
    
    true if the vectors are colinear..
  - setLength
```
default void setLength(double newLength)
```
    Change the length of the vector. The direction of the vector is unchanged.
    
    Parameters:
    
    newLength - - the new length.
  - toUnitVector
```
@Pure
default RV toUnitVector()
```
    Replies the unit vector of this vector.
    
    Returns:
    
    the unit vector of this vector.
  - toColinearVector
```
@Pure
default RV toColinearVector(double length)
```
    Replies a vector of the given length that is colinear to this vector.
    
    Parameters:
    
    length - the length of the new vector.
    
    Returns:
    
    the colinear vector.
  - toUnmodifiable
```
@Pure
UnmodifiableVector3D<RV,RP> toUnmodifiable()
```
    Replies an unmodifiable copy of this vector.
    
    Returns:
    
    an unmodifiable copy.
  - getGeomFactory
```
@Pure
GeomFactory3D<RV,RP> getGeomFactory()
```
    Replies the geometry factory associated to this point.
    
    Returns:
    
    the factory.
  - operator_add
```
default void operator_add(Vector3D<?,?> v)
```
    Add a vector to this vector: this += v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector
    
    See Also:
    
    add(Vector3D)
  - operator_remove
```
default void operator_remove(Vector3D<?,?> v)
```
    Substract a vector to this vector: this -= v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector
    
    See Also:
    
    sub(Vector3D)
  - operator_multiply
```
@Pure
default double operator_multiply(Vector3D<?,?> v)
```
    Dot product: this * v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector
    
    Returns:
    
    the result.
    
    See Also:
    
    dot(Vector3D)
  - operator_multiply
```
@Pure
default RV operator_multiply(double scale)
```
    Scale this vector: this * f
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    scale - the scaling factor.
    
    Returns:
    
    the scaled vector.
    
    See Also:
    
    Tuple3D.scale(double)
  - operator_equals
```
@Pure
default boolean operator_equals(Tuple3D<?> v)
```
    Replies if this vector and the given vector are equal: this == v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector.
    
    Returns:
    
    test result.
    
    See Also:
    
    Tuple3D.equals(Tuple3D)
  - operator_notEquals
```
@Pure
default boolean operator_notEquals(Tuple3D<?> v)
```
    Replies if this vector and the given vector are different: this != v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector.
    
    Returns:
    
    test result.
    
    See Also:
    
    Tuple3D.equals(Tuple3D)
  - operator_upTo
```
@Pure
default double operator_upTo(Vector3D<?,?> v)
```
    Replies if the absolute angle between this and v: this .. b
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector.
    
    Returns:
    
    the signed angle.
    
    See Also:
    
    angle(Vector3D)
  - operator_greaterThanDoubleDot
```
@Pure
default double operator_greaterThanDoubleDot(Vector3D<?,?> v)
```
    Replies the signed angle from this to v: this >.. v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector.
    
    Returns:
    
    the signed angle.
    
    See Also:
    
    signedAngle(Vector3D)
  - operator_doubleDotLessThan
```
@Pure
default double operator_doubleDotLessThan(Vector3D<?,?> v)
```
    Replies the signed angle from v to this: this ..< v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector.
    
    Returns:
    
    the signed angle.
    
    See Also:
    
    signedAngle(Vector3D)
  - operator_minus
```
@Pure
default RV operator_minus(Vector3D<?,?> v)
```
    Subtract a vector to this vector: this - v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector
    
    Returns:
    
    the result.
    
    See Also:
    
    sub(Vector3D)
  - operator_minus
```
@Pure
default RV operator_minus()
```
    Negation of this vector: -this
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Returns:
    
    the result.
    
    See Also:
    
    Tuple3D.negate(Tuple3D)
  - operator_divide
```
@Pure
default RV operator_divide(double scale)
```
    Scale this vector: this / f.
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    scale - the scaling factor
    
    Returns:
    
    the scaled vector.
  - operator_elvis
```
@Pure
default Vector3D<? extends RV,? extends RP> operator_elvis(Vector3D<? extends RV,? extends RP> v)
```
    If this vector is epsilon equal to zero then reply v else reply this: this ?: v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector.
    
    Returns:
    
    the vector.
  - operator_plus
```
@Pure
default RV operator_plus(Vector3D<?,?> v)
```
    Sum of this vector and the given vector: this + v
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the vector
    
    Returns:
    
    the result.
    
    See Also:
    
    add(Vector3D, Vector3D)
  - operator_plus
```
@Pure
default RP operator_plus(Point3D<?,?> point)
```
    Add this vector to a point: this + p
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    point - the point.
    
    Returns:
    
    the result.
    
    See Also:
    
    Point3D.add(Vector3D, Point3D)
  - operator_power
```
@Pure
default double operator_power(Vector3D<?,?> v)
```
    Perp product of this vector and the given vector: this ** v.
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    v - the other vector.
    
    Returns:
    
    the result.
    
    See Also:
    
    perp(Vector3D)
  - operator_power
```
@Pure
default Vector3D.PowerResult<RV> operator_power(int power)
```
    Compute the power of this vector: this ** n.
    If the power is even, the result is a scalar. If the power is odd, the result is a vector.
    This function is an implementation of the "-" operator for the languages that defined or based on the Xtext framework.
    
    Parameters:
    
    power - the power factor.
    
    Returns:
    
    the power of this vector.
    
    See Also:
    
    power(int), "http://www.euclideanspace.com/maths/algebra/vectors/vecAlgebra/powers/index.htm"

Interface Vector3D<RV extends Vector3D<? super RV,​? super RP>,​RP extends Point3D<? super RP,​? super RV>>

Nested Class Summary

Method Summary

Methods inherited from interface org.arakhne.afc.vmutil.json.JsonableObject

Methods inherited from interface org.arakhne.afc.math.geometry.d3.Tuple3D

Method Detail

isUnitVector

isUnitVector

isUnitVector

determinant

perpProduct

isCollinearVectors

dotProduct

crossProduct

crossProduct

crossProductLeftHand

crossProductRightHand

signedAngle

signedAngle

add

add

scaleAdd

scaleAdd

scaleAdd

scaleAdd

sub

sub

sub

power

dot

perp

cross

cross

crossLeftHand

crossLeftHand

crossRightHand

crossRightHand

getLength

getLengthSquared

normalize

normalize

angle

turnVector

isColinear

setLength

toUnitVector

toColinearVector

toUnmodifiable

getGeomFactory

operator_add

operator_remove

operator_multiply

operator_multiply

operator_equals

operator_notEquals

operator_upTo

operator_greaterThanDoubleDot

operator_doubleDotLessThan

operator_minus

operator_minus

operator_divide

operator_elvis

operator_plus

operator_plus

operator_power

operator_power

Interface Vector3D<RV extends Vector3D<? super RV,? super RP>,RP extends Point3D<? super RP,? super RV>>