com.io7m.jtensors

## Class QuaternionM4F

- java.lang.Object
- - com.io7m.jtensors.QuaternionM4F

- All Implemented Interfaces:
    Quaternion4FType, QuaternionReadable4FType, QuaternionWritable4FType, Vector2FType, Vector3FType, Vector4FType, VectorReadable2FType, VectorReadable3FType, VectorReadable4FType, VectorWritable2FType, VectorWritable3FType, VectorWritable4FType

      public final class QuaternionM4F
      extends Object
      implements Quaternion4FType

  A four-dimensional mutable quaternion type with `float` elements.

  Values of this type cannot be accessed safely from multiple threads without explicit synchronization.

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `QuaternionM4F.ContextQM4F` The ContextQM4F type contains the minimum storage required for all of the functions of the `QuaternionM4D` class.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `QuaternionM4F()` Default constructor, initializing the quaternion with values `[0.0, 0.0, 0.0, 1.0]`
    `QuaternionM4F(float in_x, float in_y, float in_z, float in_w)` Construct a quaternion initialized with the given values.
    `QuaternionM4F(QuaternionReadable4FType q)` Construct a quaternion initialized with the values given in `q`.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <Q extends QuaternionWritable4FType> Q` | `add(QuaternionReadable4FType q0, QuaternionReadable4FType q1, Q out)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `qr`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `addInPlace(Q q0, QuaternionReadable4FType q1)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `q0`.
    `static boolean` | `almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb)` Determine whether or not the quaternions `qa` and `qb` are equal to within the degree of error given in `context`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `conjugate(QuaternionReadable4FType q, Q out)` Calculate the conjugate of the input quaternion `q`, saving the result to `out`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `conjugateInPlace(Q q)` Calculate the conjugate of the input quaternion `q`, modifying `q` in place.
    `static <Q extends QuaternionWritable4FType> Q` | `copy(QuaternionReadable4FType q, Q out)` Copy the contents of the quaternion `q` to `out`.
    `void` | `copyFrom2F(VectorReadable2FType in_v)` Set the current vector to the contents of the input vector.
    `void` | `copyFrom3F(VectorReadable3FType in_v)` Set the current vector to the contents of the input vector.
    `void` | `copyFrom4F(VectorReadable4FType in_v)` Set the current vector to the contents of the input vector.
    `static double` | `dotProduct(QuaternionReadable4FType q0, QuaternionReadable4FType q1)` Calculate the scalar product of the quaternions `q0` and `q1`.
    `boolean` | `equals(Object obj)`
    `float` | `getWF()`
    `float` | `getXF()`
    `float` | `getYF()`
    `float` | `getZF()`
    `int` | `hashCode()`
    `static <Q extends QuaternionWritable4FType> Q` | `interpolateLinear(QuaternionM4F.ContextQM4F c, QuaternionReadable4FType q0, QuaternionReadable4FType q1, double alpha, Q r)` Linearly interpolate between `q0` and `q1` by the amount `alpha`, such that: `interpolateLinear(q0, q1, 0.0, r) -> r = q0` `interpolateLinear(q0, q1, 1.0, r) -> r = q1`
    `static boolean` | `isNegationOf(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb)` Return `true` iff `qa` is the negation of `qb`.
    `static <Q extends QuaternionWritable4FType> Q` | `lookAt(QuaternionM4F.ContextQM4F context, VectorReadable3FType origin, VectorReadable3FType target, VectorReadable3FType up, Q q)` Produce a quaternion that represents a rotation that "looks at" the point at `target` assuming the viewer is at `origin`, using `up` as the "up" vector, saving the result to `q`.
    `static double` | `magnitude(QuaternionReadable4FType q)` Calculate the magnitude of the quaternion `q`.
    `static double` | `magnitudeSquared(QuaternionReadable4FType q)` Calculate the squared magnitude of the quaternion `q`.
    `static <Q extends QuaternionWritable4FType> Q` | `makeFromAxisAngle(VectorReadable3FType axis, double angle, Q out)` Produce a quaternion that represents a rotation of `angle` degrees around the axis specified by `axis`, saving the result to `out`.
    `static <Q extends QuaternionWritable4FType> Q` | `makeFromRotationMatrix3x3(MatrixReadable3x3FType m, Q out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
    `static <Q extends QuaternionWritable4FType> Q` | `makeFromRotationMatrix4x4(MatrixReadable4x4FType m, Q out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
    `static <M extends MatrixWritable3x3FType> M` | `makeRotationMatrix3x3(QuaternionReadable4FType q, M m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
    `static <M extends MatrixWritable4x4FType> M` | `makeRotationMatrix4x4(QuaternionReadable4FType q, M m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
    `static <Q extends QuaternionWritable4FType> Q` | `multiply(QuaternionReadable4FType q0, QuaternionReadable4FType q1, Q qr)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `qr`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `multiplyInPlace(Q q0, QuaternionReadable4FType q1)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `q0`.
    `static <Q extends QuaternionWritable4FType> Q` | `negate(QuaternionReadable4FType qa, Q out)` Negate the elements of `qa`, writing the resulting quaternion to `out`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `negateInPlace(Q q)` Negate the elements of `q`, modifying the quaternion in-place.
    `static <Q extends QuaternionWritable4FType> Q` | `normalize(QuaternionReadable4FType q, Q out)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `out`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `normalizeInPlace(Q q)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `q`.
    `static <Q extends QuaternionWritable4FType> Q` | `scale(QuaternionReadable4FType q, double r, Q out)` Scale the quaternion `q` by the scalar `r`, saving the result to `out`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `scaleInPlace(Q q, double r)` Scale the quaternion `q` by the scalar `r`, saving the result to `q`.
    `void` | `set2F(float in_x, float in_y)` Set the current `x` and `y` values of the current vector.
    `void` | `set3F(float in_x, float in_y, float in_z)` Set the current `x`, `y` and `z` values of the current vector.
    `void` | `set4F(float in_x, float in_y, float in_z, float in_w)` Set the current `x`, `y`, `z` and `w` values of the current vector.
    `void` | `setWF(float in_w)` Set the current `w` value of the current vector.
    `void` | `setXF(float in_x)` Set the current `x` value of the current vector.
    `void` | `setYF(float in_y)` Set the current `y` value of the current vector.
    `void` | `setZF(float in_z)` Set the current `z` value of the current vector.
    `static <Q extends QuaternionWritable4FType> Q` | `subtract(QuaternionReadable4FType q0, QuaternionReadable4FType q1, Q out)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `out`.
    `static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q` | `subtractInPlace(Q q0, QuaternionReadable4FType q1)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `q0`.
    `static <V extends VectorWritable3FType> double` | `toAxisAngle(QuaternionReadable4FType q, V out)` Determine the axis-angle representation of the given quaternion.
    `String` | `toString()`

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### QuaternionM4F

          public QuaternionM4F()

      Default constructor, initializing the quaternion with values `[0.0, 0.0, 0.0, 1.0]`

    - #### QuaternionM4F

          public QuaternionM4F(float in_x,
                               float in_y,
                               float in_z,
                               float in_w)

      Construct a quaternion initialized with the given values.
      Parameters:
        `in_x` - The `x` value
        `in_y` - The `y` value
        `in_z` - The `z` value
        `in_w` - The `w` value

    - #### QuaternionM4F

          public QuaternionM4F(QuaternionReadable4FType q)

      Construct a quaternion initialized with the values given in `q`.
      Parameters:
        `q` - The source quaternion

  - ### Method Detail

    - #### add

          public static <Q extends QuaternionWritable4FType> Q add(QuaternionReadable4FType q0,
                                                                   QuaternionReadable4FType q1,
                                                                   Q out)

      Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `qr`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q0` - The left input quaternion
        `q1` - The right input quaternion
        `out` - The output quaternion
      Returns:
        `(q0.x + q1.x, q0.y + q1.y, q0.z + q1.z, q0.w + q1.w)`

    - #### addInPlace

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q addInPlace(Q q0,
                                                                                                     QuaternionReadable4FType q1)

      Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `q0`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q0` - The left input quaternion
        `q1` - The right input quaternion
      Returns:
        `(q0.x + q1.x, q0.y + q1.y, q0.z + q1.z, q0.w + q1.w)`

    - #### almostEqual

          public static boolean almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                            QuaternionReadable4FType qa,
                                            QuaternionReadable4FType qb)

      Determine whether or not the quaternions `qa` and `qb` are equal to within the degree of error given in `context`.
      Parameters:
        `context` - The equality context
        `qa` - The left input quaternion
        `qb` - The right input quaternion
      Returns:
        `true` if the quaternions are almost equal
      Since:
        5.0.0
      See Also:
        `AlmostEqualFloat.almostEqual(ContextRelative, float, float)`

    - #### conjugate

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q conjugate(QuaternionReadable4FType q,
                                                                                                    Q out)

      Calculate the conjugate of the input quaternion `q`, saving the result to `out`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q` - The input quaternion
        `out` - The output quaternion
      Returns:
        `out`

    - #### conjugateInPlace

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q conjugateInPlace(Q q)

      Calculate the conjugate of the input quaternion `q`, modifying `q` in place.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q` - The input quaternion
      Returns:
        `q`

    - #### copy

          public static <Q extends QuaternionWritable4FType> Q copy(QuaternionReadable4FType q,
                                                                    Q out)

      Copy the contents of the quaternion `q` to `out`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q` - The input quaternion
        `out` - The output quaternion
      Returns:
        `out`

    - #### dotProduct

          public static double dotProduct(QuaternionReadable4FType q0,
                                          QuaternionReadable4FType 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

    - #### interpolateLinear

          public static <Q extends QuaternionWritable4FType> Q interpolateLinear(QuaternionM4F.ContextQM4F c,
                                                                                 QuaternionReadable4FType q0,
                                                                                 QuaternionReadable4FType q1,
                                                                                 double alpha,
                                                                                 Q r)

      Linearly interpolate between `q0` and `q1` by the amount `alpha`, such that:
      - `interpolateLinear(q0, q1, 0.0, r) -> r = q0`
      - `interpolateLinear(q0, q1, 1.0, r) -> r = q1`
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `c` - Preallocated storage
        `q0` - The left input quaternion
        `q1` - The right input quaternion
        `alpha` - The interpolation value, between `0.0` and `1.0`
        `r` - The output quaternion
      Returns:
        `(1 - alpha) * q0 + alpha * q1`
      Since:
        7.0.0

    - #### isNegationOf

          public static boolean isNegationOf(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                             QuaternionReadable4FType qa,
                                             QuaternionReadable4FType qb)

      Return `true` iff `qa` is the negation of `qb`.

      Each element is compared with `(ContextRelative, float, float)`.

      Parameters:
        `context` - The equality context
        `qa` - The left quaternion
        `qb` - The right quaternion
      Returns:
        `true` iff `qa` is the negation of `qb`
      Since:
        5.0.0

    - #### lookAt

          public static <Q extends QuaternionWritable4FType> Q lookAt(QuaternionM4F.ContextQM4F context,
                                                                      VectorReadable3FType origin,
                                                                      VectorReadable3FType target,
                                                                      VectorReadable3FType up,
                                                                      Q q)

      Produce a quaternion that represents a rotation that "looks at" the point at `target` assuming the viewer is at `origin`, using `up` as the "up" vector, saving the result to `q`.

      The function uses storage preallocated in `context` to avoid any new allocations.

      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `context` - Preallocated storage
        `q` - The output quaternion
        `origin` - The origin point
        `target` - The target point
        `up` - The up vector
      Returns:
        `q`
      Since:
        5.0.0

    - #### magnitude

          public static double magnitude(QuaternionReadable4FType q)

      Calculate the magnitude of the quaternion `q`. Correspondingly, `magnitude(normalize(q)) == 1.0`.
      Parameters:
        `q` - The input quaternion
      Returns:
        The magnitude of the input quaternion

    - #### magnitudeSquared

          public static double magnitudeSquared(QuaternionReadable4FType q)

      Calculate the squared magnitude of the quaternion `q`.
      Parameters:
        `q` - The input quaternion
      Returns:
        The squared magnitude of the input quaternion

    - #### makeFromAxisAngle

          public static <Q extends QuaternionWritable4FType> Q makeFromAxisAngle(VectorReadable3FType axis,
                                                                                 double angle,
                                                                                 Q out)

      Produce a quaternion that represents a rotation of `angle` degrees around the axis specified by `axis`, saving the result to `out`. `axis` is assumed to be of unit length.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `axis` - The normalized vector representing the axis
        `angle` - The angle to rotate, in radians
        `out` - The output quaternion
      Returns:
        A quaternion representing the rotation
      See Also:
        `VectorI3F.normalize(VectorReadable3FType)`, `VectorI4F.normalize(VectorReadable4FType)`, `VectorM3F.normalize(VectorReadable3FType, VectorWritable3FType)`, `VectorM4F.normalize(VectorReadable4FType, VectorWritable4FType)`

    - #### makeFromRotationMatrix3x3

          public static <Q extends QuaternionWritable4FType> Q makeFromRotationMatrix3x3(MatrixReadable3x3FType m,
                                                                                         Q out)

      Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `m` - The rotation matrix
        `out` - The output quaternion
      Returns:
        `out`
      Since:
        5.0.0

    - #### makeFromRotationMatrix4x4

          public static <Q extends QuaternionWritable4FType> Q makeFromRotationMatrix4x4(MatrixReadable4x4FType m,
                                                                                         Q out)

      Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `m` - The rotation matrix
        `out` - The output quaternion
      Returns:
        `out`
      Since:
        5.0.0

    - #### makeRotationMatrix3x3

          public static <M extends MatrixWritable3x3FType> M makeRotationMatrix3x3(QuaternionReadable4FType q,
                                                                                   M m)

      Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
      Type Parameters:
        `M` - The precise type of matrix
      Parameters:
        `q` - The input quaternion
        `m` - The output matrix
      Returns:
        `m`
      Since:
        7.0.0

    - #### makeRotationMatrix4x4

          public static <M extends MatrixWritable4x4FType> M makeRotationMatrix4x4(QuaternionReadable4FType q,
                                                                                   M m)

      Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
      Type Parameters:
        `M` - The precise type of matrix.
      Parameters:
        `q` - The input quaternion
        `m` - The output matrix
      Returns:
        `m`
      Since:
        5.0.0

    - #### multiply

          public static <Q extends QuaternionWritable4FType> Q multiply(QuaternionReadable4FType q0,
                                                                        QuaternionReadable4FType q1,
                                                                        Q qr)

      Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `qr`.

      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 `qr` that represents a rotation around the X axis, followed by a rotation around the Y axis, followed by a rotation around the Z axis:

      `QuaternionM4F qr = new QuaternionM4F(); QuaternionM4F.multiply(qy, qx, qr); QuaternionM4F.multiply(qz, qr, qr);`
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q0` - The left input quaternion
        `q1` - The right input quaternion
        `qr` - The output quaternion
      Returns:
        `qr`

    - #### multiplyInPlace

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q multiplyInPlace(Q q0,
                                                                                                          QuaternionReadable4FType q1)

      Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `q0`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q0` - The left quaternion
        `q1` - The right quaternion
      Returns:
        q0
      See Also:
        `multiply(QuaternionReadable4FType, QuaternionReadable4FType, QuaternionWritable4FType)`

    - #### negate

          public static <Q extends QuaternionWritable4FType> Q negate(QuaternionReadable4FType qa,
                                                                      Q out)

      Negate the elements of `qa`, writing the resulting quaternion to `out`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `qa` - The input quaternion
        `out` - The output quaternion
      Returns:
        out
      Since:
        5.0.0

    - #### negateInPlace

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q negateInPlace(Q q)

      Negate the elements of `q`, modifying the quaternion in-place.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q` - The input quaternion
      Returns:
        q
      Since:
        5.0.0

    - #### normalize

          public static <Q extends QuaternionWritable4FType> Q normalize(QuaternionReadable4FType q,
                                                                         Q out)

      Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `out`. The function returns the zero quaternion iff the input is the zero quaternion.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `out` - The output quaternion
        `q` - The input quaternion
      Returns:
        out

    - #### normalizeInPlace

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q normalizeInPlace(Q q)

      Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `q`. The function returns the zero quaternion iff the input is the zero quaternion.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q` - The input quaternion
      Returns:
        q

    - #### scale

          public static <Q extends QuaternionWritable4FType> Q scale(QuaternionReadable4FType q,
                                                                     double r,
                                                                     Q out)

      Scale the quaternion `q` by the scalar `r`, saving the result to `out`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q` - The input quaternion
        `r` - The scaling value
        `out` - The output quaternion
      Returns:
        `(q.x * r, q.y * r, q.z * r, q.w * r)`

    - #### scaleInPlace

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q scaleInPlace(Q q,
                                                                                                       double r)

      Scale the quaternion `q` by the scalar `r`, saving the result to `q`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q` - The input quaternion
        `r` - The scaling value
      Returns:
        `(q.x * r, q.y * r, q.z * r, q.w * r)`

    - #### subtract

          public static <Q extends QuaternionWritable4FType> Q subtract(QuaternionReadable4FType q0,
                                                                        QuaternionReadable4FType q1,
                                                                        Q out)

      Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `out`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q0` - The left input quaternion
        `q1` - The right input quaternion
        `out` - The output quaternion
      Returns:
        `(q0.x - q1.x, q0.y - q1.y, q0.z - q1.z, q0.w - q1.w)`

    - #### subtractInPlace

          public static <Q extends QuaternionWritable4FType & QuaternionReadable4FType> Q subtractInPlace(Q q0,
                                                                                                          QuaternionReadable4FType q1)

      Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `q0`.
      Type Parameters:
        `Q` - The precise type of quaternion
      Parameters:
        `q0` - The left input quaternion
        `q1` - The right input quaternion
      Returns:
        `(q0.x - q1.x, q0.y - q1.y, q0.z - q1.z, q0.w - q1.w)`

    - #### copyFrom2F

          public void copyFrom2F(VectorReadable2FType in_v)

      Description copied from interface: `VectorWritable2FType`
      Set the current vector to the contents of the input vector.
      Specified by:
        `copyFrom2F` in interface `VectorWritable2FType`
      Parameters:
        `in_v` - The input vector

    - #### copyFrom3F

          public void copyFrom3F(VectorReadable3FType in_v)

      Description copied from interface: `VectorWritable3FType`
      Set the current vector to the contents of the input vector.
      Specified by:
        `copyFrom3F` in interface `VectorWritable3FType`
      Parameters:
        `in_v` - The input vector

    - #### copyFrom4F

          public void copyFrom4F(VectorReadable4FType in_v)

      Description copied from interface: `VectorWritable4FType`
      Set the current vector to the contents of the input vector.
      Specified by:
        `copyFrom4F` in interface `VectorWritable4FType`
      Parameters:
        `in_v` - The input vector

    - #### equals

          public boolean equals(@Nullable
                                Object obj)

      Overrides:
        `equals` in class `Object`

    - #### getWF

          public float getWF()

      Specified by:
        `getWF` in interface `VectorReadable4FType`
      Returns:
        The W value of the given vector.

    - #### setWF

          public void setWF(float in_w)

      Description copied from interface: `VectorWritable4FType`
      Set the current `w` value of the current vector.
      Specified by:
        `setWF` in interface `VectorWritable4FType`
      Parameters:
        `in_w` - The new `w` value.

    - #### getXF

          public float getXF()

      Specified by:
        `getXF` in interface `VectorReadable2FType`
      Returns:
        The X value of the given vector.

    - #### setXF

          public void setXF(float in_x)

      Description copied from interface: `VectorWritable2FType`
      Set the current `x` value of the current vector.
      Specified by:
        `setXF` in interface `VectorWritable2FType`
      Parameters:
        `in_x` - The new `x` value.

    - #### getYF

          public float getYF()

      Specified by:
        `getYF` in interface `VectorReadable2FType`
      Returns:
        The Y value of the given vector.

    - #### setYF

          public void setYF(float in_y)

      Description copied from interface: `VectorWritable2FType`
      Set the current `y` value of the current vector.
      Specified by:
        `setYF` in interface `VectorWritable2FType`
      Parameters:
        `in_y` - The new `y` value.

    - #### getZF

          public float getZF()

      Specified by:
        `getZF` in interface `VectorReadable3FType`
      Returns:
        The Z value of the given vector.

    - #### setZF

          public void setZF(float in_z)

      Description copied from interface: `VectorWritable3FType`
      Set the current `z` value of the current vector.
      Specified by:
        `setZF` in interface `VectorWritable3FType`
      Parameters:
        `in_z` - The new `z` value.

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### set2F

          public void set2F(float in_x,
                            float in_y)

      Description copied from interface: `VectorWritable2FType`
      Set the current `x` and `y` values of the current vector.
      Specified by:
        `set2F` in interface `VectorWritable2FType`
      Parameters:
        `in_x` - The new `x` value.
        `in_y` - The new `y` value.

    - #### set3F

          public void set3F(float in_x,
                            float in_y,
                            float in_z)

      Description copied from interface: `VectorWritable3FType`
      Set the current `x`, `y` and `z` values of the current vector.
      Specified by:
        `set3F` in interface `VectorWritable3FType`
      Parameters:
        `in_x` - The new `x` value.
        `in_y` - The new `y` value.
        `in_z` - The new `z` value.

    - #### set4F

          public void set4F(float in_x,
                            float in_y,
                            float in_z,
                            float in_w)

      Description copied from interface: `VectorWritable4FType`
      Set the current `x`, `y`, `z` and `w` values of the current vector.
      Specified by:
        `set4F` in interface `VectorWritable4FType`
      Parameters:
        `in_x` - The new `x` value.
        `in_y` - The new `y` value.
        `in_z` - The new `z` value.
        `in_w` - The new `w` value.

    - #### toAxisAngle

          public static <V extends VectorWritable3FType> double toAxisAngle(QuaternionReadable4FType q,
                                                                            V out)

      Determine the axis-angle representation of the given quaternion.
      Type Parameters:
        `V` - The precise type of output vector
      Parameters:
        `q` - The input quaternion
        `out` - The output vector that will contain the axis
      Returns:
        The angle

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

Copyright © 2016 <code@io7m.com> http://io7m.com