com.io7m.jtensors

## Class QuaternionM4D

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

- All Implemented Interfaces:
    Quaternion4DType, QuaternionReadable4DType, QuaternionWritable4DType, Vector2DType, Vector3DType, Vector4DType, VectorReadable2DType, VectorReadable3DType, VectorReadable4DType, VectorWritable2DType, VectorWritable3DType, VectorWritable4DType

      public final class QuaternionM4D
      extends Object
      implements Quaternion4DType

  A four-dimensional mutable quaternion type with `double` 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` | `QuaternionM4D.ContextQM4D` The `ContextQM4D` type contains the minimum storage required for all of the functions of the `QuaternionM4D` class.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `QuaternionM4D()` Default constructor, initializing the quaternion with values `[0.0, 0.0, 0.0, 1.0]`
    `QuaternionM4D(double in_x, double in_y, double in_z, double in_w)` Construct a quaternion initialized with the given values.
    `QuaternionM4D(QuaternionReadable4DType 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 QuaternionWritable4DType> Q` | `add(QuaternionReadable4DType q0, QuaternionReadable4DType q1, Q out)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `qr`.
    `static <Q extends QuaternionWritable4DType & QuaternionReadable4DType> Q` | `addInPlace(Q q0, QuaternionReadable4DType q1)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `q0`.
    `static boolean` | `almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, QuaternionReadable4DType qa, QuaternionReadable4DType qb)` Determine whether or not the quaternions `qa` and `qb` are equal to within the degree of error given in `context`.
    `static <Q extends QuaternionWritable4DType> Q` | `conjugate(QuaternionReadable4DType q, Q out)` Calculate the conjugate of the input quaternion `q`, saving the result to `out`.
    `static <Q extends QuaternionWritable4DType & QuaternionReadable4DType> Q` | `conjugateInPlace(Q q)` Calculate the conjugate of the input quaternion `q`, modifying `q` in place.
    `static <Q extends QuaternionWritable4DType> Q` | `copy(QuaternionReadable4DType q, Q out)` Copy the contents of the quaternion `q` to `out`.
    `void` | `copyFrom2D(VectorReadable2DType in_v)` Set the current vector to the contents of the input vector.
    `void` | `copyFrom3D(VectorReadable3DType in_v)` Set the current vector to the contents of the input vector.
    `void` | `copyFrom4D(VectorReadable4DType in_v)` Set the current vector to the contents of the input vector.
    `static double` | `dotProduct(QuaternionReadable4DType q0, QuaternionReadable4DType q1)` Calculate the scalar product of the quaternions `q0` and `q1`.
    `boolean` | `equals(Object obj)`
    `double` | `getWD()`
    `double` | `getXD()`
    `double` | `getYD()`
    `double` | `getZD()`
    `int` | `hashCode()`
    `static <Q extends QuaternionWritable4DType> Q` | `interpolateLinear(QuaternionM4D.ContextQM4D c, QuaternionReadable4DType q0, QuaternionReadable4DType 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.AlmostEqualDouble.ContextRelative context, QuaternionReadable4DType qa, QuaternionReadable4DType qb)` Return `true` iff `qa` is the negation of `qb`.
    `static <Q extends QuaternionWritable4DType> Q` | `lookAt(QuaternionM4D.ContextQM4D context, VectorReadable3DType origin, VectorReadable3DType target, VectorReadable3DType 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(QuaternionReadable4DType q)` Calculate the magnitude of the quaternion `q`.
    `static double` | `magnitudeSquared(QuaternionReadable4DType q)` Calculate the squared magnitude of the quaternion `q`.
    `static <Q extends QuaternionWritable4DType> Q` | `makeFromAxisAngle(QuaternionM4D.ContextQM4D c, VectorReadable3DType 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 QuaternionWritable4DType> Q` | `makeFromRotationMatrix3x3(MatrixReadable3x3DType m, Q out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
    `static <Q extends QuaternionWritable4DType> Q` | `makeFromRotationMatrix4x4(MatrixReadable4x4DType m, Q out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
    `static <M extends MatrixWritable3x3DType> M` | `makeRotationMatrix3x3(QuaternionReadable4DType q, M m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
    `static <M extends MatrixWritable4x4DType> M` | `makeRotationMatrix4x4(QuaternionReadable4DType q, M m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
    `static <Q extends QuaternionWritable4DType> Q` | `multiply(QuaternionReadable4DType q0, QuaternionReadable4DType q1, Q qr)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `qr`.
    `static <Q extends QuaternionWritable4DType & QuaternionReadable4DType> Q` | `multiplyInPlace(Q q0, QuaternionReadable4DType q1)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `q0`.
    `static <Q extends QuaternionWritable4DType> Q` | `negate(QuaternionReadable4DType qa, Q out)` Negate the elements of `qa`, writing the resulting quaternion to `out`.
    `static <Q extends QuaternionWritable4DType & QuaternionReadable4DType> Q` | `negateInPlace(Q q)` Negate the elements of `q`, modifying the quaternion in-place.
    `static <Q extends QuaternionWritable4DType> Q` | `normalize(QuaternionReadable4DType q, Q out)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `out`.
    `static <Q extends QuaternionWritable4DType & QuaternionReadable4DType> 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 QuaternionWritable4DType> Q` | `scale(QuaternionReadable4DType q, double r, Q out)` Scale the quaternion `q` by the scalar `r`, saving the result to `out`.
    `static <Q extends QuaternionWritable4DType & QuaternionReadable4DType> Q` | `scaleInPlace(Q q, double r)` Scale the quaternion `q` by the scalar `r`, saving the result to `q`.
    `void` | `set2D(double in_x, double in_y)` Set the current `x` and `y` values of the current vector.
    `void` | `set3D(double in_x, double in_y, double in_z)` Set the current `x`, `y` and `z` values of the current vector.
    `void` | `set4D(double in_x, double in_y, double in_z, double in_w)` Set the current `x`, `y`, `z` and `w` values of the current vector.
    `void` | `setWD(double in_w)` Set the current `w` value of the current vector.
    `void` | `setXD(double in_x)` Set the current `x` value of the current vector.
    `void` | `setYD(double in_y)` Set the current `y` value of the current vector.
    `void` | `setZD(double in_z)` Set the current `z` value of the current vector.
    `static <Q extends QuaternionWritable4DType> Q` | `subtract(QuaternionReadable4DType q0, QuaternionReadable4DType q1, Q out)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `out`.
    `static <Q extends QuaternionWritable4DType & QuaternionReadable4DType> Q` | `subtractInPlace(Q q0, QuaternionReadable4DType q1)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `q0`.
    `String` | `toString()`

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

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

- - ### Constructor Detail

    - #### QuaternionM4D

          public QuaternionM4D()

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

    - #### QuaternionM4D

          public QuaternionM4D(double in_x,
                               double in_y,
                               double in_z,
                               double 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

    - #### QuaternionM4D

          public QuaternionM4D(QuaternionReadable4DType q)

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

  - ### Method Detail

    - #### add

          public static <Q extends QuaternionWritable4DType> Q add(QuaternionReadable4DType q0,
                                                                   QuaternionReadable4DType 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 QuaternionWritable4DType & QuaternionReadable4DType> Q addInPlace(Q q0,
                                                                                                     QuaternionReadable4DType 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.AlmostEqualDouble.ContextRelative context,
                                            QuaternionReadable4DType qa,
                                            QuaternionReadable4DType 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:
        `AlmostEqualDouble.almostEqual(ContextRelative, double, double)`

    - #### conjugate

          public static <Q extends QuaternionWritable4DType> Q conjugate(QuaternionReadable4DType 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 QuaternionWritable4DType & QuaternionReadable4DType> 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 QuaternionWritable4DType> Q copy(QuaternionReadable4DType 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(QuaternionReadable4DType q0,
                                          QuaternionReadable4DType 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 QuaternionWritable4DType> Q interpolateLinear(QuaternionM4D.ContextQM4D c,
                                                                                 QuaternionReadable4DType q0,
                                                                                 QuaternionReadable4DType 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`

    - #### isNegationOf

          public static boolean isNegationOf(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                             QuaternionReadable4DType qa,
                                             QuaternionReadable4DType qb)

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

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

      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 QuaternionWritable4DType> Q lookAt(QuaternionM4D.ContextQM4D context,
                                                                      VectorReadable3DType origin,
                                                                      VectorReadable3DType target,
                                                                      VectorReadable3DType 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(QuaternionReadable4DType 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(QuaternionReadable4DType 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 QuaternionWritable4DType> Q makeFromAxisAngle(QuaternionM4D.ContextQM4D c,
                                                                                 VectorReadable3DType 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:
        `c` - Preallocated storage
        `axis` - The normalized quaternion representing the axis
        `angle` - The angle to rotate, in radians
        `out` - The output quaternion
      Returns:
        A quaternion representing the rotation
      Since:
        7.0.0
      See Also:
        `VectorI3D.normalize(VectorReadable3DType)`, `VectorI4D.normalize(VectorReadable4DType)`, `VectorM3D.normalize(VectorReadable3DType, VectorWritable3DType)`, `VectorM4D.normalize(VectorReadable4DType, VectorWritable4DType)`

    - #### makeFromRotationMatrix3x3

          public static <Q extends QuaternionWritable4DType> Q makeFromRotationMatrix3x3(MatrixReadable3x3DType 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 QuaternionWritable4DType> Q makeFromRotationMatrix4x4(MatrixReadable4x4DType 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 MatrixWritable3x3DType> M makeRotationMatrix3x3(QuaternionReadable4DType 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

    - #### makeRotationMatrix4x4

          public static <M extends MatrixWritable4x4DType> M makeRotationMatrix4x4(QuaternionReadable4DType 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 QuaternionWritable4DType> Q multiply(QuaternionReadable4DType q0,
                                                                        QuaternionReadable4DType 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:

           QuaternionM4D qr = new QuaternionM4D();
           QuaternionM4D.multiply(qy, qx, qr);
           QuaternionM4D.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 QuaternionWritable4DType & QuaternionReadable4DType> Q multiplyInPlace(Q q0,
                                                                                                          QuaternionReadable4DType 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(QuaternionReadable4DType, QuaternionReadable4DType, QuaternionWritable4DType)`

    - #### negate

          public static <Q extends QuaternionWritable4DType> Q negate(QuaternionReadable4DType 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 QuaternionWritable4DType & QuaternionReadable4DType> 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 QuaternionWritable4DType> Q normalize(QuaternionReadable4DType 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 QuaternionWritable4DType & QuaternionReadable4DType> 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 QuaternionWritable4DType> Q scale(QuaternionReadable4DType 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 QuaternionWritable4DType & QuaternionReadable4DType> 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 QuaternionWritable4DType> Q subtract(QuaternionReadable4DType q0,
                                                                        QuaternionReadable4DType 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 QuaternionWritable4DType & QuaternionReadable4DType> Q subtractInPlace(Q q0,
                                                                                                          QuaternionReadable4DType 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)`

    - #### copyFrom2D

          public void copyFrom2D(VectorReadable2DType in_v)

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

    - #### copyFrom3D

          public void copyFrom3D(VectorReadable3DType in_v)

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

    - #### copyFrom4D

          public void copyFrom4D(VectorReadable4DType in_v)

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

    - #### equals

          public boolean equals(@Nullable
                                Object obj)

      Overrides:
        `equals` in class `Object`

    - #### getWD

          public double getWD()

      Specified by:
        `getWD` in interface `VectorReadable4DType`
      Returns:
        The W value of the given vector.

    - #### setWD

          public void setWD(double in_w)

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

    - #### getXD

          public double getXD()

      Specified by:
        `getXD` in interface `VectorReadable2DType`
      Returns:
        The X value of the given vector.

    - #### setXD

          public void setXD(double in_x)

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

    - #### getYD

          public double getYD()

      Specified by:
        `getYD` in interface `VectorReadable2DType`
      Returns:
        The Y value of the given vector.

    - #### setYD

          public void setYD(double in_y)

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

    - #### getZD

          public double getZD()

      Specified by:
        `getZD` in interface `VectorReadable3DType`
      Returns:
        The Z value of the given vector.

    - #### setZD

          public void setZD(double in_z)

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

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### set2D

          public void set2D(double in_x,
                            double in_y)

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

    - #### set3D

          public void set3D(double in_x,
                            double in_y,
                            double in_z)

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

    - #### set4D

          public void set4D(double in_x,
                            double in_y,
                            double in_z,
                            double in_w)

      Description copied from interface: `VectorWritable4DType`
      Set the current `x`, `y`, `z` and `w` values of the current vector.
      Specified by:
        `set4D` in interface `VectorWritable4DType`
      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.

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

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