java.lang.Object
- nub.primitives.Quaternion

```
public class Quaternion
extends Object
```
A 4 element unit quaternion represented by single precision floating point x,y,z,w coordinates. This class API aims to conform that of the great libQGLViewer Quaternion.

Field Summary

Fields
Modifier and Type	Field	Description
`float[]`	`_quaternion`	The x, y, z, and w coordinates of the quaternion represented as a public array.
`static Quaternion`	`identity`	Returns a quaternion whose components are set to `(0, 0, 0, 1)`.

Constructor Summary

Constructors
Constructor	Description
`Quaternion()`	Constructs and initializes a quaternion to (0.0,0.0,0.0,1.0), i.e., an identity rotation.
`Quaternion(float angle)`	Same as `fromAxisAngle(new Vector(0,0,1), angle)`.
`Quaternion(float[] source)`	Convenience constructor that simply calls `this(source, true)`
`Quaternion(float[] source, boolean normalize)`	Constructs and initializes a quaternion from the array of length 4.
`Quaternion(float roll, float pitch, float yaw)`	Constructs a quaternion from the given Euler angles.
`Quaternion(float x, float y, float z, float w)`	Default constructor for Quaternion(float x, float y, float z, float w, boolean normalize), with `normalize=true`.
`Quaternion(float x, float y, float z, float w, boolean normalize)`	Constructs and initializes a quaternion from the specified xyzw coordinates.
`Quaternion(Matrix matrix)`	Constructs a quaternion from a (supposedly correct) 3x3 rotation matrix given in the upper left 3x3 sub-matrix of the Matrix.
`Quaternion(Quaternion quaternion, boolean normalize)`	Copy constructor.
`Quaternion(Vector axis, float angle)`	Constructs and initializes a quaternion from the specified rotation `axis` (non null) and `angle` (in radians).
`Quaternion(Vector from, Vector to)`	Constructs a quaternion that will rotate from the `from` direction to the `to` direction.
`Quaternion(Vector X, Vector Y, Vector Z)`	Constructs a quaternion from the three rotated vectors of an orthogonal basis.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`float`	`angle()`	Returns the `angle` (in radians) of the rotation represented by the quaternion.
`float`	`angle2D()`	Same as `return axis().z() > 0 ? angle() : -angle()`.
`Vector`	`axis()`	Returns the normalized axis direction of the rotation represented by the quaternion.
`void`	`compose(Quaternion quaternion)`	Same as `multiply(quaternion)`.
`static Quaternion`	`compose(Quaternion a, Quaternion b)`	Same as `return multiply(a, b)`.
`void`	`conjugate()`	Sets this as its conjugate.
`void`	`conjugate(Quaternion quaternion)`	Sets this as the quaternion conjugate.
`Quaternion`	`copy()`	Returns a deep copy of this quaternion.
`static float`	`dot(Quaternion a, Quaternion b)`	Returns the "dot" product of `a` and `b`:
`float`	`dotProduct(Quaternion quaternion)`	Returns the "dot" product of this quaternion and `quaternion`:
`Vector`	`eulerAngles()`	Converts this quaternion to Euler rotation angles `roll`, `pitch` and `yaw` in radians.
`Quaternion`	`exp()`	Returns the quaternion exponential.
`static Quaternion`	`from(Object... params)`	Converts various orientation representations to quaternion form and returns it.
`void`	`fromAxisAngle(Vector axis, float angle)`	Sets the quaternion as a rotation of `axis` and `angle` (in radians).
`void`	`fromEulerAngles(float roll, float pitch, float yaw)`	Converts Euler rotation angles `roll`, `pitch` and `yaw`, respectively defined to the x, y and z axes, to this quaternion.
`void`	`fromMatrix(Matrix matrix)`	Set the quaternion from a (supposedly correct) 3x3 rotation matrix given in the upper left 3x3 sub-matrix of the Matrix.
`void`	`fromRotatedBasis(Vector X, Vector Y, Vector Z)`	Sets the quaternion from the three rotated vectors of an orthogonal basis.
`void`	`fromTo(Vector from, Vector to)`	Sets the quaternion as a rotation from the `from` direction to the `to` direction.
`float[]`	`get(float[] target)`	Returns a copy of this quaternion into the four length `target` array.
`Quaternion`	`inverse()`	Returns the inverse quaternion (inverse rotation).
`Matrix`	`inverseMatrix()`	Returns the associated inverse rotation matrix.
`Vector`	`inverseRotate(Vector vector)`	Returns the image of `vector` by the quaternion `inverse()` rotation.
`void`	`invert()`	Sets the value of this to the inverse of itself.
`void`	`invert(Quaternion quaternion)`	Sets the value of this to the Quaternion inverse of `quaternion`.
`static Quaternion`	`lnDif(Quaternion a, Quaternion b)`	Simply returns `log(a. inverse() * b)`.
`Quaternion`	`log()`	Returns the quaternion logarithm.
`boolean`	`matches(Quaternion quaternion)`	Returns whether or not this quaternion matches other.
`Matrix`	`matrix()`	Returns the rotation matrix associated with the quaternion.
`void`	`multiply(Quaternion quaternion)`	Sets this as the quaternion product of itself and `quaternion`, (i.e., `this = this * quaternion`).
`static Quaternion`	`multiply(Quaternion a, Quaternion b)`	Returns the product of quaternions `a` and `b`.
`static Vector`	`multiply(Quaternion quaternion, Vector vector)`	Returns the image of `vector` by the rotation `quaternion`.
`Vector`	`multiply(Vector vector)`	Returns the image of `vector` by the rotation of this vector.
`void`	`multiplyInverse(Quaternion q1)`	Multiplies this by the inverse of Quaternion `q1` and places the value into this (i.e., `this = this * q^-1`).
`static Quaternion`	`multiplyInverse(Quaternion q1, Quaternion q2)`	Returns the product of quaternion `q1` by the inverse of quaternion `q2` (i.e., `q1 * q2^-1`).
`void`	`negate()`	Negates all the coefficients of the quaternion.
`float`	`norm()`	Returns the norm of this quaternion.
`float`	`normalize()`	Normalize this quaternion return its `norm()`.
`static Quaternion`	`random()`	Returns a normalized random quaternion.
`void`	`randomize()`	Randomize this quaternion.
`void`	`reset()`	Make this an identity quaternion.
`Vector`	`rotate(Vector vector)`	Returns the image of `vector` by the quaternion rotation.
`void`	`set(float[] source)`	Sets this quaternion from the four length `source` array.
`void`	`set(Quaternion quaternion)`	Convenience function that simply calls `set(quaternion, true);`
`void`	`set(Quaternion quaternion, boolean normalize)`	Set this from quaternion `quaternion`.
`void`	`setW(float w)`	Sets the Quaternion w component
`void`	`setX(float x)`	Sets the Quaternion x component
`void`	`setY(float y)`	Sets the Quaternion y component
`void`	`setZ(float z)`	Sets the Quaternion z component
`static Quaternion`	`slerp(Quaternion a, Quaternion b, float t)`	Wrapper function that simply calls `slerp(a, b, t, true)`.
`static Quaternion`	`slerp(Quaternion a, Quaternion b, float t, boolean allowFlip)`	Returns the slerp interpolation of quaternions `a` and `b`, at time `t`.
`static Quaternion`	`squad(Quaternion a, Quaternion tgA, Quaternion tgB, Quaternion b, float t)`	Returns the slerp interpolation of the two quaternions `a` and `b`, at time `t`, using tangents `tgA` and `tgB`.
`static Quaternion`	`squadTangent(Quaternion before, Quaternion center, Quaternion after)`	Returns a tangent quaternion for `center`, defined by `before` and `after` quaternions.
`static float`	`squaredNorm(Quaternion quaternion)`	Utility function that returns the squared norm of the quaternion.
`String`	`toString()`	Return this quaternion components as a String.
`float`	`w()`
`float`	`x()`
`float`	`y()`
`float`	`z()`

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - _quaternion
```
public float[] _quaternion
```
    The x, y, z, and w coordinates of the quaternion represented as a public array.
  - identity
```
public static final Quaternion identity
```
    Returns a quaternion whose components are set to (0, 0, 0, 1).
    
    See Also:
    
    from(Object...)
- Constructor Detail
  - Quaternion
```
public Quaternion()
```
    Constructs and initializes a quaternion to (0.0,0.0,0.0,1.0), i.e., an identity rotation.
  - Quaternion
```
public Quaternion(float x,
                  float y,
                  float z,
                  float w)
```
    Default constructor for Quaternion(float x, float y, float z, float w, boolean normalize), with normalize=true.
  - Quaternion
```
public Quaternion(float x,
                  float y,
                  float z,
                  float w,
                  boolean normalize)
```
    Constructs and initializes a quaternion from the specified xyzw coordinates.
    
    Parameters:
    
    x - the x coordinate
    
    y - the y coordinate
    
    z - the z coordinate
    
    w - the w scalar component
    
    normalize - tells whether or not the constructed Quaternion should be normalized.
  - Quaternion
```
public Quaternion(float[] source)
```
    Convenience constructor that simply calls this(source, true)
  - Quaternion
```
public Quaternion(float[] source,
                  boolean normalize)
```
    Constructs and initializes a quaternion from the array of length 4.
    
    Parameters:
    
    source - the array of length 4 containing xyzw in order
  - Quaternion
```
public Quaternion(Quaternion quaternion,
                  boolean normalize)
```
    Copy constructor. If normalize is true this quaternion is normalize().
    
    Parameters:
    
    quaternion - the Quaternion containing the initialization x y z w data
  - Quaternion
```
public Quaternion(float angle)
```
    Same as fromAxisAngle(new Vector(0,0,1), angle).
    Constructs and initializes a quaternion from the specified 2d rotation angle (in radians). The axis of the quaternion is Z.
    
    Parameters:
    
    angle - the angle in radians
    
    See Also:
    
    fromAxisAngle(Vector, float)
  - Quaternion
```
public Quaternion(Vector axis,
                  float angle)
```
    Constructs and initializes a quaternion from the specified rotation axis (non null) and angle (in radians).
    
    Parameters:
    
    axis - the Vector representing the axis
    
    angle - the angle in radians
    
    See Also:
    
    fromAxisAngle(Vector, float)
  - Quaternion
```
public Quaternion(Vector from,
                  Vector to)
```
    Constructs a quaternion that will rotate from the from direction to the to direction.
    
    Parameters:
    
    from - the first Vector
    
    to - the second Vector
    
    See Also:
    
    fromTo(Vector, Vector)
  - Quaternion
```
public Quaternion(float roll,
                  float pitch,
                  float yaw)
```
    Constructs a quaternion from the given Euler angles.
    
    Parameters:
    
    roll - Rotation angle in radians around the x-Axis
    
    pitch - Rotation angle in radians around the y-Axis
    
    yaw - Rotation angle in radians around the z-Axis
    
    See Also:
    
    fromEulerAngles(float, float, float)
  - Quaternion
```
public Quaternion(Matrix matrix)
```
    Constructs a quaternion from a (supposedly correct) 3x3 rotation matrix given in the upper left 3x3 sub-matrix of the Matrix.
    
    Parameters:
    
    matrix -
    
    See Also:
    
    fromMatrix(Matrix)
  - Quaternion
```
public Quaternion(Vector X,
                  Vector Y,
                  Vector Z)
```
    Constructs a quaternion from the three rotated vectors of an orthogonal basis.
    
    Parameters:
    
    X - 1st Orthogonal Vector
    
    Y - 2nd Orthogonal Vector
    
    Z - 3rd Orthogonal Vector
    
    See Also:
    
    fromRotatedBasis(Vector, Vector, Vector)
- Method Detail
  - matches
```
public boolean matches(Quaternion quaternion)
```
    Returns whether or not this quaternion matches other.
    
    Parameters:
    
    quaternion - other quaternion
  - copy
```
public Quaternion copy()
```
    Returns a deep copy of this quaternion.
  - from
```
public static final Quaternion from(Object... params)
```
    Converts various orientation representations to quaternion form and returns it. According to the numbers and types of params passed the following representations are supported:
    
    One params: if its type is Matrix it returns a quaternion from the given 'matrix-form' (see Quaternion(Matrix)). If its type is Quaternion then the quaternion is cloned (see copy()) and returned. If it's of type float[] then a quaternion is returned from the 4-array elements (see Quaternion(float[])).
    
    Two params: if both params are of type Vector it returns the quaternion which would produce the rotation from the first vector param to the second (see Quaternion(Vector, Vector)). If the first params is of type Vector and the second of type Float it returns the quaternion from the given 'axis-angle form', (see Quaternion(Vector, float)).
    
    Three params: If the three params are of type Float it returns a quaternion from the given 'Euler angles form', (see Quaternion(float, float, float)). If the three params are of type Vector it returns a quaternion from the given 'rotated-basis form', (see Quaternion(Vector, Vector, Vector)).
    
    It params cannot be parsed a new Quaternion (#identity) is returned.
    See Also:
    
    Quaternion(Matrix), copy(), Quaternion(float[]), Quaternion(Vector, Vector), Quaternion(Vector, float), Quaternion(Vector, Vector, Vector)
  - randomize
```
public void randomize()
```
    Randomize this quaternion. The quaternion is normalized too.
    
    See Also:
    
    random()
  - random
```
public static Quaternion random()
```
    Returns a normalized random quaternion.
    
    See Also:
    
    randomize()
  - reset
```
public void reset()
```
    Make this an identity quaternion.
  - get
```
public float[] get(float[] target)
```
    Returns a copy of this quaternion into the four length target array.
  - set
```
public void set(float[] source)
```
    Sets this quaternion from the four length source array.
  - x
```
public float x()
```
    Returns:
    
    Quaternion x component
  - y
```
public float y()
```
    Returns:
    
    Quaternion y component
  - z
```
public float z()
```
    Returns:
    
    Quaternion z component
  - w
```
public float w()
```
    Returns:
    
    Quaternion w component
  - setX
```
public void setX(float x)
```
    Sets the Quaternion x component
  - setY
```
public void setY(float y)
```
    Sets the Quaternion y component
  - setZ
```
public void setZ(float z)
```
    Sets the Quaternion z component
  - setW
```
public void setW(float w)
```
    Sets the Quaternion w component
  - set
```
public void set(Quaternion quaternion)
```
    Convenience function that simply calls set(quaternion, true);
    
    See Also:
    
    set(Quaternion, boolean)
  - set
```
public void set(Quaternion quaternion,
                boolean normalize)
```
    Set this from quaternion quaternion. If normalize is true this Quaternion is normalize().
  - conjugate
```
public void conjugate()
```
    Sets this as its conjugate.
  - conjugate
```
public void conjugate(Quaternion quaternion)
```
    Sets this as the quaternion conjugate.
    
    Parameters:
    
    quaternion - the source vector
  - negate
```
public void negate()
```
    Negates all the coefficients of the quaternion.
  - dotProduct
```
public float dotProduct(Quaternion quaternion)
```
    Returns the "dot" product of this quaternion and quaternion:
    this._quaternion[0] * quaternion._quaternion[0] + this._quaternion[1] * quaternion._quaternion[1] + this._quaternion[2] * quaternion._quaternion[2] + this._quaternion[3] * quaternion._quaternion[3]
    
    Parameters:
    
    quaternion - the Quaternion
  - dot
```
public static float dot(Quaternion a,
                        Quaternion b)
```
    Returns the "dot" product of a and b:
    a.x * b.x + a.y * b.y + a.z * b.z + a.w * b.w
    
    Parameters:
    
    a - the first Quaternion
    
    b - the second Quaternion
  - compose
```
public void compose(Quaternion quaternion)
```
    Same as multiply(quaternion).
    
    See Also:
    
    multiply(Quaternion)
  - multiply
```
public void multiply(Quaternion quaternion)
```
    Sets this as the quaternion product of itself and quaternion, (i.e., this = this * quaternion).
    
    Parameters:
    
    quaternion - the other Quaternion
  - compose
```
public static Quaternion compose(Quaternion a,
                                 Quaternion b)
```
    Same as return multiply(a, b).
    
    See Also:
    
    multiply(Quaternion, Vector)
  - multiply
```
public static Quaternion multiply(Quaternion a,
                                  Quaternion b)
```
    Returns the product of quaternions a and b.
    
    Parameters:
    
    a - the first Quaternion
    
    b - the second Quaternion
  - multiply
```
public Vector multiply(Vector vector)
```
    Returns the image of vector by the rotation of this vector. Same as this.rotate(vector).
    
    Parameters:
    
    vector - the Vector
    
    See Also:
    
    rotate(Vector), inverseRotate(Vector)
  - multiply
```
public static Vector multiply(Quaternion quaternion,
                              Vector vector)
```
    Returns the image of vector by the rotation quaternion. Same as quaternion.rotate(vector).
    
    Parameters:
    
    quaternion - the Quaternion
    
    vector - the Vector
    
    See Also:
    
    rotate(Vector), inverseRotate(Vector)
  - multiplyInverse
```
public void multiplyInverse(Quaternion q1)
```
    Multiplies this by the inverse of Quaternion q1 and places the value into this (i.e., this = this * q^-1). The value of the argument quaternion is preserved.
    
    Parameters:
    
    q1 - the other Quaternion
  - multiplyInverse
```
public static Quaternion multiplyInverse(Quaternion q1,
                                         Quaternion q2)
```
    Returns the product of quaternion q1 by the inverse of quaternion q2 (i.e., q1 * q2^-1). The value of both argument quaternions is preserved.
    
    Parameters:
    
    q1 - the first Quaternion
    
    q2 - the second Quaternion
  - inverse
```
public Quaternion inverse()
```
    Returns the inverse quaternion (inverse rotation).
    The result has a negated axis() direction and the same angle().
    A composition of a quaternion and its inverse() results in an identity function. Use invert() to actually modify the quaternion.
    
    See Also:
    
    invert()
  - invert
```
public void invert()
```
    Sets the value of this to the inverse of itself.
    
    See Also:
    
    inverse()
  - invert
```
public void invert(Quaternion quaternion)
```
    Sets the value of this to the Quaternion inverse of quaternion.
    
    Parameters:
    
    quaternion - the Quaternion to be inverted
  - normalize
```
public float normalize()
```
    Normalize this quaternion return its norm().
  - norm
```
public float norm()
```
    Returns the norm of this quaternion.
  - rotate
```
public Vector rotate(Vector vector)
```
    Returns the image of vector by the quaternion rotation.
    
    Parameters:
    
    vector - the Vector
  - inverseRotate
```
public Vector inverseRotate(Vector vector)
```
    Returns the image of vector by the quaternion inverse() rotation.
    rotate(Vector) performs an inverse transformation.
    
    Parameters:
    
    vector - the Vector
  - fromAxisAngle
```
public void fromAxisAngle(Vector axis,
                          float angle)
```
    Sets the quaternion as a rotation of axis and angle (in radians).
    The axis does not need to be normalized. A null axis will result in an identity quaternion.
    
    Parameters:
    
    axis - the Vector representing the axis
    
    angle - the angle in radians
    
    See Also:
    
    fromTo(Vector, Vector), fromMatrix(Matrix), fromRotatedBasis(Vector, Vector, Vector), fromEulerAngles(float, float, float)
  - fromEulerAngles
```
public void fromEulerAngles(float roll,
                            float pitch,
                            float yaw)
```
    Converts Euler rotation angles roll, pitch and yaw, respectively defined to the x, y and z axes, to this quaternion. In the convention used here these angles represent a composition of extrinsic rotations (rotations about the reference node axes), which is also known as Tait-Bryan angles (See http://en.wikipedia.org/wiki/Euler_angles and http://en.wikipedia.org/wiki/Tait-Bryan_angles). eulerAngles() performs the inverse operation.
    Each rotation angle is converted to an axis-angle pair, with the axis corresponding to one of the Euclidean axes. The axis-angle pairs are converted to quaternions and multiplied together. The order of the rotations is: y,z,x which follows the convention found here: http://www.euclideanspace.com/maths/geometry/rotations/euler/index.htm
    
    See Also:
    
    fromTo(Vector, Vector), fromMatrix(Matrix), fromRotatedBasis(Vector, Vector, Vector), fromAxisAngle(Vector, float), eulerAngles()
  - eulerAngles
```
public Vector eulerAngles()
```
    Converts this quaternion to Euler rotation angles roll, pitch and yaw in radians. fromEulerAngles(float, float, float) performs the inverse operation. The code was adapted from: http://www.euclideanspace.com/maths/geometry/rotations/conversions/ quaternionToEuler/index.htm. Attention: This method assumes that this quaternion is normalized.
    
    Returns:
    
    the Vector holding the roll (x coordinate of the vector), pitch (y coordinate of the vector) and yaw angles (z coordinate of the vector). Note: The order of the rotations that would produce this Quaternion (i.e., as with fromEulerAngles(roll, pitch, yaw)) is: y,z,x.
    
    See Also:
    
    fromEulerAngles(float, float, float)
  - fromTo
```
public void fromTo(Vector from,
                   Vector to)
```
    Sets the quaternion as a rotation from the from direction to the to direction. Attention: this rotation is not uniquely defined. The selected axis is usually orthogonal to from and to, minimizing the rotation angle. This method is robust and can handle small or almost identical vectors.
    
    See Also:
    
    fromRotatedBasis(Vector, Vector, Vector), fromEulerAngles(float, float, float), fromMatrix(Matrix), fromAxisAngle(Vector, float)
  - fromMatrix
```
public void fromMatrix(Matrix matrix)
```
    Set the quaternion from a (supposedly correct) 3x3 rotation matrix given in the upper left 3x3 sub-matrix of the Matrix.
    
    See Also:
    
    fromTo(Vector, Vector), fromEulerAngles(float, float, float), fromRotatedBasis(Vector, Vector, Vector), fromAxisAngle(Vector, float), fromRotatedBasis(Vector, Vector, Vector)
  - fromRotatedBasis
```
public void fromRotatedBasis(Vector X,
                             Vector Y,
                             Vector Z)
```
    Sets the quaternion from the three rotated vectors of an orthogonal basis.
    The three vectors do not have to be normalized but must be orthogonal and direct (i,e., X^Y=k*Z, with k>0).
    
    Parameters:
    
    X - the first Vector
    
    Y - the second Vector
    
    Z - the third Vector
    
    See Also:
    
    fromTo(Vector, Vector), fromEulerAngles(float, float, float), fromMatrix(Matrix), fromAxisAngle(Vector, float), fromRotatedBasis(Vector, Vector, Vector), Quaternion(Vector, Vector)
  - axis
```
public Vector axis()
```
    Returns the normalized axis direction of the rotation represented by the quaternion.
    The result is (0,0,0) for an identity quaternion.
    
    See Also:
    
    angle()
  - angle
```
public float angle()
```
    Returns the angle (in radians) of the rotation represented by the quaternion.
    This value is always in the range [0-pi]. Larger rotational angles are obtained by inverting the axis() direction.
    
    See Also:
    
    axis()
  - angle2D
```
public float angle2D()
```
    Same as return axis().z() > 0 ? angle() : -angle().
    
    See Also:
    
    angle()
  - matrix
```
public Matrix matrix()
```
    Returns the rotation matrix associated with the quaternion.
  - inverseMatrix
```
public Matrix inverseMatrix()
```
    Returns the associated inverse rotation matrix. This is simply matrix() of the inverse(). Attention: The result is only valid until the next call to inverseMatrix(). Use it immediately (as in applyMatrix(q.inverseMatrix())).
  - log
```
public Quaternion log()
```
    Returns the quaternion logarithm.
    
    See Also:
    
    exp()
  - exp
```
public Quaternion exp()
```
    Returns the quaternion exponential.
    
    See Also:
    
    log()
  - slerp
```
public static Quaternion slerp(Quaternion a,
                               Quaternion b,
                               float t)
```
    Wrapper function that simply calls slerp(a, b, t, true).
    See slerp(Quaternion, Quaternion, float, boolean) for details.
  - slerp
```
public static Quaternion slerp(Quaternion a,
                               Quaternion b,
                               float t,
                               boolean allowFlip)
```
    Returns the slerp interpolation of quaternions a and b, at time t.
    t should range in [0,1]. Result is a when t=0 and b when t=1.
    When allowFlip is true (default) the slerp interpolation will always use the "shortest path" between the quaternions' orientations, by "flipping" the source quaternion if needed (see negate()).
    
    Parameters:
    
    a - the first Quaternion
    
    b - the second Quaternion
    
    t - the t interpolation parameter
    
    allowFlip - tells whether or not the interpolation allows axis flip
  - squad
```
public static Quaternion squad(Quaternion a,
                               Quaternion tgA,
                               Quaternion tgB,
                               Quaternion b,
                               float t)
```
    Returns the slerp interpolation of the two quaternions a and b, at time t, using tangents tgA and tgB.
    The resulting quaternion is "between" a and b (result is a when t=0 and b for t=1).
    Use squadTangent(Quaternion, Quaternion, Quaternion) to define the quaternion tangents tgA and tgB.
    
    Parameters:
    
    a - the first Quaternion
    
    tgA - the first tangent Quaternion
    
    tgB - the second tangent Quaternion
    
    b - the second Quaternion
    
    t - the t interpolation parameter
  - lnDif
```
public static Quaternion lnDif(Quaternion a,
                               Quaternion b)
```
    Simply returns log(a. inverse() * b).
    Useful for squadTangent(Quaternion, Quaternion, Quaternion).
    
    Parameters:
    
    a - the first Quaternion
    
    b - the second Quaternion
  - squadTangent
```
public static Quaternion squadTangent(Quaternion before,
                                      Quaternion center,
                                      Quaternion after)
```
    Returns a tangent quaternion for center, defined by before and after quaternions.
    
    Parameters:
    
    before - the first Quaternion
    
    center - the second Quaternion
    
    after - the third Quaternion
  - squaredNorm
```
public static float squaredNorm(Quaternion quaternion)
```
    Utility function that returns the squared norm of the quaternion.
  - toString
```
public String toString()
```
    Return this quaternion components as a String.
    
    Overrides:
    
    toString in class Object

Class Quaternion

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

_quaternion

identity

Constructor Detail

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Method Detail

matches

copy

from

randomize

random

reset

get

set

x

y

z

w

setX

setY

setZ

setW

set

set

conjugate

conjugate

negate

dotProduct

dot

compose

multiply

compose

multiply

multiply

multiply

multiplyInverse

multiplyInverse

inverse

invert

invert

normalize

norm

rotate

inverseRotate

fromAxisAngle

fromEulerAngles

eulerAngles

fromTo

fromMatrix

fromRotatedBasis

axis

angle

angle2D

matrix

inverseMatrix

log

exp

slerp

slerp

squad

lnDif

squadTangent

squaredNorm

toString