com.io7m.jtensors

## Class QuaternionM4F

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

- All Implemented Interfaces:
    QuaternionReadable4FType, QuaternionWritable4FType, VectorReadable2FType, VectorReadable3FType, VectorReadable4FType, VectorWritable2FType, VectorWritable3FType, VectorWritable4FType

      public class QuaternionM4F
      extends Object
      implements QuaternionReadable4FType, QuaternionWritable4FType

  A four-dimensional mutable quaternion type with single precision 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.Context` The Context 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 QuaternionM4F` | `add(QuaternionReadable4FType q0, QuaternionReadable4FType q1, QuaternionM4F out)` Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `qr`.
    `static QuaternionM4F` | `addInPlace(QuaternionM4F 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 QuaternionM4F` | `conjugate(QuaternionReadable4FType q, QuaternionM4F out)` Calculate the conjugate of the input quaternion `q`, saving the result to `out`.
    `static QuaternionM4F` | `conjugateInPlace(QuaternionM4F q)` Calculate the conjugate of the input quaternion `q`, modifying `q` in place.
    `static QuaternionM4F` | `copy(QuaternionReadable4FType q, QuaternionM4F 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 QuaternionM4F` | `interpolateLinear(QuaternionReadable4FType q0, QuaternionReadable4FType q1, double alpha, QuaternionM4F 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 QuaternionM4F` | `lookAtWithContext(QuaternionM4F.Context context, VectorReadable3FType origin, VectorReadable3FType target, VectorReadable3FType up, QuaternionM4F 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 QuaternionM4F` | `makeFromAxisAngle(VectorReadable3FType axis, double angle, QuaternionM4F out)` Produce a quaternion that represents a rotation of `angle` degrees around the axis specified by `axis`, saving the result to `out`.
    `static QuaternionM4F` | `makeFromRotationMatrix3x3(MatrixReadable3x3FType m, QuaternionM4F out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
    `static QuaternionM4F` | `makeFromRotationMatrix4x4(MatrixReadable4x4FType m, QuaternionM4F out)` Produce a quaternion equivalent to the rotation matrix `m`, writing the result to `out`.
    `static MatrixM3x3F` | `makeRotationMatrix3x3(QuaternionM4F q, MatrixM3x3F m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
    `static MatrixM4x4F` | `makeRotationMatrix4x4(QuaternionReadable4FType q, MatrixM4x4F m)` Produce a rotation matrix from the quaternion `q`, saving the result to `m`.
    `static QuaternionM4F` | `multiply(QuaternionReadable4FType q0, QuaternionReadable4FType q1, QuaternionM4F qr)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `qr`.
    `static QuaternionM4F` | `multiplyInPlace(QuaternionM4F q0, QuaternionReadable4FType q1)` Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `q0`.
    `static QuaternionM4F` | `negate(QuaternionReadable4FType qa, QuaternionM4F out)` Negate the elements of `qa`, writing the resulting quaternion to `out`.
    `static QuaternionM4F` | `negateInPlace(QuaternionM4F q)` Negate the elements of `q`, modifying the quaternion in-place.
    `static QuaternionM4F` | `normalize(QuaternionReadable4FType q, QuaternionM4F out)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `out`.
    `static QuaternionM4F` | `normalizeInPlace(QuaternionM4F q)` Returns a quaternion with the same orientation as `q` but with magnitude equal to `1.0` in `q`.
    `static QuaternionM4F` | `scale(QuaternionReadable4FType q, double r, QuaternionM4F out)` Scale the quaternion `q` by the scalar `r`, saving the result to `out`.
    `static QuaternionM4F` | `scaleInPlace(QuaternionM4F 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 QuaternionM4F` | `subtract(QuaternionReadable4FType q0, QuaternionReadable4FType q1, QuaternionM4F out)` Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `out`.
    `static QuaternionM4F` | `subtractInPlace(QuaternionM4F q0, QuaternionReadable4FType 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

    - #### 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 final QuaternionM4F add(QuaternionReadable4FType q0,
                                                QuaternionReadable4FType q1,
                                                QuaternionM4F out)

      Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `qr`.
      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 final QuaternionM4F addInPlace(QuaternionM4F q0,
                                                       QuaternionReadable4FType q1)

      Calculate the element-wise sum of the quaternions `q0` and `q1`, saving the result to `q0`.
      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 final 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 final QuaternionM4F conjugate(QuaternionReadable4FType q,
                                                      QuaternionM4F out)

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

    - #### conjugateInPlace

          public static final QuaternionM4F conjugateInPlace(QuaternionM4F q)

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

    - #### copy

          public static final QuaternionM4F copy(QuaternionReadable4FType q,
                                                 QuaternionM4F out)

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

    - #### dotProduct

          public static final 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 final QuaternionM4F interpolateLinear(QuaternionReadable4FType q0,
                                                              QuaternionReadable4FType q1,
                                                              double alpha,
                                                              QuaternionM4F 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`
      Parameters:
        `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 final 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 `AlmostEqualFloat.almostEqual(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

    - #### lookAtWithContext

          public static final QuaternionM4F lookAtWithContext(QuaternionM4F.Context context,
                                                              VectorReadable3FType origin,
                                                              VectorReadable3FType target,
                                                              VectorReadable3FType up,
                                                              QuaternionM4F 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.

      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 final 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 final 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 final QuaternionM4F makeFromAxisAngle(VectorReadable3FType axis,
                                                              double angle,
                                                              QuaternionM4F 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.
      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, VectorM3F)`, `VectorM4F.normalize(VectorReadable4FType, VectorM4F)`

    - #### makeFromRotationMatrix3x3

          public static final QuaternionM4F makeFromRotationMatrix3x3(MatrixReadable3x3FType m,
                                                                      QuaternionM4F out)

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

    - #### makeFromRotationMatrix4x4

          public static final QuaternionM4F makeFromRotationMatrix4x4(MatrixReadable4x4FType m,
                                                                      QuaternionM4F out)

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

    - #### makeRotationMatrix3x3

          public static final MatrixM3x3F makeRotationMatrix3x3(QuaternionM4F q,
                                                                MatrixM3x3F m)

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

    - #### makeRotationMatrix4x4

          public static final MatrixM4x4F makeRotationMatrix4x4(QuaternionReadable4FType q,
                                                                MatrixM4x4F m)

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

    - #### multiply

          public static final QuaternionM4F multiply(QuaternionReadable4FType q0,
                                                     QuaternionReadable4FType q1,
                                                     QuaternionM4F 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);`
      Parameters:
        `q0` - The left input quaternion
        `q1` - The right input quaternion
        `qr` - The output quaternion
      Returns:
        `qr`

    - #### multiplyInPlace

          public static final QuaternionM4F multiplyInPlace(QuaternionM4F q0,
                                                            QuaternionReadable4FType q1)

      Multiply the quaternion `q0` by the quaternion `q1` , saving the result to `q0`.
      Parameters:
        `q0` - The left quaternion
        `q1` - The right quaternion
      Returns:
        q0
      See Also:
        `multiply(QuaternionReadable4FType, QuaternionReadable4FType, QuaternionM4F)`

    - #### negate

          public static final QuaternionM4F negate(QuaternionReadable4FType qa,
                                                   QuaternionM4F out)

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

    - #### negateInPlace

          public static final QuaternionM4F negateInPlace(QuaternionM4F q)

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

    - #### normalize

          public static final QuaternionM4F normalize(QuaternionReadable4FType q,
                                                      QuaternionM4F 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.
      Parameters:
        `out` - The output quaternion
        `q` - The input quaternion
      Returns:
        out

    - #### normalizeInPlace

          public static final QuaternionM4F normalizeInPlace(QuaternionM4F 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.
      Parameters:
        `q` - The input quaternion
      Returns:
        q

    - #### scale

          public static final QuaternionM4F scale(QuaternionReadable4FType q,
                                                  double r,
                                                  QuaternionM4F out)

      Scale the quaternion `q` by the scalar `r`, saving the result to `out`.
      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 final QuaternionM4F scaleInPlace(QuaternionM4F q,
                                                         double r)

      Scale the quaternion `q` by the scalar `r`, saving the result to `q`.
      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 final QuaternionM4F subtract(QuaternionReadable4FType q0,
                                                     QuaternionReadable4FType q1,
                                                     QuaternionM4F out)

      Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `out`.
      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 final QuaternionM4F subtractInPlace(QuaternionM4F q0,
                                                            QuaternionReadable4FType q1)

      Subtract the quaternion `q0` from the quaternion `q1`, saving the result to `q0`.
      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 final 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 final 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 final 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 final boolean equals(@Nullable
                                      Object obj)

      Overrides:
        `equals` in class `Object`

    - #### getWF

          public final float getWF()

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

    - #### getXF

          public final float getXF()

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

    - #### getYF

          public final float getYF()

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

    - #### getZF

          public final float getZF()

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

    - #### hashCode

          public final int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### set2F

          public final 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 final 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 final 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.

    - #### setWF

          public final 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.

    - #### setXF

          public final 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.

    - #### setYF

          public final 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.

    - #### setZF

          public final 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.

    - #### toString

          public final String toString()

      Overrides:
        `toString` in class `Object`

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