Class Quaternions4D

java.lang.Object
com.io7m.jtensors.core.quaternions.Quaternions4D
public final class Quaternions4D extends Object

Functions over Quaternion4D values.

See "Mathematics for 3D Game Programming and Computer Graphics" 2nd Ed for the derivations of most of the code in this class (ISBN: 1-58450-277-0).

Since:
8.0.0

  • Method Details

    • add

      public static Quaternion4D add(Quaternion4D q0, Quaternion4D q1)
      Add q0 to q1.
      Parameters:
      q0 - The left quaternion
      q1 - The right quaternion
      Returns:
      (q0.x + q1.x, q0.y + q0.y, q0.z + q1.z, q0.w + q1.w)

    • conjugate

      public static Quaternion4D conjugate(Quaternion4D q)
      Calculate the conjugate of the input quaternion q.
      Parameters:
      q - The input quaternion
      Returns:
      The conjugate of the input quaternion

    • dotProduct

      public static double dotProduct(Quaternion4D q0, Quaternion4D q1)
      Calculate the scalar product of the quaternions q0 and q1.
      Parameters:
      q0 - The left input quaternion
      q1 - The right input quaternion
      Returns:
      The scalar product of the two quaternions

    • identity

      public static Quaternion4D identity()
      The identity quaternion.
      Returns:
      (0, 0, 0, 1)

    • interpolateLinear

      public static Quaternion4D interpolateLinear(Quaternion4D q0, Quaternion4D q1, double alpha)

      Linearly interpolate between q0 and q1 by the amount alpha, such that:

      • interpolateLinear(q0, q1, 0.0) = q0
      • interpolateLinear(q0, q1, 1.0) = q1
      Parameters:
      q0 - The left input quaternion
      q1 - The right input quaternion
      alpha - The interpolation value, between 0.0 and 1.0
      Returns:
      (1 - alpha) * q0 + alpha * q1

    • interpolateSphericalLinear

      public static Quaternion4D interpolateSphericalLinear(Quaternion4D q0, Quaternion4D q1, double alpha)

      Interpolate between q0 and q1, using spherical linear interpolation, by the amount alpha, such that:

      • interpolateSphericalLinear(q0, q1, 0.0) = normalize(q0)
      • interpolateSphericalLinear(q0, q1, 1.0) = normalize(q1)

      Note that unlike simple linear interpolation, this function is guaranteed to return a normalized quaternion.

      Parameters:
      q0 - The left input quaternion
      q1 - The right input quaternion
      alpha - The interpolation value, between 0.0 and 1.0
      Returns:
      A spherical-linearly interpolated quaternion between q0 and q1

    • isNegationOf

      public static boolean isNegationOf(Quaternions4D.ComponentComparatorType c, Quaternion4D qa, Quaternion4D qb)

      Return true iff qa is the negation of qb.

      Parameters:
      qa - The left quaternion
      qb - The right quaternion
      Returns:
      true iff qa is the negation of qb

    • magnitudeSquared

      public static double magnitudeSquared(Quaternion4D q0)
      Calculate the squared magnitude of the quaternion q0.
      Parameters:
      q0 - The quaternion
      Returns:
      The squared magnitude of the quaternion

    • magnitude

      public static double magnitude(Quaternion4D q0)
      Calculate the magnitude of the quaternion q0.
      Parameters:
      q0 - The quaternion
      Returns:
      The magnitude of the quaternion

    • multiply

      public static Quaternion4D multiply(Quaternion4D q0, Quaternion4D q1)

      Multiply the quaternion q0 by the quaternion q1.

      Note that this operation is not commutative.

      The function is most often used to concatenate quaternions to combine rotations. As an example, assuming that:

      • qx represents some rotation around the X axis
      • qy represents some rotation around the Y axis
      • qz represents some rotation around the Z axis

      The following code produces a quaternion qr1 that represents a rotation around the X axis, followed by a rotation around the Y axis, followed by a rotation around the Z axis:

      qr0 = multiply(qy, qx); qr1 = multiply(qz, qy);
      Parameters:
      q0 - The left input quaternion
      q1 - The right input quaternion
      Returns:
      The multiplication of the input quaternions

    • normalize

      public static Quaternion4D normalize(Quaternion4D q0)

      Normalize the quaternion q0.

      If the magnitude of the quaternion is zero, the function returns q0.

      Parameters:
      q0 - The quaternion
      Returns:
      A normalized copy of q0

    • negate

      public static Quaternion4D negate(Quaternion4D q)
      Calculate the negation of the input quaternion q.
      Parameters:
      q - The input quaternion
      Returns:
      The negation of the input quaternion

    • ofAxisAngle

      public static Quaternion4D ofAxisAngle(double axis_x, double axis_y, double axis_z, double r)
      Calculate a quaternion that represents a rotation of r radians around the axis (axis_x, axis_y, axis_z).
      Parameters:
      axis_x - The X component of the axis
      axis_y - The Y component of the axis
      axis_z - The Z component of the axis
      r - The rotation in radians
      Returns:
      A quaternion

    • ofMatrix4x4

      public static Quaternion4D ofMatrix4x4(Matrix4x4D m)
      Calculate a quaternion that represents the rotation given by the matrix m.
      Parameters:
      m - The matrix
      Returns:
      A quaternion

    • ofPMatrix4x4

      public static <A,B> Quaternion4D ofPMatrix4x4(PMatrix4x4D<A,B> m)
      Calculate a quaternion that represents the rotation given by the matrix m.
      Type Parameters:
      A - A phantom type parameter, possibly representing a source coordinate system
      B - A phantom type parameter, possibly representing a target coordinate system
      Parameters:
      m - The matrix
      Returns:
      A quaternion

    • scale

      public static Quaternion4D scale(Quaternion4D q0, double r)
      Scale q0 by r.
      Parameters:
      q0 - The left quaternion
      r - The scaling value
      Returns:
      (q0.x * r, q0.y * r, q0.z * r, q0.w * r)

    • subtract

      public static Quaternion4D subtract(Quaternion4D q0, Quaternion4D q1)
      Add q0 to q1.
      Parameters:
      q0 - The left quaternion
      q1 - The right quaternion
      Returns:
      (q0.x - q1.x, q0.y - q0.y, q0.z - q1.z, q0.w - q1.w)

    • toMatrix4x4

      public static Matrix4x4D toMatrix4x4(Quaternion4D q)
      Create a 4x4 matrix from the quaternion q.
      Parameters:
      q - The quaternion
      Returns:
      A matrix based on q

    • toPMatrix4x4

      public static <A,B> PMatrix4x4D<A,B> toPMatrix4x4(Quaternion4D q)
      Create a 4x4 matrix from the quaternion q.
      Type Parameters:
      A - A phantom type parameter, possibly representing a source coordinate system
      B - A phantom type parameter, possibly representing a target coordinate system
      Parameters:
      q - The quaternion
      Returns:
      A matrix based on q

    • zero

      public static Quaternion4D zero()
      The zero quaternion.
      Returns:
      (0, 0, 0, 0)