Quaterniond (JOML 1.7.0 API)

java.lang.Object
- org.joml.Quaterniond

All Implemented Interfaces:

Externalizable, Serializable
```
public class Quaterniond
extends Object
implements Externalizable
```
Contains the definition and functions for rotations expressed as 4-dimensional vectors

Author:

Richard Greenlees, Kai Burjack

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`double`	`w` The real/scalar part of the quaternion.
`double`	`x` The first component of the vector part.
`double`	`y` The second component of the vector part.
`double`	`z` The third component of the vector part.

Constructor Summary

Constructors
Constructor and Description
`Quaterniond()` Create a new `Quaterniond` and initialize it with `(x=0, y=0, z=0, w=1)`, where `(x, y, z)` is the vector part of the quaternion and `w` is the real/scalar part.
`Quaterniond(AxisAngle4d axisAngle)` Create a new `Quaterniond` and initialize it to represent the same rotation as the given `AxisAngle4d`.
`Quaterniond(AxisAngle4f axisAngle)` Create a new `Quaterniond` and initialize it to represent the same rotation as the given `AxisAngle4f`.
`Quaterniond(double x, double y, double z)` Create a new `Quaterniond` and initialize its imaginary components to the given values, and its real part to `1.0`.
`Quaterniond(double x, double y, double z, double w)` Create a new `Quaterniond` and initialize its components to the given values.
`Quaterniond(Quaterniond source)` Create a new `Quaterniond` and initialize its components to the same values as the given `Quaterniond`.
`Quaterniond(Quaternionf source)` Create a new `Quaterniond` and initialize its components to the same values as the given `Quaternionf`.

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Quaterniond`	`add(Quaterniond q2)` Add `q2` to this quaternion.
`Quaterniond`	`add(Quaterniond q2, Quaterniond dest)` Add `q2` to this quaternion and store the result in `dest`.
`double`	`angle()` Return the angle in radians represented by this quaternion rotation.
`Quaterniond`	`conjugate()` Conjugate this quaternion.
`Quaterniond`	`conjugate(Quaterniond dest)` Conjugate this quaternion and store the result in `dest`.
`Quaterniond`	`difference(Quaterniond other)` Compute the difference between `this` and the `other` quaternion and store the result in `this`.
`Quaterniond`	`difference(Quaterniond other, Quaterniond dest)` Compute the difference between `this` and the `other` quaternion and store the result in `dest`.
`Quaterniond`	`div(Quaterniond b)` Divide `this` quaternion by `b`.
`Quaterniond`	`div(Quaterniond b, Quaterniond dest)` Divide `this` quaternion by `b` and store the result in `dest`.
`double`	`dot(Quaterniond otherQuat)` Return the dot product of this `Quaterniond` and `otherQuat`.
`boolean`	`equals(Object obj)`
`Quaterniond`	`fromAxisAngleDeg(Vector3d axis, double angle)` Set this quaternion to be a representation of the supplied axis and angle (in radians).
`Quaterniond`	`fromAxisAngleRad(double axisX, double axisY, double axisZ, double angle)` Set this quaternion to be a representation of the supplied axis and angle (in radians).
`Quaterniond`	`fromAxisAngleRad(Vector3d axis, double angle)` Set this quaternion to be a representation of the supplied axis and angle (in radians).
`Matrix3d`	`get(Matrix3d dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix3f`	`get(Matrix3f dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix4d`	`get(Matrix4d dest)` Set the given destination matrix to the rotation represented by `this`.
`Matrix4f`	`get(Matrix4f dest)` Set the given destination matrix to the rotation represented by `this`.
`Quaterniond`	`get(Quaterniond dest)` Set the given `Quaterniond` to the values of `this`.
`Vector3d`	`getEulerAnglesXYZ(Vector3d eulerAngles)` Get the euler angles in radians in rotation sequence `XYZ` of this quaternion and store them in the provided parameter `eulerAngles`.
`int`	`hashCode()`
`Quaterniond`	`identity()` Set this quaternion to the identity.
`Quaterniond`	`integrate(double dt, double vx, double vy, double vz)` Integrate the rotation given by the angular velocity `(vx, vy, vz)` around the x, y and z axis, respectively, with respect to the given elapsed time delta `dt` and add the differentiate rotation to the rotation represented by this quaternion.
`Quaterniond`	`integrate(double dt, double vx, double vy, double vz, Quaterniond dest)` Integrate the rotation given by the angular velocity `(vx, vy, vz)` around the x, y and z axis, respectively, with respect to the given elapsed time delta `dt` and add the differentiate rotation to the rotation represented by this quaternion and store the result into `dest`.
`Quaterniond`	`invert()` Invert this quaternion and `normalize` it.
`Quaterniond`	`invert(Quaterniond dest)` Invert this quaternion and store the `normalized` result in `dest`.
`double`	`lengthSquared()` Return the square of the length of this quaternion.
`Quaterniond`	`lookRotate(double dirX, double dirY, double dirZ, double upX, double upY, double upZ)` Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
`Quaterniond`	`lookRotate(double dirX, double dirY, double dirZ, double upX, double upY, double upZ, Quaterniond dest)` Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in `dest`.
`Quaterniond`	`lookRotate(Vector3d dir, Vector3d up)` Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
`Quaterniond`	`lookRotate(Vector3d dir, Vector3d up, Quaterniond dest)` Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in `dest`.
`Quaterniond`	`mul(double qx, double qy, double qz, double qw)` Multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)`.
`Quaterniond`	`mul(double qx, double qy, double qz, double qw, Quaterniond dest)` Multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)` and store the result in `dest`.
`Quaterniond`	`mul(Quaterniond q)` Multiply this quaternion by `q`.
`Quaterniond`	`mul(Quaterniond q, Quaterniond dest)` Multiply this quaternion by `q` and store the result in `dest`.
`Quaterniond`	`nlerp(Quaterniond q, double factor)` Compute a linear (non-spherical) interpolation of `this` and the given quaternion `q` and store the result in `this`.
`Quaterniond`	`nlerp(Quaterniond q, double factor, Quaterniond dest)` Compute a linear (non-spherical) interpolation of `this` and the given quaternion `q` and store the result in `dest`.
`Quaterniond`	`nlerpIterative(Quaterniond q, double alpha, double dotThreshold, Quaterniond dest)` Compute linear (non-spherical) interpolations of `this` and the given quaternion `q` iteratively and store the result in `dest`.
`Quaterniond`	`normalize()` Normalize this quaternion.
`Quaterniond`	`normalize(Quaterniond dest)` Normalize this quaternion and store the result in `dest`.
`Vector3d`	`positiveX(Vector3d dir)` Obtain the direction of `+X` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	`positiveY(Vector3d dir)` Obtain the direction of `+Y` before the rotation transformation represented by `this` quaternion is applied.
`Vector3d`	`positiveZ(Vector3d dir)` Obtain the direction of `+Z` before the rotation transformation represented by `this` quaternion is applied.
`Quaterniond`	`premul(double qx, double qy, double qz, double qw)` Pre-multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)`.
`Quaterniond`	`premul(double qx, double qy, double qz, double qw, Quaterniond dest)` Pre-multiply this quaternion by the quaternion represented via `(qx, qy, qz, qw)` and store the result in `dest`.
`Quaterniond`	`premul(Quaterniond q)` Pre-multiply this quaternion by `q`.
`Quaterniond`	`premul(Quaterniond q, Quaterniond dest)` Pre-multiply this quaternion by `q` and store the result in `dest`.
`void`	`readExternal(ObjectInput in)`
`Quaterniond`	`rotate(double angleX, double angleY, double angleZ)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the cartesian space.
`Quaterniond`	`rotate(double angleX, double angleY, double angleZ, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the cartesian space and store the result in `dest`.
`Quaterniond`	`rotate(Vector3d anglesXYZ)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the cartesian space.
`Quaterniond`	`rotate(Vector3d anglesXYZ, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the cartesian space and store the result in `dest`.
`Quaterniond`	`rotateAxis(double angle, double axisX, double axisY, double axisZ)` Apply a rotation to `this` quaternion rotating the given radians about the specified axis.
`Quaterniond`	`rotateAxis(double angle, double axisX, double axisY, double axisZ, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the specified axis and store the result in `dest`.
`Quaterniond`	`rotateAxis(double angle, Vector3d axis)` Apply a rotation to `this` quaternion rotating the given radians about the specified axis.
`Quaterniond`	`rotateAxis(double angle, Vector3d axis, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the specified axis and store the result in `dest`.
`Quaterniond`	`rotateLocal(double angleX, double angleY, double angleZ)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion.
`Quaterniond`	`rotateLocal(double angleX, double angleY, double angleZ, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion and store the result in `dest`.
`Quaterniond`	`rotateLocalX(double angle)` Apply a rotation to `this` quaternion rotating the given radians about the local x axis.
`Quaterniond`	`rotateLocalX(double angle, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the local x axis and store the result in `dest`.
`Quaterniond`	`rotateLocalY(double angle)` Apply a rotation to `this` quaternion rotating the given radians about the local y axis.
`Quaterniond`	`rotateLocalY(double angle, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the local y axis and store the result in `dest`.
`Quaterniond`	`rotateLocalZ(double angle)` Apply a rotation to `this` quaternion rotating the given radians about the local z axis.
`Quaterniond`	`rotateLocalZ(double angle, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the local z axis and store the result in `dest`.
`Quaterniond`	`rotateTo(double fromDirX, double fromDirY, double fromDirZ, double toDirX, double toDirY, double toDirZ)` Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir`.
`Quaterniond`	`rotateTo(double fromDirX, double fromDirY, double fromDirZ, double toDirX, double toDirY, double toDirZ, Quaterniond dest)` Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir` and store the result in `dest`.
`Quaterniond`	`rotateTo(Vector3d fromDir, Vector3d toDir)` Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir`.
`Quaterniond`	`rotateTo(Vector3d fromDir, Vector3d toDir, Quaterniond dest)` Apply a rotation to `this` that rotates the `fromDir` vector to point along `toDir` and store the result in `dest`.
`Quaterniond`	`rotateX(double angle)` Apply a rotation to `this` quaternion rotating the given radians about the x axis.
`Quaterniond`	`rotateX(double angle, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the x axis and store the result in `dest`.
`Quaterniond`	`rotateXYZ(double angleX, double angleY, double angleZ)` Apply a rotation to `this` quaternion rotating the given radians about the cartesian base unit axes, called the euler angles using rotation sequence `XYZ`.
`Quaterniond`	`rotateXYZ(double angleX, double angleY, double angleZ, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the cartesian base unit axes, called the euler angles using rotation sequence `XYZ` and store the result in `dest`.
`Quaterniond`	`rotateY(double angle)` Apply a rotation to `this` quaternion rotating the given radians about the y axis.
`Quaterniond`	`rotateY(double angle, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the y axis and store the result in `dest`.
`Quaterniond`	`rotateYXZ(double angleZ, double angleY, double angleX)` Apply a rotation to `this` quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence `YXZ`.
`Quaterniond`	`rotateYXZ(double angleY, double angleX, double angleZ, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence `YXZ` and store the result in `dest`.
`Quaterniond`	`rotateZ(double angle)` Apply a rotation to `this` quaternion rotating the given radians about the z axis.
`Quaterniond`	`rotateZ(double angle, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the z axis and store the result in `dest`.
`Quaterniond`	`rotateZYX(double angleZ, double angleY, double angleX)` Apply a rotation to `this` quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence `ZYX`.
`Quaterniond`	`rotateZYX(double angleZ, double angleY, double angleX, Quaterniond dest)` Apply a rotation to `this` quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence `ZYX` and store the result in `dest`.
`Quaterniond`	`rotation(double angleX, double angleY, double angleZ)` Set this quaternion to represent a rotation of the given angles in radians about the basis unit axes of the cartesian space.
`Quaterniond`	`rotationAxis(AxisAngle4f axisAngle)` Set this `Quaterniond` to a rotation of the given angle in radians about the supplied axis, all of which are specified via the `AxisAngle4f`.
`Quaterniond`	`rotationAxis(double angle, double axisX, double axisY, double axisZ)` Set this quaternion to a rotation of the given angle in radians about the supplied axis.
`Quaterniond`	`rotationTo(double fromDirX, double fromDirY, double fromDirZ, double toDirX, double toDirY, double toDirZ)` Set `this` quaternion to a rotation that rotates the `fromDir` vector to point along `toDir`.
`Quaterniond`	`rotationTo(Vector3d fromDir, Vector3d toDir)` Set `this` quaternion to a rotation that rotates the `fromDir` vector to point along `toDir`.
`Quaterniond`	`rotationX(double angle)` Set this quaternion to represent a rotation of the given radians about the x axis.
`Quaterniond`	`rotationXYZ(double angleX, double angleY, double angleZ)` Set this quaternion from the supplied euler angles (in radians) with rotation order XYZ.
`Quaterniond`	`rotationY(double angle)` Set this quaternion to represent a rotation of the given radians about the y axis.
`Quaterniond`	`rotationYXZ(double angleY, double angleX, double angleZ)` Set this quaternion from the supplied euler angles (in radians) with rotation order YXZ.
`Quaterniond`	`rotationZ(double angle)` Set this quaternion to represent a rotation of the given radians about the z axis.
`Quaterniond`	`rotationZYX(double angleZ, double angleY, double angleX)` Set this quaternion from the supplied euler angles (in radians) with rotation order ZYX.
`Quaterniond`	`scale(double factor)` Scale the rotation represented by this quaternion by the given `factor` using sperical linear interpolation.
`Quaterniond`	`scale(double factor, Quaterniond dest)` Scale the rotation represented by this quaternion by the given `factor` using sperical linear interpolation, and store the result in `dest`.
`Quaterniond`	`set(AxisAngle4d axisAngle)` Set this `Quaterniond` to be equivalent to the given `AxisAngle4d`.
`Quaterniond`	`set(AxisAngle4f axisAngle)` Set this `Quaterniond` to be equivalent to the given `AxisAngle4f`.
`Quaterniond`	`set(double x, double y, double z)` Set the x, y and z components of this quaternion to the new values.
`Quaterniond`	`set(double x, double y, double z, double w)` Set this quaternion to the new values.
`Quaterniond`	`set(Quaterniond q)` Set this quaternion to be a copy of q.
`Quaterniond`	`set(Quaternionf q)` Set this quaternion to be a copy of q.
`Quaterniond`	`setAngleAxis(double angle, double x, double y, double z)` Set this quaternion to a rotation equivalent to the supplied axis and angle (in radians).
`Quaterniond`	`setAngleAxis(double angle, Vector3d axis)` Set this quaternion to be a representation of the supplied axis and angle (in radians).
`Quaterniond`	`setFromNormalized(Matrix3d mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`setFromNormalized(Matrix3f mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`setFromNormalized(Matrix4d mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`setFromNormalized(Matrix4f mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`setFromUnnormalized(Matrix3d mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`setFromUnnormalized(Matrix3f mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`setFromUnnormalized(Matrix4d mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`setFromUnnormalized(Matrix4f mat)` Set this quaternion to be a representation of the rotational component of the given matrix.
`Quaterniond`	`slerp(Quaterniond target, double alpha)` Interpolate between `this` quaternion and the specified `target` using sperical linear interpolation using the specified interpolation factor `alpha`.
`Quaterniond`	`slerp(Quaterniond target, double alpha, Quaterniond dest)` Interpolate between `this` quaternion and the specified `target` using sperical linear interpolation using the specified interpolation factor `alpha`, and store the result in `dest`.
`String`	`toString()` Return a string representation of this quaternion.
`String`	`toString(NumberFormat formatter)` Return a string representation of this quaternion by formatting the components with the given `NumberFormat`.
`Vector3d`	`transform(Vector3d vec)` Transform the given vector by this quaternion.
`Vector3d`	`transform(Vector3d vec, Vector3d dest)` Transform the given vector by this quaternion and store the result in `dest`.
`Vector4d`	`transform(Vector4d vec)` Transform the given vector by this quaternion.
`Vector4d`	`transform(Vector4d vec, Vector4d dest)` Transform the given vector by this quaternion and store the result in `dest`.
`void`	`writeExternal(ObjectOutput out)`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - x
```
public double x
```
    The first component of the vector part.
  - y
```
public double y
```
    The second component of the vector part.
  - z
```
public double z
```
    The third component of the vector part.
  - w
```
public double w
```
    The real/scalar part of the quaternion.
- Constructor Detail
  - Quaterniond
```
public Quaterniond()
```
    Create a new Quaterniond and initialize it with (x=0, y=0, z=0, w=1), where (x, y, z) is the vector part of the quaternion and w is the real/scalar part.
  - Quaterniond
```
public Quaterniond(double x,
                   double y,
                   double z,
                   double w)
```
    Create a new Quaterniond and initialize its components to the given values.
    
    Parameters:
    
    x - the first component of the imaginary part
    
    y - the second component of the imaginary part
    
    z - the third component of the imaginary part
    
    w - the real part
  - Quaterniond
```
public Quaterniond(double x,
                   double y,
                   double z)
```
    Create a new Quaterniond and initialize its imaginary components to the given values, and its real part to 1.0.
    
    Parameters:
    
    x - the first component of the imaginary part
    
    y - the second component of the imaginary part
    
    z - the third component of the imaginary part
  - Quaterniond
```
public Quaterniond(Quaterniond source)
```
    Create a new Quaterniond and initialize its components to the same values as the given Quaterniond.
    
    Parameters:
    
    source - the Quaterniond to take the component values from
  - Quaterniond
```
public Quaterniond(Quaternionf source)
```
    Create a new Quaterniond and initialize its components to the same values as the given Quaternionf.
    
    Parameters:
    
    source - the Quaternionf to take the component values from
  - Quaterniond
```
public Quaterniond(AxisAngle4f axisAngle)
```
    Create a new Quaterniond and initialize it to represent the same rotation as the given AxisAngle4f.
    
    Parameters:
    
    axisAngle - the axis-angle to initialize this quaternion with
  - Quaterniond
```
public Quaterniond(AxisAngle4d axisAngle)
```
    Create a new Quaterniond and initialize it to represent the same rotation as the given AxisAngle4d.
    
    Parameters:
    
    axisAngle - the axis-angle to initialize this quaternion with
- Method Detail
  - normalize
```
public Quaterniond normalize()
```
    Normalize this quaternion.
    
    Returns:
    
    this
  - normalize
```
public Quaterniond normalize(Quaterniond dest)
```
    Normalize this quaternion and store the result in dest.
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - add
```
public Quaterniond add(Quaterniond q2)
```
    Add q2 to this quaternion.
    
    Parameters:
    
    q2 - the quaternion to add to this
    
    Returns:
    
    this
  - add
```
public Quaterniond add(Quaterniond q2,
                       Quaterniond dest)
```
    Add q2 to this quaternion and store the result in dest.
    
    Parameters:
    
    q2 - the quaternion to add to this
    
    dest - will hold the result
    
    Returns:
    
    dest
  - dot
```
public double dot(Quaterniond otherQuat)
```
    Return the dot product of this Quaterniond and otherQuat.
    
    Parameters:
    
    otherQuat - the other quaternion
    
    Returns:
    
    the dot product
  - angle
```
public double angle()
```
    Return the angle in radians represented by this quaternion rotation.
    
    Returns:
    
    the angle in radians
  - get
```
public Matrix3d get(Matrix3d dest)
```
    Set the given destination matrix to the rotation represented by this.
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
  - get
```
public Matrix3f get(Matrix3f dest)
```
    Set the given destination matrix to the rotation represented by this.
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
  - get
```
public Matrix4d get(Matrix4d dest)
```
    Set the given destination matrix to the rotation represented by this.
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
  - get
```
public Matrix4f get(Matrix4f dest)
```
    Set the given destination matrix to the rotation represented by this.
    
    Parameters:
    
    dest - the matrix to write the rotation into
    
    Returns:
    
    the passed in destination
  - get
```
public Quaterniond get(Quaterniond dest)
```
    Set the given Quaterniond to the values of this.
    
    Parameters:
    
    dest - the Quaterniond to set
    
    Returns:
    
    the passed in destination
    
    See Also:
    
    set(Quaterniond)
  - set
```
public Quaterniond set(double x,
                       double y,
                       double z,
                       double w)
```
    Set this quaternion to the new values.
    
    Parameters:
    
    x - the new value of x
    
    y - the new value of y
    
    z - the new value of z
    
    w - the new value of w
    
    Returns:
    
    this
  - set
```
public Quaterniond set(double x,
                       double y,
                       double z)
```
    Set the x, y and z components of this quaternion to the new values.
    
    Parameters:
    
    x - the new value of x
    
    y - the new value of y
    
    z - the new value of z
    
    Returns:
    
    this
  - set
```
public Quaterniond set(Quaterniond q)
```
    Set this quaternion to be a copy of q.
    
    Parameters:
    
    q - the Quaterniond to copy
    
    Returns:
    
    this
  - set
```
public Quaterniond set(Quaternionf q)
```
    Set this quaternion to be a copy of q.
    
    Parameters:
    
    q - the Quaternionf to copy
    
    Returns:
    
    this
  - set
```
public Quaterniond set(AxisAngle4f axisAngle)
```
    Set this Quaterniond to be equivalent to the given AxisAngle4f.
    
    Parameters:
    
    axisAngle - the AxisAngle4f
    
    Returns:
    
    this
  - set
```
public Quaterniond set(AxisAngle4d axisAngle)
```
    Set this Quaterniond to be equivalent to the given AxisAngle4d.
    
    Parameters:
    
    axisAngle - the AxisAngle4d
    
    Returns:
    
    this
  - setAngleAxis
```
public Quaterniond setAngleAxis(double angle,
                                double x,
                                double y,
                                double z)
```
    Set this quaternion to a rotation equivalent to the supplied axis and angle (in radians).
    This method assumes that the given rotation axis (x, y, z) is already normalized
    
    Parameters:
    
    angle - the angle in radians
    
    x - the x-component of the normalized rotation axis
    
    y - the y-component of the normalized rotation axis
    
    z - the z-component of the normalized rotation axis
    
    Returns:
    
    this
  - setAngleAxis
```
public Quaterniond setAngleAxis(double angle,
                                Vector3d axis)
```
    Set this quaternion to be a representation of the supplied axis and angle (in radians).
    
    Parameters:
    
    angle - the angle in radians
    
    axis - the rotation axis
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaterniond setFromUnnormalized(Matrix4f mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaterniond setFromNormalized(Matrix4f mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaterniond setFromUnnormalized(Matrix4d mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaterniond setFromNormalized(Matrix4d mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaterniond setFromUnnormalized(Matrix3f mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaterniond setFromNormalized(Matrix3f mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromUnnormalized
```
public Quaterniond setFromUnnormalized(Matrix3d mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    This method assumes that the first three columns of the upper left 3x3 submatrix are no unit vectors.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - setFromNormalized
```
public Quaterniond setFromNormalized(Matrix3d mat)
```
    Set this quaternion to be a representation of the rotational component of the given matrix.
    
    Parameters:
    
    mat - the matrix whose rotational component is used to set this quaternion
    
    Returns:
    
    this
  - fromAxisAngleRad
```
public Quaterniond fromAxisAngleRad(Vector3d axis,
                                    double angle)
```
    Set this quaternion to be a representation of the supplied axis and angle (in radians).
    
    Parameters:
    
    axis - the rotation axis
    
    angle - the angle in radians
    
    Returns:
    
    this
  - fromAxisAngleRad
```
public Quaterniond fromAxisAngleRad(double axisX,
                                    double axisY,
                                    double axisZ,
                                    double angle)
```
    Set this quaternion to be a representation of the supplied axis and angle (in radians).
    
    Parameters:
    
    axisX - the x component of the rotation axis
    
    axisY - the y component of the rotation axis
    
    axisZ - the z component of the rotation axis
    
    angle - the angle in radians
    
    Returns:
    
    this
  - fromAxisAngleDeg
```
public Quaterniond fromAxisAngleDeg(Vector3d axis,
                                    double angle)
```
    Set this quaternion to be a representation of the supplied axis and angle (in radians).
    
    Parameters:
    
    axis - the rotation axis
    
    angle - the angle in radians
    
    Returns:
    
    this
  - mul
```
public Quaterniond mul(Quaterniond q)
```
    Multiply this quaternion by q.
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = T * Q
    So, this method uses post-multiplication like the matrix classes, resulting in a vector to be transformed by Q first, and then by T.
    
    Parameters:
    
    q - the quaternion to multiply this by
    
    Returns:
    
    this
  - mul
```
public Quaterniond mul(Quaterniond q,
                       Quaterniond dest)
```
    Multiply this quaternion by q and store the result in dest.
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = T * Q
    So, this method uses post-multiplication like the matrix classes, resulting in a vector to be transformed by Q first, and then by T.
    
    Parameters:
    
    q - the quaternion to multiply this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - mul
```
public Quaterniond mul(double qx,
                       double qy,
                       double qz,
                       double qw)
```
    Multiply this quaternion by the quaternion represented via (qx, qy, qz, qw).
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = T * Q
    So, this method uses post-multiplication like the matrix classes, resulting in a vector to be transformed by Q first, and then by T.
    
    Parameters:
    
    qx - the x component of the quaternion to multiply this by
    
    qy - the y component of the quaternion to multiply this by
    
    qz - the z component of the quaternion to multiply this by
    
    qw - the w component of the quaternion to multiply this by
    
    Returns:
    
    this
  - mul
```
public Quaterniond mul(double qx,
                       double qy,
                       double qz,
                       double qw,
                       Quaterniond dest)
```
    Multiply this quaternion by the quaternion represented via (qx, qy, qz, qw) and store the result in dest.
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = T * Q
    So, this method uses post-multiplication like the matrix classes, resulting in a vector to be transformed by Q first, and then by T.
    
    Parameters:
    
    qx - the x component of the quaternion to multiply this by
    
    qy - the y component of the quaternion to multiply this by
    
    qz - the z component of the quaternion to multiply this by
    
    qw - the w component of the quaternion to multiply this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - premul
```
public Quaterniond premul(Quaterniond q)
```
    Pre-multiply this quaternion by q.
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = Q * T
    So, this method uses pre-multiplication, resulting in a vector to be transformed by T first, and then by Q.
    
    Parameters:
    
    q - the quaternion to pre-multiply this by
    
    Returns:
    
    this
  - premul
```
public Quaterniond premul(Quaterniond q,
                          Quaterniond dest)
```
    Pre-multiply this quaternion by q and store the result in dest.
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = Q * T
    So, this method uses pre-multiplication, resulting in a vector to be transformed by T first, and then by Q.
    
    Parameters:
    
    q - the quaternion to pre-multiply this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - premul
```
public Quaterniond premul(double qx,
                          double qy,
                          double qz,
                          double qw)
```
    Pre-multiply this quaternion by the quaternion represented via (qx, qy, qz, qw).
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = Q * T
    So, this method uses pre-multiplication, resulting in a vector to be transformed by T first, and then by Q.
    
    Parameters:
    
    qx - the x component of the quaternion to multiply this by
    
    qy - the y component of the quaternion to multiply this by
    
    qz - the z component of the quaternion to multiply this by
    
    qw - the w component of the quaternion to multiply this by
    
    Returns:
    
    this
  - premul
```
public Quaterniond premul(double qx,
                          double qy,
                          double qz,
                          double qw,
                          Quaterniond dest)
```
    Pre-multiply this quaternion by the quaternion represented via (qx, qy, qz, qw) and store the result in dest.
    If T is this and Q is the given quaternion, then the resulting quaternion R is:
    R = Q * T
    So, this method uses pre-multiplication, resulting in a vector to be transformed by T first, and then by Q.
    
    Parameters:
    
    qx - the x component of the quaternion to multiply this by
    
    qy - the y component of the quaternion to multiply this by
    
    qz - the z component of the quaternion to multiply this by
    
    qw - the w component of the quaternion to multiply this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transform
```
public Vector3d transform(Vector3d vec)
```
    Transform the given vector by this quaternion. This will apply the rotation described by this quaternion to the given vector.
    
    Parameters:
    
    vec - the vector to transform
    
    Returns:
    
    vec
  - transform
```
public Vector3d transform(Vector3d vec,
                          Vector3d dest)
```
    Transform the given vector by this quaternion and store the result in dest. This will apply the rotation described by this quaternion to the given vector.
    
    Parameters:
    
    vec - the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - transform
```
public Vector4d transform(Vector4d vec)
```
    Transform the given vector by this quaternion. This will apply the rotation described by this quaternion to the given vector.
    Only the first three components of the given 4D vector are being used and modified.
    
    Parameters:
    
    vec - the vector to transform
    
    Returns:
    
    vec
  - transform
```
public Vector4d transform(Vector4d vec,
                          Vector4d dest)
```
    Transform the given vector by this quaternion and store the result in dest. This will apply the rotation described by this quaternion to the given vector.
    Only the first three components of the given 4D vector are being used and set on the destination.
    
    Parameters:
    
    vec - the vector to transform
    
    dest - will hold the result
    
    Returns:
    
    dest
  - invert
```
public Quaterniond invert(Quaterniond dest)
```
    Invert this quaternion and store the normalized result in dest.
    If this quaternion is already normalized, then conjugate(Quaterniond) should be used instead.
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    conjugate(Quaterniond)
  - invert
```
public Quaterniond invert()
```
    Invert this quaternion and normalize it.
    If this quaternion is already normalized, then conjugate() should be used instead.
    
    Returns:
    
    this
    
    See Also:
    
    conjugate()
  - div
```
public Quaterniond div(Quaterniond b,
                       Quaterniond dest)
```
    Divide this quaternion by b and store the result in dest.
    The division expressed using the inverse is performed in the following way:
    dest = this * b^-1, where b^-1 is the inverse of b.
    
    Parameters:
    
    b - the Quaterniond to divide this by
    
    dest - will hold the result
    
    Returns:
    
    dest
  - div
```
public Quaterniond div(Quaterniond b)
```
    Divide this quaternion by b.
    The division expressed using the inverse is performed in the following way:
    this = this * b^-1, where b^-1 is the inverse of b.
    
    Parameters:
    
    b - the Quaterniond to divide this by
    
    Returns:
    
    this
  - conjugate
```
public Quaterniond conjugate()
```
    Conjugate this quaternion.
    
    Returns:
    
    this
  - conjugate
```
public Quaterniond conjugate(Quaterniond dest)
```
    Conjugate this quaternion and store the result in dest.
    
    Parameters:
    
    dest - will hold the result
    
    Returns:
    
    dest
  - identity
```
public Quaterniond identity()
```
    Set this quaternion to the identity.
    
    Returns:
    
    this
  - lengthSquared
```
public double lengthSquared()
```
    Return the square of the length of this quaternion.
    
    Returns:
    
    the length
  - rotationXYZ
```
public Quaterniond rotationXYZ(double angleX,
                               double angleY,
                               double angleZ)
```
    Set this quaternion from the supplied euler angles (in radians) with rotation order XYZ.
    This method is equivalent to calling: rotationX(angleX).rotateY(angleY).rotateZ(angleZ)
    Reference: this stackexchange answer
    
    Parameters:
    
    angleX - the angle in radians to rotate about x
    
    angleY - the angle in radians to rotate about y
    
    angleZ - the angle in radians to rotate about z
    
    Returns:
    
    this
  - rotationZYX
```
public Quaterniond rotationZYX(double angleZ,
                               double angleY,
                               double angleX)
```
    Set this quaternion from the supplied euler angles (in radians) with rotation order ZYX.
    This method is equivalent to calling: rotationZ(angleZ).rotateY(angleY).rotateX(angleX)
    Reference: this stackexchange answer
    
    Parameters:
    
    angleX - the angle in radians to rotate about x
    
    angleY - the angle in radians to rotate about y
    
    angleZ - the angle in radians to rotate about z
    
    Returns:
    
    this
  - rotationYXZ
```
public Quaterniond rotationYXZ(double angleY,
                               double angleX,
                               double angleZ)
```
    Set this quaternion from the supplied euler angles (in radians) with rotation order YXZ.
    This method is equivalent to calling: rotationY(angleY).rotateX(angleX).rotateZ(angleZ)
    Reference: https://en.wikipedia.org
    
    Parameters:
    
    angleY - the angle in radians to rotate about y
    
    angleX - the angle in radians to rotate about x
    
    angleZ - the angle in radians to rotate about z
    
    Returns:
    
    this
  - slerp
```
public Quaterniond slerp(Quaterniond target,
                         double alpha)
```
    Interpolate between this quaternion and the specified target using sperical linear interpolation using the specified interpolation factor alpha.
    This method resorts to non-spherical linear interpolation when the absolute dot product between this and target is below 1E-6.
    
    Parameters:
    
    target - the target of the interpolation, which should be reached with alpha = 1.0
    
    alpha - the interpolation factor, within [0..1]
    
    Returns:
    
    this
  - slerp
```
public Quaterniond slerp(Quaterniond target,
                         double alpha,
                         Quaterniond dest)
```
    Interpolate between this quaternion and the specified target using sperical linear interpolation using the specified interpolation factor alpha, and store the result in dest.
    This method resorts to non-spherical linear interpolation when the absolute dot product between this and target is below 1E-6.
    Reference: http://fabiensanglard.net
    
    Parameters:
    
    target - the target of the interpolation, which should be reached with alpha = 1.0
    
    alpha - the interpolation factor, within [0..1]
    
    dest - will hold the result
    
    Returns:
    
    dest
  - scale
```
public Quaterniond scale(double factor)
```
    Scale the rotation represented by this quaternion by the given factor using sperical linear interpolation.
    This method is equivalent to performing a spherical linear interpolation between the unit quaternion and this, and thus equivalent to calling: new Quaterniond().slerp(this, factor)
    Reference: http://fabiensanglard.net
    
    Parameters:
    
    factor - the scaling/interpolation factor, within [0..1]
    
    Returns:
    
    this
    
    See Also:
    
    slerp(Quaterniond, double)
  - scale
```
public Quaterniond scale(double factor,
                         Quaterniond dest)
```
    Scale the rotation represented by this quaternion by the given factor using sperical linear interpolation, and store the result in dest.
    This method is equivalent to performing a spherical linear interpolation between the unit quaternion and this, and thus equivalent to calling: new Quaterniond().slerp(this, factor, dest)
    Reference: http://fabiensanglard.net
    
    Parameters:
    
    factor - the scaling/interpolation factor, within [0..1]
    
    dest - will hold the result
    
    Returns:
    
    this
    
    See Also:
    
    slerp(Quaterniond, double, Quaterniond)
  - integrate
```
public Quaterniond integrate(double dt,
                             double vx,
                             double vy,
                             double vz)
```
    Integrate the rotation given by the angular velocity (vx, vy, vz) around the x, y and z axis, respectively, with respect to the given elapsed time delta dt and add the differentiate rotation to the rotation represented by this quaternion.
    This method pre-multiplies the rotation given by dt and (vx, vy, vz) by this, so the angular velocities are always relative to the local coordinate system of the rotation represented by this quaternion.
    This method is equivalent to calling: rotateLocal(dt * vx, dt * vy, dt * vz)
    Reference: http://physicsforgames.blogspot.de/
    
    Parameters:
    
    dt - the delta time
    
    vx - the angular velocity around the x axis
    
    vy - the angular velocity around the y axis
    
    vz - the angular velocity around the z axis
    
    Returns:
    
    this
    
    See Also:
    
    rotateLocal(double, double, double)
  - integrate
```
public Quaterniond integrate(double dt,
                             double vx,
                             double vy,
                             double vz,
                             Quaterniond dest)
```
    Integrate the rotation given by the angular velocity (vx, vy, vz) around the x, y and z axis, respectively, with respect to the given elapsed time delta dt and add the differentiate rotation to the rotation represented by this quaternion and store the result into dest.
    This method pre-multiplies the rotation given by dt and (vx, vy, vz) by this, so the angular velocities are always relative to the local coordinate system of the rotation represented by this quaternion.
    This method is equivalent to calling: rotateLocal(dt * vx, dt * vy, dt * vz, dest)
    Reference: http://physicsforgames.blogspot.de/
    
    Parameters:
    
    dt - the delta time
    
    vx - the angular velocity around the x axis
    
    vy - the angular velocity around the y axis
    
    vz - the angular velocity around the z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotateLocal(double, double, double, Quaterniond)
  - nlerp
```
public Quaterniond nlerp(Quaterniond q,
                         double factor)
```
    Compute a linear (non-spherical) interpolation of this and the given quaternion q and store the result in this.
    
    Parameters:
    
    q - the other quaternion
    
    factor - the interpolation factor. It is between 0.0 and 1.0
    
    Returns:
    
    this
  - nlerp
```
public Quaterniond nlerp(Quaterniond q,
                         double factor,
                         Quaterniond dest)
```
    Compute a linear (non-spherical) interpolation of this and the given quaternion q and store the result in dest.
    Reference: http://fabiensanglard.net
    
    Parameters:
    
    q - the other quaternion
    
    factor - the interpolation factor. It is between 0.0 and 1.0
    
    dest - will hold the result
    
    Returns:
    
    dest
  - nlerpIterative
```
public Quaterniond nlerpIterative(Quaterniond q,
                                  double alpha,
                                  double dotThreshold,
                                  Quaterniond dest)
```
    Compute linear (non-spherical) interpolations of this and the given quaternion q iteratively and store the result in dest.
    This method performs a series of small-step nlerp interpolations to avoid doing a costly spherical linear interpolation, like slerp, by subdividing the rotation arc between this and q via non-spherical linear interpolations as long as the absolute dot product of this and q is greater than the given dotThreshold parameter.
    Thanks to @theagentd at http://www.java-gaming.org/ for providing the code.
    
    Parameters:
    
    q - the other quaternion
    
    alpha - the interpolation factor, between 0.0 and 1.0
    
    dotThreshold - the threshold for the dot product of this and q above which this method performs another iteration of a small-step linear interpolation
    
    dest - will hold the result
    
    Returns:
    
    dest
  - lookRotate
```
public Quaterniond lookRotate(Vector3d dir,
                              Vector3d up)
```
    Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
    Because there are multiple possibilities for such a rotation, this method will choose the one that ensures the given up direction to remain parallel to the plane spanned by the up and dir vectors.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    Reference: http://answers.unity3d.com
    
    Parameters:
    
    dir - the direction to map to the positive Z axis
    
    up - the vector which will be mapped to a vector parallel to the plane spanned by the given dir and up
    
    Returns:
    
    this
    
    See Also:
    
    lookRotate(double, double, double, double, double, double, Quaterniond)
  - lookRotate
```
public Quaterniond lookRotate(Vector3d dir,
                              Vector3d up,
                              Quaterniond dest)
```
    Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in dest.
    Because there are multiple possibilities for such a rotation, this method will choose the one that ensures the given up direction to remain parallel to the plane spanned by the up and dir vectors.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    Reference: http://answers.unity3d.com
    
    Parameters:
    
    dir - the direction to map to the positive Z axis
    
    up - the vector which will be mapped to a vector parallel to the plane spanned by the given dir and up
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    lookRotate(double, double, double, double, double, double, Quaterniond)
  - lookRotate
```
public Quaterniond lookRotate(double dirX,
                              double dirY,
                              double dirZ,
                              double upX,
                              double upY,
                              double upZ)
```
    Apply a rotation to this quaternion that maps the given direction to the positive Z axis.
    Because there are multiple possibilities for such a rotation, this method will choose the one that ensures the given up direction to remain parallel to the plane spanned by the up and dir vectors.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    Reference: http://answers.unity3d.com
    
    Parameters:
    
    dirX - the x-coordinate of the direction to look along
    
    dirY - the y-coordinate of the direction to look along
    
    dirZ - the z-coordinate of the direction to look along
    
    upX - the x-coordinate of the up vector
    
    upY - the y-coordinate of the up vector
    
    upZ - the z-coordinate of the up vector
    
    Returns:
    
    this
    
    See Also:
    
    lookRotate(double, double, double, double, double, double, Quaterniond)
  - lookRotate
```
public Quaterniond lookRotate(double dirX,
                              double dirY,
                              double dirZ,
                              double upX,
                              double upY,
                              double upZ,
                              Quaterniond dest)
```
    Apply a rotation to this quaternion that maps the given direction to the positive Z axis, and store the result in dest.
    Because there are multiple possibilities for such a rotation, this method will choose the one that ensures the given up direction to remain parallel to the plane spanned by the up and dir vectors.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    Reference: http://answers.unity3d.com
    
    Parameters:
    
    dirX - the x-coordinate of the direction to look along
    
    dirY - the y-coordinate of the direction to look along
    
    dirZ - the z-coordinate of the direction to look along
    
    upX - the x-coordinate of the up vector
    
    upY - the y-coordinate of the up vector
    
    upZ - the z-coordinate of the up vector
    
    dest - will hold the result
    
    Returns:
    
    dest
  - toString
```
public String toString()
```
    Return a string representation of this quaternion.
    This method creates a new DecimalFormat on every invocation with the format string " 0.000E0;-".
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    the string representation
  - toString
```
public String toString(NumberFormat formatter)
```
    Return a string representation of this quaternion by formatting the components with the given NumberFormat.
    
    Parameters:
    
    formatter - the NumberFormat used to format the quaternion components with
    
    Returns:
    
    the string representation
  - writeExternal
```
public void writeExternal(ObjectOutput out)
                   throws IOException
```
    Specified by:
    
    writeExternal in interface Externalizable
    
    Throws:
    
    IOException
  - readExternal
```
public void readExternal(ObjectInput in)
                  throws IOException,
                         ClassNotFoundException
```
    Specified by:
    
    readExternal in interface Externalizable
    
    Throws:
    
    IOException
    
    ClassNotFoundException
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - equals
```
public boolean equals(Object obj)
```
    Overrides:
    
    equals in class Object
  - difference
```
public Quaterniond difference(Quaterniond other)
```
    Compute the difference between this and the other quaternion and store the result in this.
    The difference is the rotation that has to be applied to get from this rotation to other. If T is this, Q is other and D is the computed difference, then the following equation holds:
    T * D = Q
    It is defined as: D = T^-1 * Q, where T^-1 denotes the inverse of T.
    
    Parameters:
    
    other - the other quaternion
    
    Returns:
    
    this
  - difference
```
public Quaterniond difference(Quaterniond other,
                              Quaterniond dest)
```
    Compute the difference between this and the other quaternion and store the result in dest.
    The difference is the rotation that has to be applied to get from this rotation to other. If T is this, Q is other and D is the computed difference, then the following equation holds:
    T * D = Q
    It is defined as: D = T^-1 * Q, where T^-1 denotes the inverse of T.
    
    Parameters:
    
    other - the other quaternion
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotationTo
```
public Quaterniond rotationTo(double fromDirX,
                              double fromDirY,
                              double fromDirZ,
                              double toDirX,
                              double toDirY,
                              double toDirZ)
```
    Set this quaternion to a rotation that rotates the fromDir vector to point along toDir.
    Since there can be multiple possible rotations, this method chooses the one with the shortest arc.
    Reference: stackoverflow.com
    
    Parameters:
    
    fromDirX - the x-coordinate of the direction to rotate into the destination direction
    
    fromDirY - the y-coordinate of the direction to rotate into the destination direction
    
    fromDirZ - the z-coordinate of the direction to rotate into the destination direction
    
    toDirX - the x-coordinate of the direction to rotate to
    
    toDirY - the y-coordinate of the direction to rotate to
    
    toDirZ - the z-coordinate of the direction to rotate to
    
    Returns:
    
    this
  - rotationTo
```
public Quaterniond rotationTo(Vector3d fromDir,
                              Vector3d toDir)
```
    Set this quaternion to a rotation that rotates the fromDir vector to point along toDir.
    Because there can be multiple possible rotations, this method chooses the one with the shortest arc.
    
    Parameters:
    
    fromDir - the starting direction
    
    toDir - the destination direction
    
    Returns:
    
    this
    
    See Also:
    
    rotationTo(double, double, double, double, double, double)
  - rotateTo
```
public Quaterniond rotateTo(double fromDirX,
                            double fromDirY,
                            double fromDirZ,
                            double toDirX,
                            double toDirY,
                            double toDirZ,
                            Quaterniond dest)
```
    Apply a rotation to this that rotates the fromDir vector to point along toDir and store the result in dest.
    Since there can be multiple possible rotations, this method chooses the one with the shortest arc.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    Reference: stackoverflow.com
    
    Parameters:
    
    fromDirX - the x-coordinate of the direction to rotate into the destination direction
    
    fromDirY - the y-coordinate of the direction to rotate into the destination direction
    
    fromDirZ - the z-coordinate of the direction to rotate into the destination direction
    
    toDirX - the x-coordinate of the direction to rotate to
    
    toDirY - the y-coordinate of the direction to rotate to
    
    toDirZ - the z-coordinate of the direction to rotate to
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotationAxis
```
public Quaterniond rotationAxis(AxisAngle4f axisAngle)
```
    Set this Quaterniond to a rotation of the given angle in radians about the supplied axis, all of which are specified via the AxisAngle4f.
    
    Parameters:
    
    axisAngle - the AxisAngle4f giving the rotation angle in radians and the axis to rotate about
    
    Returns:
    
    this
    
    See Also:
    
    rotationAxis(double, double, double, double)
  - rotationAxis
```
public Quaterniond rotationAxis(double angle,
                                double axisX,
                                double axisY,
                                double axisZ)
```
    Set this quaternion to a rotation of the given angle in radians about the supplied axis.
    
    Parameters:
    
    angle - the rotation angle in radians
    
    axisX - the x-coordinate of the rotation axis
    
    axisY - the y-coordinate of the rotation axis
    
    axisZ - the z-coordinate of the rotation axis
    
    Returns:
    
    this
  - rotation
```
public Quaterniond rotation(double angleX,
                            double angleY,
                            double angleZ)
```
    Set this quaternion to represent a rotation of the given angles in radians about the basis unit axes of the cartesian space.
    
    Parameters:
    
    angleX - the angle in radians to rotate about the x axis
    
    angleY - the angle in radians to rotate about the y axis
    
    angleZ - the angle in radians to rotate about the z axis
    
    Returns:
    
    this
  - rotationX
```
public Quaterniond rotationX(double angle)
```
    Set this quaternion to represent a rotation of the given radians about the x axis.
    
    Parameters:
    
    angle - the angle in radians to rotate about the x axis
    
    Returns:
    
    this
  - rotationY
```
public Quaterniond rotationY(double angle)
```
    Set this quaternion to represent a rotation of the given radians about the y axis.
    
    Parameters:
    
    angle - the angle in radians to rotate about the y axis
    
    Returns:
    
    this
  - rotationZ
```
public Quaterniond rotationZ(double angle)
```
    Set this quaternion to represent a rotation of the given radians about the z axis.
    
    Parameters:
    
    angle - the angle in radians to rotate about the z axis
    
    Returns:
    
    this
  - rotateTo
```
public Quaterniond rotateTo(double fromDirX,
                            double fromDirY,
                            double fromDirZ,
                            double toDirX,
                            double toDirY,
                            double toDirZ)
```
    Apply a rotation to this that rotates the fromDir vector to point along toDir.
    Since there can be multiple possible rotations, this method chooses the one with the shortest arc.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    fromDirX - the x-coordinate of the direction to rotate into the destination direction
    
    fromDirY - the y-coordinate of the direction to rotate into the destination direction
    
    fromDirZ - the z-coordinate of the direction to rotate into the destination direction
    
    toDirX - the x-coordinate of the direction to rotate to
    
    toDirY - the y-coordinate of the direction to rotate to
    
    toDirZ - the z-coordinate of the direction to rotate to
    
    Returns:
    
    this
    
    See Also:
    
    rotateTo(double, double, double, double, double, double, Quaterniond)
  - rotateTo
```
public Quaterniond rotateTo(Vector3d fromDir,
                            Vector3d toDir,
                            Quaterniond dest)
```
    Apply a rotation to this that rotates the fromDir vector to point along toDir and store the result in dest.
    Because there can be multiple possible rotations, this method chooses the one with the shortest arc.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    fromDir - the starting direction
    
    toDir - the destination direction
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotateTo(double, double, double, double, double, double, Quaterniond)
  - rotateTo
```
public Quaterniond rotateTo(Vector3d fromDir,
                            Vector3d toDir)
```
    Apply a rotation to this that rotates the fromDir vector to point along toDir.
    Because there can be multiple possible rotations, this method chooses the one with the shortest arc.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    fromDir - the starting direction
    
    toDir - the destination direction
    
    Returns:
    
    this
    
    See Also:
    
    rotateTo(double, double, double, double, double, double, Quaterniond)
  - rotate
```
public Quaterniond rotate(Vector3d anglesXYZ,
                          Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the cartesian space and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    anglesXYZ - the angles in radians to rotate about the x, y and z axes, respectively
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotate
```
public Quaterniond rotate(Vector3d anglesXYZ)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the cartesian space.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    anglesXYZ - the angles in radians to rotate about the x, y and z axes, respectively
    
    Returns:
    
    this
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotate
```
public Quaterniond rotate(double angleX,
                          double angleY,
                          double angleZ)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the cartesian space.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleX - the angle in radians to rotate about the x axis
    
    angleY - the angle in radians to rotate about the y axis
    
    angleZ - the angle in radians to rotate about the z axis
    
    Returns:
    
    this
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotate
```
public Quaterniond rotate(double angleX,
                          double angleY,
                          double angleZ,
                          Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the cartesian space and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleX - the angle in radians to rotate about the x axis
    
    angleY - the angle in radians to rotate about the y axis
    
    angleZ - the angle in radians to rotate about the z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double)
  - rotateLocal
```
public Quaterniond rotateLocal(double angleX,
                               double angleY,
                               double angleZ)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angleX - the angle in radians to rotate about the local x axis
    
    angleY - the angle in radians to rotate about the local y axis
    
    angleZ - the angle in radians to rotate about the local z axis
    
    Returns:
    
    this
    
    See Also:
    
    rotateLocal(double, double, double, Quaterniond)
  - rotateLocal
```
public Quaterniond rotateLocal(double angleX,
                               double angleY,
                               double angleZ,
                               Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the basis unit axes of the local coordinate system represented by this quaternion and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angleX - the angle in radians to rotate about the local x axis
    
    angleY - the angle in radians to rotate about the local y axis
    
    angleZ - the angle in radians to rotate about the local z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotateLocal(double, double, double)
  - rotateX
```
public Quaterniond rotateX(double angle)
```
    Apply a rotation to this quaternion rotating the given radians about the x axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the x axis
    
    Returns:
    
    this
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotateX
```
public Quaterniond rotateX(double angle,
                           Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the x axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the x axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotateY
```
public Quaterniond rotateY(double angle)
```
    Apply a rotation to this quaternion rotating the given radians about the y axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the y axis
    
    Returns:
    
    this
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotateY
```
public Quaterniond rotateY(double angle,
                           Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the y axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the y axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotateZ
```
public Quaterniond rotateZ(double angle)
```
    Apply a rotation to this quaternion rotating the given radians about the z axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the z axis
    
    Returns:
    
    this
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotateZ
```
public Quaterniond rotateZ(double angle,
                           Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the z axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotate(double, double, double, Quaterniond)
  - rotateLocalX
```
public Quaterniond rotateLocalX(double angle)
```
    Apply a rotation to this quaternion rotating the given radians about the local x axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the local x axis
    
    Returns:
    
    this
  - rotateLocalX
```
public Quaterniond rotateLocalX(double angle,
                                Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the local x axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the local x axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocalY
```
public Quaterniond rotateLocalY(double angle)
```
    Apply a rotation to this quaternion rotating the given radians about the local y axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the local y axis
    
    Returns:
    
    this
  - rotateLocalY
```
public Quaterniond rotateLocalY(double angle,
                                Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the local y axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the local y axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateLocalZ
```
public Quaterniond rotateLocalZ(double angle)
```
    Apply a rotation to this quaternion rotating the given radians about the local z axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the local z axis
    
    Returns:
    
    this
  - rotateLocalZ
```
public Quaterniond rotateLocalZ(double angle,
                                Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the local z axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be R * Q. So when transforming a vector v with the new quaternion by using R * Q * v, the rotation represented by this will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the local z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateXYZ
```
public Quaterniond rotateXYZ(double angleX,
                             double angleY,
                             double angleZ)
```
    Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles using rotation sequence XYZ.
    This method is equivalent to calling: rotateX(angleX).rotateY(angleY).rotateZ(angleZ)
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleX - the angle in radians to rotate about the x axis
    
    angleY - the angle in radians to rotate about the y axis
    
    angleZ - the angle in radians to rotate about the z axis
    
    Returns:
    
    this
  - rotateXYZ
```
public Quaterniond rotateXYZ(double angleX,
                             double angleY,
                             double angleZ,
                             Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles using rotation sequence XYZ and store the result in dest.
    This method is equivalent to calling: rotateX(angleX, dest).rotateY(angleY).rotateZ(angleZ)
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleX - the angle in radians to rotate about the x axis
    
    angleY - the angle in radians to rotate about the y axis
    
    angleZ - the angle in radians to rotate about the z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateZYX
```
public Quaterniond rotateZYX(double angleZ,
                             double angleY,
                             double angleX)
```
    Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence ZYX.
    This method is equivalent to calling: rotateZ(angleZ).rotateY(angleY).rotateX(angleX)
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleZ - the angle in radians to rotate about the z axis
    
    angleY - the angle in radians to rotate about the y axis
    
    angleX - the angle in radians to rotate about the x axis
    
    Returns:
    
    this
  - rotateZYX
```
public Quaterniond rotateZYX(double angleZ,
                             double angleY,
                             double angleX,
                             Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence ZYX and store the result in dest.
    This method is equivalent to calling: rotateZ(angleZ, dest).rotateY(angleY).rotateX(angleX)
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleZ - the angle in radians to rotate about the z axis
    
    angleY - the angle in radians to rotate about the y axis
    
    angleX - the angle in radians to rotate about the x axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateYXZ
```
public Quaterniond rotateYXZ(double angleZ,
                             double angleY,
                             double angleX)
```
    Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence YXZ.
    This method is equivalent to calling: rotateY(angleY).rotateX(angleX).rotateZ(angleZ)
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleY - the angle in radians to rotate about the y axis
    
    angleX - the angle in radians to rotate about the x axis
    
    angleZ - the angle in radians to rotate about the z axis
    
    Returns:
    
    this
  - rotateYXZ
```
public Quaterniond rotateYXZ(double angleY,
                             double angleX,
                             double angleZ,
                             Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the cartesian base unit axes, called the euler angles, using the rotation sequence YXZ and store the result in dest.
    This method is equivalent to calling: rotateY(angleY, dest).rotateX(angleX).rotateZ(angleZ)
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angleY - the angle in radians to rotate about the y axis
    
    angleX - the angle in radians to rotate about the x axis
    
    angleZ - the angle in radians to rotate about the z axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - getEulerAnglesXYZ
```
public Vector3d getEulerAnglesXYZ(Vector3d eulerAngles)
```
    Get the euler angles in radians in rotation sequence XYZ of this quaternion and store them in the provided parameter eulerAngles.
    
    Parameters:
    
    eulerAngles - will hold the euler angles in radians
    
    Returns:
    
    the passed in vector
  - rotateAxis
```
public Quaterniond rotateAxis(double angle,
                              double axisX,
                              double axisY,
                              double axisZ,
                              Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the specified axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the specified axis
    
    axisX - the x coordinate of the rotation axis
    
    axisY - the y coordinate of the rotation axis
    
    axisZ - the z coordinate of the rotation axis
    
    dest - will hold the result
    
    Returns:
    
    dest
  - rotateAxis
```
public Quaterniond rotateAxis(double angle,
                              Vector3d axis,
                              Quaterniond dest)
```
    Apply a rotation to this quaternion rotating the given radians about the specified axis and store the result in dest.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the specified axis
    
    axis - the rotation axis
    
    dest - will hold the result
    
    Returns:
    
    dest
    
    See Also:
    
    rotateAxis(double, double, double, double, Quaterniond)
  - rotateAxis
```
public Quaterniond rotateAxis(double angle,
                              Vector3d axis)
```
    Apply a rotation to this quaternion rotating the given radians about the specified axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the specified axis
    
    axis - the rotation axis
    
    Returns:
    
    this
    
    See Also:
    
    rotateAxis(double, double, double, double, Quaterniond)
  - rotateAxis
```
public Quaterniond rotateAxis(double angle,
                              double axisX,
                              double axisY,
                              double axisZ)
```
    Apply a rotation to this quaternion rotating the given radians about the specified axis.
    If Q is this quaternion and R the quaternion representing the specified rotation, then the new quaternion will be Q * R. So when transforming a vector v with the new quaternion by using Q * R * v, the rotation added by this method will be applied first!
    
    Parameters:
    
    angle - the angle in radians to rotate about the specified axis
    
    axisX - the x coordinate of the rotation axis
    
    axisY - the y coordinate of the rotation axis
    
    axisZ - the z coordinate of the rotation axis
    
    Returns:
    
    this
    
    See Also:
    
    rotateAxis(double, double, double, double, Quaterniond)
  - positiveX
```
public Vector3d positiveX(Vector3d dir)
```
    Obtain the direction of +X before the rotation transformation represented by this quaternion is applied.
    This method is equivalent to the following code:
```
 Quaterniond inv = new Quaterniond(this).invert();
 inv.transform(dir.set(1, 0, 0));
 
```
    Parameters:
    
    dir - will hold the direction of +X
    
    Returns:
    
    dir
  - positiveY
```
public Vector3d positiveY(Vector3d dir)
```
    Obtain the direction of +Y before the rotation transformation represented by this quaternion is applied.
    This method is equivalent to the following code:
```
 Quaterniond inv = new Quaterniond(this).invert();
 inv.transform(dir.set(0, 1, 0));
 
```
    Parameters:
    
    dir - will hold the direction of +Y
    
    Returns:
    
    dir
  - positiveZ
```
public Vector3d positiveZ(Vector3d dir)
```
    Obtain the direction of +Z before the rotation transformation represented by this quaternion is applied.
    This method is equivalent to the following code:
```
 Quaterniond inv = new Quaterniond(this).invert();
 inv.transform(dir.set(0, 0, 1));
 
```
    Parameters:
    
    dir - will hold the direction of +Z
    
    Returns:
    
    dir

Class Quaterniond

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

x

y

z

w

Constructor Detail

Quaterniond

Quaterniond

Quaterniond

Quaterniond

Quaterniond

Quaterniond

Quaterniond

Method Detail

normalize

normalize

add

add

dot

angle

get

get

get

get

get

set

set

set

set

set

set

setAngleAxis

setAngleAxis

setFromUnnormalized

setFromNormalized

setFromUnnormalized

setFromNormalized

setFromUnnormalized

setFromNormalized

setFromUnnormalized

setFromNormalized

fromAxisAngleRad

fromAxisAngleRad

fromAxisAngleDeg

mul

mul

mul

mul

premul

premul

premul

premul

transform

transform

transform

transform

invert

invert

div

div

conjugate

conjugate

identity

lengthSquared

rotationXYZ

rotationZYX

rotationYXZ

slerp

slerp

scale

scale

integrate

integrate

nlerp

nlerp