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.
Author:

Sylvain Bertrand

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method	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.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

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

- 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.

Interface Vector4DBasics

Method Summary

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

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

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

Method Detail

setX

setY

setZ

setS

setToZero

normalize

clipToMax

clipToMin

clipToMinMax

setElement

set

set

set

setAndScale

setAndClipToMax

setAndClipToMin

setAndClipToMinMax

addX

addY

addZ

addS

add

add

add

subX

subY

subZ

subS

sub

sub

sub

scale

scale

scaleAdd

scaleAdd

scaleSub

scaleSub

interpolate

interpolate

applyTransform

applyInverseTransform