us.ihmc.euclid.tuple4D.interfaces

Interface Vector4DBasics

All Superinterfaces:

Clearable, Transformable, Tuple4DBasics, Tuple4DReadOnly, Vector4DReadOnly

All Known Implementing Classes:

Vector4D, Vector4D32

public interface Vector4DBasics
extends Vector4DReadOnly, Tuple4DBasics

Write and read interface for a 4 dimensional vector representing a generic quaternion.

When describing a 4D tuple, its 4 components are often gathered in two groups: the scalar part s and the vector part (x, y, z).

Note on the difference between applying a 3D transform on a quaternion and a 4D vector:

• When transformed by a homogeneous transformation matrix, a quaternion is only pre-multiplied by the rotation part of the transform, resulting in concatenating the orientations of the transform and the quaternion.
• When transformed by a homogeneous transformation matrix, a 4D vector scalar part s remains unchanged. The vector part (x, y, z) is scaled and rotated, and translated by s times the translation part of the transform. Note that for s = 0, a 4D vector behaves as a 3D vector, and for s = 1 it behaves as a 3D point.

Method Summary

Modifier and Type	Method and Description
default void	add(double x, double y, double z, double s) Adds the given (x, y, z, s)-tuple to this vector.
default void	add(Tuple4DReadOnly tupleReadOnly) Adds the given tuple to this vector.
default void	add(Tuple4DReadOnly tuple1, Tuple4DReadOnly tuple2) Sets this vector to the sum of the two given tuples.
default void	addS(double s) Adds the given s to this vector's s-component.
default void	addX(double x) Adds the given x to this vector's x-component.
default void	addY(double y) Adds the given y to this vector's y-component.
default void	addZ(double z) Adds the given z to this vector's z-component.
default void	applyInverseTransform(Transform transform) Performs the inverse the transform on the vector part (x, y, z) of this vector as a 3D vector and translates it by s times the translation part of the transform.
default void	applyTransform(Transform transform) Transforms the vector part (x, y, z) of this vector as a 3D vector and translates it by s times the translation part of the transform.
default void	clipToMax(double max) Clips each component of this vector to a maximum value max.
default void	clipToMin(double min) Clips each component of this vector to a minimum value min.
default void	clipToMinMax(double min, double max) Clips each component of this vector to a minimum value min and a maximum value max.
default void	interpolate(Tuple4DReadOnly tupleReadOnly, double alpha) Performs a linear interpolation from this vector to tupleReadOnly given the percentage alpha.
default void	interpolate(Tuple4DReadOnly tuple1, Tuple4DReadOnly tuple2, double alpha) Performs a linear interpolation from tuple1 to tuple2 given the percentage alpha.
default void	normalize() Normalizes this tuple such that its norm is equal to 1 after calling this method and its direction remains unchanged.
default void	scale(double scalar) Scales the components of this vector by the given scalar.
default void	scale(double scalarX, double scalarY, double scalarZ, double scalarS) Scales independently each component of this vector.
default void	scaleAdd(double scalar, Tuple4DReadOnly tupleReadOnly) Scales this vector and adds tupleReadOnly.
default void	scaleAdd(double scalar, Tuple4DReadOnly tuple1, Tuple4DReadOnly tuple2) Sets this vector to the sum of tuple1 scaled and tuple2.
default void	scaleSub(double scalar, Tuple4DReadOnly tupleReadOnly) Scales this vector and subtracts tupleReadOnly.
default void	scaleSub(double scalar, Tuple4DReadOnly tuple1, Tuple4DReadOnly tuple2) Sets this vector to the difference of tuple1 scaled and tuple2.
default void	set(double x, double y, double z, double s) Sets this tuple's components to x, y, z, and s.
default void	set(Point3DReadOnly point3D) Sets this 4D vector to represent the given 3D point
default void	set(Vector3DReadOnly vector3D) Sets this 4D vector to represent the given 3D vector
default void	setAndClipToMax(double max, Tuple4DReadOnly tupleReadOnly) Sets this vector to tupleReadOnly and then calls clipToMax(double).
default void	setAndClipToMin(double min, Tuple4DReadOnly tupleReadOnly) Sets this vector to tupleReadOnly and then calls clipToMin(double).
default void	setAndClipToMinMax(double min, double max, Tuple4DReadOnly tupleReadOnly) Sets this vector to tupleReadOnly and then calls clipToMinMax(double, double).
default void	setAndScale(double scalar, Tuple4DReadOnly tupleReadOnly) Sets this vector to tupleReadOnly and then scales it scale(double).
default void	setElement(int index, double value) Selects a component of this vector based on index and sets it to value.
void	setS(double s) Sets the s-component of this vector.
default void	setToZero() Sets all the components of this vector to zero.
void	setX(double x) Sets the x-component of this vector.
void	setY(double y) Sets the y-component of this vector.
void	setZ(double z) Sets the z-component of this vector.
default void	sub(double x, double y, double z, double s) Subtracts the given (x, y, z, s)-tuple to this vector.
default void	sub(Tuple4DReadOnly tupleReadOnly) Subtracts the given tuple to this vector.
default void	sub(Tuple4DReadOnly tuple1, Tuple4DReadOnly tuple2) Sets this vector to the difference of the two given tuples.
default void	subS(double s) Subtracts the given s to this vector's s-component.
default void	subX(double x) Subtracts the given x to this vector's x-component.
default void	subY(double y) Subtracts the given y to this vector's y-component.
default void	subZ(double z) Subtracts the given z to this vector's z-component.

Methods inherited from interface us.ihmc.euclid.tuple4D.interfaces.Vector4DReadOnly

geometricallyEquals

Methods inherited from interface us.ihmc.euclid.tuple4D.interfaces.Tuple4DBasics

absolute, containsNaN, negate, set, set, set, set, set, set, set, set, setAndAbsolute, setAndNegate, setAndNormalize, setToNaN

Methods inherited from interface us.ihmc.euclid.tuple4D.interfaces.Tuple4DReadOnly

dot, epsilonEquals, equals, get, get, get, get, get, get, get, getElement, getElement32, getS, getS32, getX, getX32, getY, getY32, getZ, getZ32, norm, normSquared

Method Detail

setX

void setX(double x)

Sets the x-component of this vector.

Parameters:

x - the new x-component's value.

setY

void setY(double y)

Sets the y-component of this vector.

Parameters:

y - the new y-component's value.

setZ

void setZ(double z)

Sets the z-component of this vector.

Parameters:

z - the new z-component's value.

setS

void setS(double s)

Sets the s-component of this vector.

Parameters:

s - the new s-component's value.

setToZero

default void setToZero()

Sets all the components of this vector to zero.

Specified by:

setToZero in interface Clearable

normalize

default void normalize()

Normalizes this tuple such that its norm is equal to 1 after calling this method and its direction remains unchanged.

Edge cases:

• if this tuple contains Double.NaN, this method is ineffective.

Specified by:

normalize in interface Tuple4DBasics

clipToMax

default void clipToMax(double max)

Clips each component of this vector to a maximum value max.

Parameters:

max - the maximum value for each component.

clipToMin

default void clipToMin(double min)

Clips each component of this vector to a minimum value min.

Parameters:

min - the minimum value for each component.

clipToMinMax

default void clipToMinMax(double min,
                          double max)

Clips each component of this vector to a minimum value min and a maximum value max.

Parameters:

min - the minimum value for each component.

max - the maximum value for each component.

setElement

default void setElement(int index,
                        double value)

Selects a component of this vector based on index and sets it to value.

For an index value going from 0 up to 3, the corresponding components are x, y, z, and s, respectively.

Parameters:

index - the index of the component to set.

value - the new value of the selected component.

Throws:

java.lang.IndexOutOfBoundsException - if index ∉ [0, 3].

set

default void set(double x,
                 double y,
                 double z,
                 double s)

Sets this tuple's components to x, y, z, and s.

Specified by:

set in interface Tuple4DBasics

Parameters:

x - the new value for the x-component of this tuple.

y - the new value for the y-component of this tuple.

z - the new value for the z-component of this tuple.

s - the new value for the s-component of this tuple.

set

default void set(Vector3DReadOnly vector3D)

Sets this 4D vector to represent the given 3D vector

this.xyz = vector3D
this.s = 0.0

Parameters:

vector3D - the 3D vector used to set this 4D vector. Not modified.

set

default void set(Point3DReadOnly point3D)

Sets this 4D vector to represent the given 3D point

this.xyz = point3D
this.s = 1.0

Parameters:

point3D - the 3D point used to set this 4D vector. Not modified.

setAndScale

default void setAndScale(double scalar,
                         Tuple4DReadOnly tupleReadOnly)

Sets this vector to tupleReadOnly and then scales it scale(double).

Parameters:

scalar - the scale factor to use on this tuple.

tupleReadOnly - the tuple to copy the values from. Not modified.

setAndClipToMax

default void setAndClipToMax(double max,
                             Tuple4DReadOnly tupleReadOnly)

Sets this vector to tupleReadOnly and then calls clipToMax(double).

Parameters:

max - the maximum value for each component of this tuple.

tupleReadOnly - the tuple to copy the values from. Not modified.

setAndClipToMin

default void setAndClipToMin(double min,
                             Tuple4DReadOnly tupleReadOnly)

Sets this vector to tupleReadOnly and then calls clipToMin(double).

Parameters:

min - the minimum value for each component of this tuple.

tupleReadOnly - the tuple to copy the values from. Not modified.

setAndClipToMinMax

default void setAndClipToMinMax(double min,
                                double max,
                                Tuple4DReadOnly tupleReadOnly)

Sets this vector to tupleReadOnly and then calls clipToMinMax(double, double).

Parameters:

min - the minimum value for each component of this tuple.

max - the maximum value for each component of this tuple.

tupleReadOnly - the tuple to copy the values from. Not modified.

addX

default void addX(double x)

Adds the given x to this vector's x-component.

Parameters:

x - the value to add.

addY

default void addY(double y)

Adds the given y to this vector's y-component.

Parameters:

y - the value to add.

addZ

default void addZ(double z)

Adds the given z to this vector's z-component.

Parameters:

z - the value to add.

addS

default void addS(double s)

Adds the given s to this vector's s-component.

Parameters:

s - the value to add.

add

default void add(double x,
                 double y,
                 double z,
                 double s)

Adds the given (x, y, z, s)-tuple to this vector.

this = this + (x, y, z, s)

Parameters:

x - the value to add to the x-component of this vector.

y - the value to add to the y-component of this vector.

z - the value to add to the z-component of this vector.

s - the value to add to the s-component of this vector.

add

default void add(Tuple4DReadOnly tupleReadOnly)

Adds the given tuple to this vector.

this = this + tupleReadOnly

Parameters:

tupleReadOnly - the tuple to add to this vector.

add

default void add(Tuple4DReadOnly tuple1,
                 Tuple4DReadOnly tuple2)

Sets this vector to the sum of the two given tuples.

this = tuple1 + tuple2

Parameters:

tuple1 - the first tuple to sum. Not modified.

tuple2 - the second tuple to sum. Not modified.

subX

default void subX(double x)

Subtracts the given x to this vector's x-component.

Parameters:

x - the value to add.

subY

default void subY(double y)

Subtracts the given y to this vector's y-component.

Parameters:

y - the value to add.

subZ

default void subZ(double z)

Subtracts the given z to this vector's z-component.

Parameters:

z - the value to add.

subS

default void subS(double s)

Subtracts the given s to this vector's s-component.

Parameters:

s - the value to add.

sub

default void sub(double x,
                 double y,
                 double z,
                 double s)

Subtracts the given (x, y, z, s)-tuple to this vector.

this = this - (x, y, z, s)

Parameters:

x - the value to add to the x-component of this vector.

y - the value to add to the y-component of this vector.

z - the value to add to the z-component of this vector.

s - the value to add to the s-component of this vector.

sub

default void sub(Tuple4DReadOnly tupleReadOnly)

Subtracts the given tuple to this vector.

this = this - tupleReadOnly

Parameters:

tupleReadOnly - the tuple to subtract to this vector.

sub

default void sub(Tuple4DReadOnly tuple1,
                 Tuple4DReadOnly tuple2)

Sets this vector to the difference of the two given tuples.

this = tuple1 - tuple2

Parameters:

tuple1 - the first tuple. Not modified.

tuple2 - the second tuple to subtract to tuple1. Not modified.

scale

default void scale(double scalar)

Scales the components of this vector by the given scalar.

this = scalar * this

Parameters:

scalar - the scale factor to use.

scale

default void scale(double scalarX,
                   double scalarY,
                   double scalarZ,
                   double scalarS)

Scales independently each component of this vector.

 / this.x \   / scalarX * this.x \
 | this.y | = | scalarY * this.y |
 | this.z |   | scalarZ * this.z |
 \ this.s /   \ scalarS * this.s /
 

Parameters:

scalarX - the scalar factor to use on the x-component of this vector.

scalarY - the scalar factor to use on the y-component of this vector.

scalarZ - the scalar factor to use on the z-component of this vector.

scalarS - the scalar factor to use on the s-component of this vector.

scaleAdd

default void scaleAdd(double scalar,
                      Tuple4DReadOnly tupleReadOnly)

Scales this vector and adds tupleReadOnly.

this = scalar * this + tupleReadOnly

Parameters:

scalar - the scale factor to use.

tupleReadOnly - the tuple to add to this. Not modified.

scaleAdd

default void scaleAdd(double scalar,
                      Tuple4DReadOnly tuple1,
                      Tuple4DReadOnly tuple2)

Sets this vector to the sum of tuple1 scaled and tuple2.

this = scalar * tuple1 + tuple2

Parameters:

scalar - the scale factor to use on tuple1.

tuple1 - the first tuple of the sum. Not modified.

tuple2 - the second tuple of the sum. Not modified.

scaleSub

default void scaleSub(double scalar,
                      Tuple4DReadOnly tupleReadOnly)

Scales this vector and subtracts tupleReadOnly.

this = scalar * this - tupleReadOnly

Parameters:

scalar - the scale factor to use.

tupleReadOnly - the tuple to subtract to this. Not modified.

scaleSub

default void scaleSub(double scalar,
                      Tuple4DReadOnly tuple1,
                      Tuple4DReadOnly tuple2)

Sets this vector to the difference of tuple1 scaled and tuple2.

this = scalar * tuple1 - tuple2

Parameters:

scalar - the scale factor to use on tuple1.

tuple1 - the first tuple of the difference. Not modified.

tuple2 - the second tuple of the difference. Not modified.

interpolate

default void interpolate(Tuple4DReadOnly tupleReadOnly,
                         double alpha)

Performs a linear interpolation from this vector to tupleReadOnly given the percentage alpha.

this = (1.0 - alpha) * this + alpha * tupleReadOnly

Parameters:

tupleReadOnly - the tuple used for the interpolation. Not modified.

alpha - the percentage used for the interpolation. A value of 0 will result in not modifying this vector, while a value of 1 is equivalent to setting this vector to tupleReadOnly.

interpolate

default void interpolate(Tuple4DReadOnly tuple1,
                         Tuple4DReadOnly tuple2,
                         double alpha)

Performs a linear interpolation from tuple1 to tuple2 given the percentage alpha.

this = (1.0 - alpha) * tuple1 + alpha * tuple2

Parameters:

tuple1 - the first tuple used in the interpolation. Not modified.

tuple2 - the second tuple used in the interpolation. Not modified.

alpha - the percentage to use for the interpolation. A value of 0 will result in setting this vector to tuple1, while a value of 1 is equivalent to setting this vector to tuple2.

applyTransform

default void applyTransform(Transform transform)

Transforms the vector part (x, y, z) of this vector as a 3D vector and translates it by s times the translation part of the transform. The scalar part (s) remains unchanged.

Note that for s = 0, a 4D vector behaves as a 3D vector, and for s = 1 it behaves as a 3D point.

RigidBodyTransform rotates then translates a vector. QuaternionBasedTransform rotates then translates a vector. AffineTransform scales, rotates, then translates a vector.

Specified by:

applyTransform in interface Transformable

Parameters:

transform - the geometric transform to apply on this vector. Not modified.

applyInverseTransform

default void applyInverseTransform(Transform transform)

Performs the inverse the transform on the vector part (x, y, z) of this vector as a 3D vector and translates it by s times the translation part of the transform. The scalar part (s) remains unchanged.

Note that for s = 0, a 4D vector behaves as a 3D vector, and for s = 1 it behaves as a 3D point.

RigidBodyTransform rotates then translates a vector. QuaternionBasedTransform rotates then translates a vector. AffineTransform scales, rotates, then translates a vector.