AxisAngleBasics (euclid-core 0.5.1 API)

All Superinterfaces:

AxisAngleReadOnly, Clearable, Orientation3DBasics, Orientation3DReadOnly

All Known Implementing Classes:

AxisAngle, AxisAngle32
```
public interface AxisAngleBasics
extends AxisAngleReadOnly, Orientation3DBasics, Clearable
```
Write and read interface for an axis-angle object.
An axis-angle is used to represent a 3D orientation by a unitary axis of components (x, y, z) and an angle of rotation usually expressed in radians.

Field Summary
- Fields inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DReadOnly
  ORIENTATION_2D_EPSILON

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`default void`	`absolute()` Sets each component of this axis-angle to its absolute value.
`default void`	`append(Orientation3DReadOnly other)` Appends the given orientation to this orientation.
`default void`	`appendInvertOther(Orientation3DReadOnly orientation)` Appends the inverse of the given orientation to this orientation.
`default void`	`appendPitchRotation(double pitch)` Append a rotation about the y-axis to this axis-angle.
`default void`	`appendRollRotation(double roll)` Append a rotation about the x-axis to this axis-angle.
`default void`	`appendYawRotation(double yaw)` Append a rotation about the z-axis to this axis-angle.
`default boolean`	`containsNaN()` Tests if this axis-angle contains a `Double.NaN`.
`default void`	`inverse()` Deprecated. Use `invert()` instead.
`default void`	`invert()` Inverses this orientation.
`default void`	`multiply(AxisAngleReadOnly other)` Multiplies this axis-angle by `other`.
`default void`	`multiply(AxisAngleReadOnly aa1, AxisAngleReadOnly aa2)` Sets this axis-angle to the multiplication of `aa1` and `aa2`.
`default void`	`multiplyInvertBoth(AxisAngleReadOnly other)` Sets this axis-angle to the multiplication of the inverse of `this` and the inverse of `other`.
`default void`	`multiplyInvertOther(AxisAngleReadOnly other)` Multiplies this axis-angle by the inverse of `other`.
`default void`	`multiplyInvertThis(AxisAngleReadOnly other)` Sets this axis-angle to the multiplication of the inverse of `this` and `other`.
`default void`	`negate()` Negates each component of this axis-angle.
`default void`	`normalize()` Normalizes the axis of this axis-angle such that its norm is equal to 1 after calling this method and its direction remains unchanged.
`default void`	`normalizeAxis()` Deprecated. Use `normalize()` instead
`default void`	`preMultiply(AxisAngleReadOnly other)` Pre-multiplies this axis-angle by `other`.
`default void`	`preMultiplyInvertBoth(AxisAngleReadOnly other)` Sets this axis-angle to the multiplication of the inverse of `other` and the inverse of `this`.
`default void`	`preMultiplyInvertOther(AxisAngleReadOnly other)` Sets this axis-angle to the multiplication of the inverse of `other` and `this`.
`default void`	`preMultiplyInvertThis(AxisAngleReadOnly other)` Sets this axis-angle to the multiplication of `other` and the inverse of `this`.
`default void`	`prepend(Orientation3DReadOnly orientation)` Prepends the given orientation to this orientation.
`default void`	`prependInvertOther(Orientation3DReadOnly orientation)` Prepends the inverse of the given orientation to this orientation.
`default void`	`prependPitchRotation(double pitch)` Prepend a rotation about the y-axis to this axis-angle.
`default void`	`prependRollRotation(double roll)` Prepend a rotation about the x-axis to this axis-angle.
`default void`	`prependYawRotation(double yaw)` Prepend a rotation about the z-axis to this axis-angle.
`default void`	`scaleAngle(double scale)` Multiplies the angle of this axis-angle by the given `scale`.
`default void`	`set(AxisAngleReadOnly other)` Sets this axis-angle to the same value as the given axis-angle `other`.
`default void`	`set(double[] axisAngleArray)` Copies the values in the given array into this axis-angle as follows: `this.setX(axisAngleArray[0]);` `this.setY(axisAngleArray[1]);` `this.setZ(axisAngleArray[2]);` `this.setAngle(axisAngleArray[3]);`
`default void`	`set(double x, double y, double z, double angle)` Sets this axis-angle to represent a new rotation of axis (`x`, `y`, `z`) and angle of `angle`.
`default void`	`set(float[] axisAngleArray)` Copies the values in the given array into this axis-angle as follows: `this.setX(axisAngleArray[0]);` `this.setY(axisAngleArray[1]);` `this.setZ(axisAngleArray[2]);` `this.setAngle(axisAngleArray[3]);`
`default void`	`set(int startIndex, double[] axisAngleArray)` Copies the values in the given array into this axis-angle as follows: `this.setX(axisAngleArray[startIndex + 0]);` `this.setY(axisAngleArray[startIndex + 1]);` `this.setZ(axisAngleArray[startIndex + 2]);` `this.setAngle(axisAngleArray[startIndex + 3]);`
`default void`	`set(int startIndex, float[] axisAngleArray)` Copies the values in the given array into this axis-angle as follows: `this.setX(axisAngleArray[startIndex + 0]);` `this.setY(axisAngleArray[startIndex + 1]);` `this.setZ(axisAngleArray[startIndex + 2]);` `this.setAngle(axisAngleArray[startIndex + 3]);`
`default void`	`set(Orientation3DReadOnly orientation3DReadOnly)` Converts, if necessary, and sets this orientation to represents the same orientation as `orientation3DReadOnly`.
`default void`	`set(Vector3DReadOnly axis, double angle)` Sets the axis and the angle of this axis-angle.
`default void`	`setAndNegate(AxisAngleReadOnly other)` Sets this axis-angle to `other` and then calls `negate()`.
`void`	`setAngle(double angle)` Sets a new angle to this axis-angle.
`default void`	`setAxisAngle(double x, double y, double z, double angle)` Sets this orientation to represents the same orientation as an axis-angle given its 4 components.
`default void`	`setElement(int index, double value)` Selects a component of this axis-angle based on `index` and sets it to `value`.
`default void`	`setQuaternion(double x, double y, double z, double s)` Sets this orientation to represents the same orientation as a quaternion given its 4 components.
`default void`	`setRotationMatrix(double m00, double m01, double m02, double m10, double m11, double m12, double m20, double m21, double m22)` Sets this orientation to represents the same orientation as a rotation matrix given its 9 components.
`default void`	`setRotationVector(double x, double y, double z)` Sets this orientation to represents the same orientation as a rotation vector given its 3 components.
`default void`	`setToNaN()` Sets the components of this axis-angle to `Double.NaN`.
`default void`	`setToZero()` Sets the components of this axis-angle to represent a "zero" rotation.
`void`	`setX(double x)` Sets a new x-component for the axis of this axis-angle.
`void`	`setY(double y)` Sets a new y-component for the axis of this axis-angle.
`default void`	`setYawPitchRoll(double yaw, double pitch, double roll)` Sets this orientation to represents the same orientation as a yaw-pitch-roll representation.
`void`	`setZ(double z)` Sets a new z-component for the axis of this axis-angle.

Methods inherited from interface us.ihmc.euclid.axisAngle.interfaces.AxisAngleReadOnly
addTransform, axisNorm, checkIfIsZOnly, distance, epsilonEquals, equals, geometricallyEquals, get, get, get, get, get, get, get, getAngle, getAngle32, getElement, getElement32, getEuler, getPitch, getRoll, getRotationVector, getX, getX32, getY, getY32, getYaw, getYawPitchRoll, getZ, getZ32, inverseTransform, inverseTransform, inverseTransform, inverseTransform, isAxisUnitary, isOrientation2D, isZOnly, transform, transform, transform, transform

Methods inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DBasics
appendInvertBoth, appendInvertThis, prependInvertBoth, prependInvertThis, setAndInvert, setAndNormalize, setEuler, setEuler, setRotationVector, setYawPitchRoll

Methods inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DReadOnly
addTransform, checkIfOrientation2D, checkIfOrientation2D, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, inverseTransform, isOrientation2D, toStringAsYawPitchRoll, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform, transform

- Method Detail
  - setAngle
```
void setAngle(double angle)
```
    Sets a new angle to this axis-angle.
    
    Parameters:
    
    angle - the new angle.
  - setX
```
void setX(double x)
```
    Sets a new x-component for the axis of this axis-angle.
    
    Parameters:
    
    x - the new axis x-component.
  - setY
```
void setY(double y)
```
    Sets a new y-component for the axis of this axis-angle.
    
    Parameters:
    
    y - the new axis y-component.
  - setZ
```
void setZ(double z)
```
    Sets a new z-component for the axis of this axis-angle.
    
    Parameters:
    
    z - the new axis z-component.
  - setToZero
```
default void setToZero()
```
    Sets the components of this axis-angle to represent a "zero" rotation. After calling the axis is equal to (1, 0, 0) and the angle to 0.
    
    Specified by:
    
    setToZero in interface Clearable
  - setToNaN
```
default void setToNaN()
```
    Sets the components of this axis-angle to Double.NaN.
    
    Specified by:
    
    setToNaN in interface Clearable
  - containsNaN
```
default boolean containsNaN()
```
    Tests if this axis-angle contains a Double.NaN.
    
    Specified by:
    
    containsNaN in interface AxisAngleReadOnly
    
    Specified by:
    
    containsNaN in interface Clearable
    
    Returns:
    
    true if this axis-angle contains a Double.NaN, false otherwise.
  - absolute
```
default void absolute()
```
    Sets each component of this axis-angle to its absolute value.
  - negate
```
default void negate()
```
    Negates each component of this axis-angle.
  - inverse
```
@Deprecated
default void inverse()
```
    Deprecated. Use invert() instead.
    
    Sets this axis-angle to its inverse.
  - invert
```
default void invert()
```
    Inverses this orientation.
    If this orientation describes the orientation of a coordinate system A with respect to a coordinate system B, after this method, the orientation will describe the orientation of B with respect to A.
    
    Note that appending or prepending an orientation with its inverse will result into a "zero" orientation.
    
    Specified by:
    
    invert in interface Orientation3DBasics
  - normalizeAxis
```
@Deprecated
default void normalizeAxis()
```
    Deprecated. Use normalize() instead
    Normalizes the axis of this axis-angle such that its norm is equal to 1 after calling this method and its direction remains unchanged.
    Edge cases:
    - if this axis-angle contains Double.NaN, this method is ineffective.
  - normalize
```
default void normalize()
```
    Normalizes the axis of this axis-angle such that its norm is equal to 1 after calling this method and its direction remains unchanged.
    Edge cases:
    - if this axis-angle contains Double.NaN, this method is ineffective.
    Specified by:
    
    normalize in interface Orientation3DBasics
  - scaleAngle
```
default void scaleAngle(double scale)
```
    Multiplies the angle of this axis-angle by the given scale.
    
    Parameters:
    
    scale - the scaling factor to apply to the angle of this axis-angle.
  - set
```
default void set(double x,
                 double y,
                 double z,
                 double angle)
```
    Sets this axis-angle to represent a new rotation of axis (x, y, z) and angle of angle.
    
    Parameters:
    
    x - x-component of the new axis.
    
    y - y-component of the new axis.
    
    z - z-component of the new axis.
    
    angle - the new angle.
  - set
```
default void set(Orientation3DReadOnly orientation3DReadOnly)
```
    Converts, if necessary, and sets this orientation to represents the same orientation as orientation3DReadOnly.
    
    Specified by:
    
    set in interface Orientation3DBasics
    
    Parameters:
    
    orientation3DReadOnly - the new orientation. Not modified.
  - set
```
default void set(Vector3DReadOnly axis,
                 double angle)
```
    Sets the axis and the angle of this axis-angle.
    
    Parameters:
    
    axis - the new axis. Not modified.
    
    angle - the new angle.
  - set
```
default void set(AxisAngleReadOnly other)
```
    Sets this axis-angle to the same value as the given axis-angle other.
    
    Parameters:
    
    other - the other axis-angle. Not modified.
  - setAndNegate
```
default void setAndNegate(AxisAngleReadOnly other)
```
    Sets this axis-angle to other and then calls negate().
    
    Parameters:
    
    other - the other axis-angle to copy the values from. Not modified.
  - set
```
default void set(double[] axisAngleArray)
```
    Copies the values in the given array into this axis-angle as follows:
    - this.setX(axisAngleArray[0]);
    - this.setY(axisAngleArray[1]);
    - this.setZ(axisAngleArray[2]);
    - this.setAngle(axisAngleArray[3]);
    Parameters:
    
    axisAngleArray - the array containing the new values for this axis-angle. Not modified.
  - set
```
default void set(int startIndex,
                 double[] axisAngleArray)
```
    Copies the values in the given array into this axis-angle as follows:
    - this.setX(axisAngleArray[startIndex + 0]);
    - this.setY(axisAngleArray[startIndex + 1]);
    - this.setZ(axisAngleArray[startIndex + 2]);
    - this.setAngle(axisAngleArray[startIndex + 3]);
    Parameters:
    
    startIndex - the first index to start reading from in the array.
    
    axisAngleArray - the array containing the new values for this axis-angle. Not modified.
  - set
```
default void set(float[] axisAngleArray)
```
    Copies the values in the given array into this axis-angle as follows:
    - this.setX(axisAngleArray[0]);
    - this.setY(axisAngleArray[1]);
    - this.setZ(axisAngleArray[2]);
    - this.setAngle(axisAngleArray[3]);
    Parameters:
    
    axisAngleArray - the array containing the new values for this axis-angle. Not modified.
  - set
```
default void set(int startIndex,
                 float[] axisAngleArray)
```
    Copies the values in the given array into this axis-angle as follows:
    - this.setX(axisAngleArray[startIndex + 0]);
    - this.setY(axisAngleArray[startIndex + 1]);
    - this.setZ(axisAngleArray[startIndex + 2]);
    - this.setAngle(axisAngleArray[startIndex + 3]);
    Parameters:
    
    startIndex - the first index to start reading from in the array.
    
    axisAngleArray - the array containing the new values for this axis-angle. Not modified.
  - setAxisAngle
```
default void setAxisAngle(double x,
                          double y,
                          double z,
                          double angle)
```
    Sets this orientation to represents the same orientation as an axis-angle given its 4 components.
    
    Specified by:
    
    setAxisAngle in interface Orientation3DBasics
    
    Parameters:
    
    x - x-component of the axis part of the axis-angle.
    
    y - y-component of the axis part of the axis-angle.
    
    z - z-component of the axis part of the axis-angle.
    
    angle - the angle part of the axis-angle.
  - setQuaternion
```
default void setQuaternion(double x,
                           double y,
                           double z,
                           double s)
```
    Sets this orientation to represents the same orientation as a quaternion given its 4 components.
    
    Specified by:
    
    setQuaternion in interface Orientation3DBasics
    
    Parameters:
    
    x - the x-component of the quaternion.
    
    y - the y-component of the quaternion.
    
    z - the z-component of the quaternion.
    
    s - the s-component of the quaternion.
  - setRotationVector
```
default void setRotationVector(double x,
                               double y,
                               double z)
```
    Sets this orientation to represents the same orientation as a rotation vector given its 3 components.
    WARNING: a rotation vector is different from a yaw-pitch-roll or Euler angles representation. A rotation vector is equivalent to the axis of an axis-angle that is multiplied by the angle of the same axis-angle.
    
    Specified by:
    
    setRotationVector in interface Orientation3DBasics
    
    Parameters:
    
    x - the x-component of the rotation vector.
    
    y - the y-component of the rotation vector.
    
    z - the z-component of the rotation vector.
  - setYawPitchRoll
```
default void setYawPitchRoll(double yaw,
                             double pitch,
                             double roll)
```
    Sets this orientation to represents the same orientation as a yaw-pitch-roll representation.
    WARNING: the Euler angles or yaw-pitch-roll representation is sensitive to gimbal lock and is sometimes undefined.
    
    The yaw-pitch-roll representation describes a 3D orientation as a succession of three rotations around three axes:
    1. yaw: rotation around the z-axis,
    2. pitch: rotation around the y-axis,
    3. roll: rotation around the x-axis.
    As an example, a rotation matrix can be computed from a yaw-pitch-roll representation as follows:
```
     / cos(yaw) -sin(yaw) 0 \   /  cos(pitch) 0 sin(pitch) \   / 1     0          0     \
 R = | sin(yaw)  cos(yaw) 0 | * |      0      1     0      | * | 0 cos(roll) -sin(roll) |
     \    0         0     1 /   \ -sin(pitch) 0 cos(pitch) /   \ 0 sin(roll)  cos(roll) /
 
```
    Specified by:
    
    setYawPitchRoll in interface Orientation3DBasics
    
    Parameters:
    
    yaw - the angle to rotate about the z-axis.
    
    pitch - the angle to rotate about the y-axis.
    
    roll - the angle to rotate about the x-axis.
  - setRotationMatrix
```
default void setRotationMatrix(double m00,
                               double m01,
                               double m02,
                               double m10,
                               double m11,
                               double m12,
                               double m20,
                               double m21,
                               double m22)
```
    Sets this orientation to represents the same orientation as a rotation matrix given its 9 components.
    
    Specified by:
    
    setRotationMatrix in interface Orientation3DBasics
    
    Parameters:
    
    m00 - the new 1st row 1st column coefficient of the rotation matrix.
    
    m01 - the new 1st row 2nd column coefficient of the rotation matrix.
    
    m02 - the new 1st row 3rd column coefficient of the rotation matrix.
    
    m10 - the new 2nd row 1st column coefficient of the rotation matrix.
    
    m11 - the new 2nd row 2nd column coefficient of the rotation matrix.
    
    m12 - the new 2nd row 3rd column coefficient of the rotation matrix.
    
    m20 - the new 3rd row 1st column coefficient of the rotation matrix.
    
    m21 - the new 3rd row 2nd column coefficient of the rotation matrix.
    
    m22 - the new 3rd row 3rd column coefficient of the rotation matrix.
  - setElement
```
default void setElement(int index,
                        double value)
```
    Selects a component of this axis-angle based on index and sets it to value.
    For index values of 0, 1, and 2, the corresponding components are x, y, and z, respectively, while 3 corresponds to the angle.
    
    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].
  - multiply
```
default void multiply(AxisAngleReadOnly other)
```
    Multiplies this axis-angle by other.
    this = this * other
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - append
```
default void append(Orientation3DReadOnly other)
```
    Appends the given orientation to this orientation.
    Let's consider the following:
    - three coordinate systems A, B, and C.
    - this represents the orientation of B relative to A.
    - orientation represents the orientation of C relative to B.
    The result of calling this method will be that this, represents the orientation of C relative to A.
    
    Appending orientations is in some way similar to summing translations. However, while the addition for translation is commutative, the "append" operation on orientation is NOT commutative. Such that: this.append(orientation) ≠ orientation.append(this).
    Specified by:
    
    append in interface Orientation3DBasics
    
    Parameters:
    
    other - the orientation to append to this orientation. Not modified.
  - multiply
```
default void multiply(AxisAngleReadOnly aa1,
                      AxisAngleReadOnly aa2)
```
    Sets this axis-angle to the multiplication of aa1 and aa2.
    this = aa1 * aa2
    
    Parameters:
    
    aa1 - the first axis-angle in the multiplication. Not modified.
    
    aa2 - the second axis-angle in the multiplication. Not modified.
  - multiplyInvertOther
```
default void multiplyInvertOther(AxisAngleReadOnly other)
```
    Multiplies this axis-angle by the inverse of other.
    this = this * other^-1
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - appendInvertOther
```
default void appendInvertOther(Orientation3DReadOnly orientation)
```
    Appends the inverse of the given orientation to this orientation.
    Let's consider the following:
    - three coordinate systems A, B, and C.
    - this represents the orientation of B relative to A.
    - orientation represents the orientation of B relative to C.
    The result of calling this method will be that this, represents the orientation of C relative to A.
    
    This operation is in some way similar to subtracting translations, as in this operation can be seen as subtracting orientation to this.
    Specified by:
    
    appendInvertOther in interface Orientation3DBasics
    
    Parameters:
    
    orientation - the orientation which the inverse is to be appended to this orientation. Not modified.
  - multiplyInvertThis
```
default void multiplyInvertThis(AxisAngleReadOnly other)
```
    Sets this axis-angle to the multiplication of the inverse of this and other.
    this = this^-1 * other
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - multiplyInvertBoth
```
default void multiplyInvertBoth(AxisAngleReadOnly other)
```
    Sets this axis-angle to the multiplication of the inverse of this and the inverse of other.
    this = this^-1 * other^-1
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - appendYawRotation
```
default void appendYawRotation(double yaw)
```
    Append a rotation about the z-axis to this axis-angle.
```
               / ux    =  0  \
 this = this * | uy    =  0  |
               | uz    =  1  |
               \ angle = yaw /
 
```
    Specified by:
    
    appendYawRotation in interface Orientation3DBasics
    
    Parameters:
    
    yaw - the angle to rotate about the z-axis.
  - appendPitchRotation
```
default void appendPitchRotation(double pitch)
```
    Append a rotation about the y-axis to this axis-angle.
```
               / ux    =  0    \
 this = this * | uy    =  1    |
               | uz    =  0    |
               \ angle = pitch /
 
```
    Specified by:
    
    appendPitchRotation in interface Orientation3DBasics
    
    Parameters:
    
    pitch - the angle to rotate about the y-axis.
  - appendRollRotation
```
default void appendRollRotation(double roll)
```
    Append a rotation about the x-axis to this axis-angle.
```
               / ux    =  1   \
 this = this * | uy    =  0   |
               | uz    =  0   |
               \ angle = roll /
 
```
    Specified by:
    
    appendRollRotation in interface Orientation3DBasics
    
    Parameters:
    
    roll - the angle to rotate about the x-axis.
  - preMultiply
```
default void preMultiply(AxisAngleReadOnly other)
```
    Pre-multiplies this axis-angle by other.
    this = other * other
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - prepend
```
default void prepend(Orientation3DReadOnly orientation)
```
    Prepends the given orientation to this orientation.
    Let's consider the following:
    - three coordinate systems A, B, and C.
    - this represents the orientation of C relative to B.
    - orientation represents the orientation of B relative to A.
    The result of calling this method will be that this, represents the orientation of C relative to A.
    
    Prepending orientations is in some way similar to summing translations. However, while the addition for translation is commutative, the "prepend" operation on orientation is NOT commutative. Such that: this.prepend(orientation) ≠ orientation.prepend(this).
    Specified by:
    
    prepend in interface Orientation3DBasics
    
    Parameters:
    
    orientation - the orientation to prepend to this orientation. Not modified.
  - preMultiplyInvertOther
```
default void preMultiplyInvertOther(AxisAngleReadOnly other)
```
    Sets this axis-angle to the multiplication of the inverse of other and this.
    this = other^-1 * this
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - prependInvertOther
```
default void prependInvertOther(Orientation3DReadOnly orientation)
```
    Prepends the inverse of the given orientation to this orientation.
    Let's consider the following:
    - three coordinate systems A, B, and C.
    - this represents the orientation of B relative to C.
    - orientation represents the orientation of B relative to A.
    The result of calling this method will be that this, represents the orientation of C relative to A.
    
    This operation is in some way similar to subtracting translations, as in this operation can be seen as subtracting orientation to this.
    Specified by:
    
    prependInvertOther in interface Orientation3DBasics
    
    Parameters:
    
    orientation - the orientation which the inverse is to be appended to this orientation. Not modified.
  - preMultiplyInvertThis
```
default void preMultiplyInvertThis(AxisAngleReadOnly other)
```
    Sets this axis-angle to the multiplication of other and the inverse of this.
    this = other * this^-1
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - preMultiplyInvertBoth
```
default void preMultiplyInvertBoth(AxisAngleReadOnly other)
```
    Sets this axis-angle to the multiplication of the inverse of other and the inverse of this.
    this = other^-1 * this^-1
    
    Parameters:
    
    other - the other axis-angle to multiply this. Not modified.
  - prependYawRotation
```
default void prependYawRotation(double yaw)
```
    Prepend a rotation about the z-axis to this axis-angle.
```
        / ux    =  0  \
 this = | uy    =  0  | * this
        | uz    =  1  |
        \ angle = yaw /
 
```
    Specified by:
    
    prependYawRotation in interface Orientation3DBasics
    
    Parameters:
    
    yaw - the angle to rotate about the z-axis.
  - prependPitchRotation
```
default void prependPitchRotation(double pitch)
```
    Prepend a rotation about the y-axis to this axis-angle.
```
        / ux    =  0    \
 this = | uy    =  1    | * this
        | uz    =  0    |
        \ angle = pitch /
 
```
    Specified by:
    
    prependPitchRotation in interface Orientation3DBasics
    
    Parameters:
    
    pitch - the angle to rotate about the y-axis.
  - prependRollRotation
```
default void prependRollRotation(double roll)
```
    Prepend a rotation about the x-axis to this axis-angle.
```
        / ux    =  1   \
 this = | uy    =  0   | * this
        | uz    =  0   |
        \ angle = roll /
 
```
    Specified by:
    
    prependRollRotation in interface Orientation3DBasics
    
    Parameters:
    
    roll - the angle to rotate about the x-axis.

Interface AxisAngleBasics

Field Summary

Fields inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DReadOnly

Method Summary

Methods inherited from interface us.ihmc.euclid.axisAngle.interfaces.AxisAngleReadOnly

Methods inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DBasics

Methods inherited from interface us.ihmc.euclid.orientation.interfaces.Orientation3DReadOnly

Method Detail

setAngle

setX

setY

setZ

setToZero

setToNaN

containsNaN

absolute

negate

inverse

invert

normalizeAxis

normalize

scaleAngle

set

set

set

set

setAndNegate

set

set

set

set

setAxisAngle

setQuaternion

setRotationVector

setYawPitchRoll

setRotationMatrix

setElement

multiply

append

multiply

multiplyInvertOther

appendInvertOther

multiplyInvertThis

multiplyInvertBoth

appendYawRotation

appendPitchRotation

appendRollRotation

preMultiply

prepend

preMultiplyInvertOther

prependInvertOther

preMultiplyInvertThis

preMultiplyInvertBoth

prependYawRotation

prependPitchRotation

prependRollRotation