Interface Vector3D<RV extends Vector3D<? super RV,? super RP>,RP extends Point3D<? super RP,? super RV>>
-
- 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 vectory1
- is the Y coordinate of the first vectorz1
- is the Z coordinate of the first vectorx2
- is the X coordinate of the second vectory2
- is the Y coordinate of the second vectorz2
- is the Z coordinate of the second vectorx3
- is the X coordinate of the third vectory3
- is the Y coordinate of the third vectorz3
- 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.
wheredet(X1,X2) = |X1|.|X2|.sin(a)
X1
andX2
are two vectors anda
is the angle betweenX1
andX2
.- Parameters:
x1
- is the X coordinate of the first vectory1
- is the Y coordinate of the first vectorz1
- is the Z coordinate of the first vectorx2
- is the X coordinate of the second vectory2
- is the Y coordinate of the second vectorz2
- 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 vectory1
- is the Y coordinate of the first vectorz1
- is the Z coordinate of the first vectorx2
- is the X coordinate of the second vectory2
- is the Y coordinate of the second vectorz2
- 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 theleft-handed cross product
if the default coordinate system is left-handed. Otherwise, it uses theright-handed cross product
. The default coordinate system is given byCoordinateSystem3D.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 theleft-handed cross product
if the given coordinate system is left-handed. Otherwise, it uses theright-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 vectory1
- is the Y coordinate of the first vectorz1
- is the Z coordinate of the first vectorx2
- is the X coordinate of the second vectory2
- is the Y coordinate of the second vectorz2
- is the Z coordinate of the second vector- Returns:
- the angle between
-PI
andPI
.
-
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 givenvector
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 tuplevector2
- 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 valuevector1
- the tuple to be multipledvector2
- 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 valuevector1
- the tuple to be multipledvector2
- 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 valuevector
- 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 valuevector
- 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 tuplevector2
- 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 tuplepoint2
- 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.
wheredet(this, V) = |this|.|V|.sin(a)
this
andV
are two vectors anda
is the angle betweenthis
andV
.- 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 ofcrossLeftHand(Vector3D)
orcrossRightHand(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 ofcrossLeftHand(Vector3D, Vector3D)
orcrossRightHand(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 operandvector2
- 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"
-
-