com.io7m.jtensors

## Class VectorM4F

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

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

      public class VectorM4F
      extends Object
      implements VectorReadable4FType, VectorWritable4FType

  A four-dimensional mutable vector type with single precision elements.

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

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `VectorM4F()` Default constructor, initializing the vector with values `[0.0, 0.0, 0.0, 1.0]`.
    `VectorM4F(float in_x, float in_y, float in_z, float in_w)` Construct a vector initialized with the given values.
    `VectorM4F(VectorReadable4FType in_v)` Construct a vector initialized with the values given in the vector `in_v`.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static VectorM4F` | `absolute(VectorReadable4FType v, VectorM4F out)` Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
    `static VectorM4F` | `absoluteInPlace(VectorM4F v)` Calculate the absolute values of the elements in vector `v`, modifying the vector in-place.
    `static VectorM4F` | `add(VectorReadable4FType v0, VectorReadable4FType v1, VectorM4F out)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
    `static VectorM4F` | `addInPlace(VectorM4F v0, VectorReadable4FType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
    `static VectorM4F` | `addScaled(VectorReadable4FType v0, VectorReadable4FType v1, double r, VectorM4F out)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`, saving the result to `out`.
    `static VectorM4F` | `addScaledInPlace(VectorM4F v0, VectorReadable4FType v1, double r)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`, saving the result to `v0`.
    `static boolean` | `almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, VectorReadable4FType va, VectorReadable4FType vb)` Determine whether or not the vectors `va` and `vb` are equal to within the degree of error given in `context`.
    `static VectorM4F` | `clamp(VectorReadable4FType v, double minimum, double maximum, VectorM4F out)` Clamp the elements of the vector `v` to the range `[minimum ..`
    `static VectorM4F` | `clampByVector(VectorReadable4FType v, VectorReadable4FType minimum, VectorReadable4FType maximum, VectorM4F out)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`, saving the result to `out`.
    `static VectorM4F` | `clampByVectorInPlace(VectorM4F v, VectorReadable4FType minimum, VectorReadable4FType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`, saving the result to `v`.
    `static VectorM4F` | `clampInPlace(VectorM4F v, float minimum, float maximum)` Clamp the elements of the vector `v` to the range `[minimum ..`
    `static VectorM4F` | `clampMaximum(VectorReadable4FType v, float maximum, VectorM4F out)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
    `static VectorM4F` | `clampMaximumByVector(VectorReadable4FType v, VectorReadable4FType maximum, VectorM4F out)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `out`.
    `static VectorM4F` | `clampMaximumByVectorInPlace(VectorM4F v, VectorReadable4FType maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `v`.
    `static VectorM4F` | `clampMaximumInPlace(VectorM4F v, float maximum)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
    `static VectorM4F` | `clampMinimum(VectorReadable4FType v, float minimum, VectorM4F out)` Clamp the elements of the vector `v` to the range `[minimum ..`
    `static VectorM4F` | `clampMinimumByVector(VectorReadable4FType v, VectorReadable4FType minimum, VectorM4F out)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `out`.
    `static VectorM4F` | `clampMinimumByVectorInPlace(VectorM4F v, VectorReadable4FType minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `v`.
    `static VectorM4F` | `clampMinimumInPlace(VectorM4F v, float minimum)` Clamp the elements of the vector `v` to the range `[minimum ..`
    `static <T extends VectorWritable4FType> T` | `copy(VectorReadable4FType input, T output)` Copy all elements of the vector `input` to the vector `output`.
    `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` | `distance(VectorReadable4FType v0, VectorReadable4FType v1)` Calculate the distance between the two vectors `v0` and `v1`.
    `static double` | `dotProduct(VectorReadable4FType v0, VectorReadable4FType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
    `boolean` | `equals(Object obj)`
    `float` | `getWF()`
    `float` | `getXF()`
    `float` | `getYF()`
    `float` | `getZF()`
    `int` | `hashCode()`
    `static VectorM4F` | `interpolateLinear(VectorReadable4FType v0, VectorReadable4FType v1, double alpha, VectorM4F r)` Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`.
    `static double` | `magnitude(VectorReadable4FType v)` Calculate the magnitude of the vector `v`.
    `static double` | `magnitudeSquared(VectorReadable4FType v)` Calculate the squared magnitude of the vector `v`.
    `static VectorM4F` | `normalize(VectorReadable4FType v, VectorM4F out)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `out`.
    `static VectorM4F` | `normalizeInPlace(VectorM4F v)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `v`.
    `static com.io7m.jfunctional.Pair<VectorM4F,VectorM4F>` | `orthoNormalize(VectorReadable4FType v0, VectorReadable4FType v1)` Orthonormalize and return the vectors `v0` and `v1` .
    `static void` | `orthoNormalizeInPlace(VectorM4F v0, VectorM4F v1)` Orthonormalize and the vectors `v0` and `v1`.
    `static VectorM4F` | `projection(VectorReadable4FType p, VectorReadable4FType q, VectorM4F r)` Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
    `static VectorM4F` | `scale(VectorReadable4FType v, double r, VectorM4F out)` Scale the vector `v` by the scalar `r`, saving the result to `out`.
    `static VectorM4F` | `scaleInPlace(VectorM4F v, double r)` Scale the vector `v` by the scalar `r`, saving the result to `v`.
    `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 VectorM4F` | `subtract(VectorReadable4FType v0, VectorReadable4FType v1, VectorM4F out)` Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
    `static VectorM4F` | `subtractInPlace(VectorM4F v0, VectorReadable4FType v1)` Subtract the vector `v1` from the vector `v0`, saving the result to `v0`.
    `String` | `toString()`

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

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

- - ### Constructor Detail

    - #### VectorM4F

          public VectorM4F()

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

    - #### VectorM4F

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

      Construct a vector 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

    - #### VectorM4F

          public VectorM4F(VectorReadable4FType in_v)

      Construct a vector initialized with the values given in the vector `in_v`.
      Parameters:
        `in_v` - The source vector

  - ### Method Detail

    - #### absolute

          public static final VectorM4F absolute(VectorReadable4FType v,
                                                 VectorM4F out)

      Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `out` - The output vector
      Returns:
        `(abs v.x, abs v.y, abs v.z, abs.w)`

    - #### absoluteInPlace

          public static final VectorM4F absoluteInPlace(VectorM4F v)

      Calculate the absolute values of the elements in vector `v`, modifying the vector in-place.
      Parameters:
        `v` - The input vector
      Returns:
        `(abs v.x, abs v.y, abs v.z, abs v.w)`

    - #### add

          public static final VectorM4F add(VectorReadable4FType v0,
                                            VectorReadable4FType v1,
                                            VectorM4F out)

      Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `out` - The output vector
      Returns:
        `(v0.x + v1.x, v0.y + v1.y, v0.z + v1.z, v0.w + v1.w)`

    - #### addInPlace

          public static final VectorM4F addInPlace(VectorM4F v0,
                                                   VectorReadable4FType v1)

      Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        `(v0.x + v1.x, v0.y + v1.y, v0.z + v1.z, v0.w + v1.w)`

    - #### addScaled

          public static final VectorM4F addScaled(VectorReadable4FType v0,
                                                  VectorReadable4FType v1,
                                                  double r,
                                                  VectorM4F out)

      Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`, saving the result to `out`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `out` - The output vector
        `r` - The scaling value
      Returns:
        `(v0.x + (v1.x * r), v0.y + (v1.y * r), v0.z + (v1.z * r), v0.w + (v1.w * r))`

    - #### addScaledInPlace

          public static final VectorM4F addScaledInPlace(VectorM4F v0,
                                                         VectorReadable4FType v1,
                                                         double r)

      Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`, saving the result to `v0`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `r` - The scaling value
      Returns:
        `(v0.x + (v1.x * r), v0.y + (v1.y * r), v0.z + (v1.z * r), v0.w + (v1.w * r))`

    - #### almostEqual

          public static final boolean almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                                  VectorReadable4FType va,
                                                  VectorReadable4FType vb)

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

    - #### clamp

          public static final VectorM4F clamp(VectorReadable4FType v,
                                              double minimum,
                                              double maximum,
                                              VectorM4F out)

      Clamp the elements of the vector `v` to the range `[minimum .. maximum]` inclusive, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `minimum` - The minimum allowed value
        `maximum` - The maximum allowed value
        `out` - The output vector
      Returns:
        A vector with both elements equal to at most `maximum` and at least `minimum`

    - #### clampByVector

          public static final VectorM4F clampByVector(VectorReadable4FType v,
                                                      VectorReadable4FType minimum,
                                                      VectorReadable4FType maximum,
                                                      VectorM4F out)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `minimum` - The vector containing the minimum acceptable values
        `maximum` - The vector containing the maximum acceptable values
        `out` - The output vector
      Returns:
        `(min(max(v.x, minimum.x), maximum.x), min(max(v.y, minimum.y), maximum.y), min(max(v.z, minimum.z), maximum.z), min(max(v.w, minimum.w), maximum.w))`

    - #### clampByVectorInPlace

          public static final VectorM4F clampByVectorInPlace(VectorM4F v,
                                                             VectorReadable4FType minimum,
                                                             VectorReadable4FType maximum)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`, saving the result to `v`.
      Parameters:
        `v` - The input vector
        `minimum` - The vector containing the minimum acceptable values
        `maximum` - The vector containing the maximum acceptable values
      Returns:
        `(min(max(v.x, minimum.x), maximum.x), min(max(v.y, minimum.y), maximum.y), min(max(v.z, minimum.z), maximum.z), min(max(v.w, minimum.w), maximum.w))`

    - #### clampInPlace

          public static final VectorM4F clampInPlace(VectorM4F v,
                                                     float minimum,
                                                     float maximum)

      Clamp the elements of the vector `v` to the range `[minimum .. maximum]` inclusive, saving the result to `v`.
      Parameters:
        `v` - The input vector
        `minimum` - The minimum allowed value
        `maximum` - The maximum allowed value
      Returns:
        A vector with both elements equal to at most `maximum` and at least `minimum`, in `v`

    - #### clampMaximum

          public static final VectorM4F clampMaximum(VectorReadable4FType v,
                                                     float maximum,
                                                     VectorM4F out)

      Clamp the elements of the vector `v` to the range `[-Infinity .. maximum]` inclusive, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `out` - The output vector
        `maximum` - The maximum allowed value
      Returns:
        A vector with both elements equal to at most `maximum`

    - #### clampMaximumByVector

          public static final VectorM4F clampMaximumByVector(VectorReadable4FType v,
                                                             VectorReadable4FType maximum,
                                                             VectorM4F out)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `maximum` - The vector containing the maximum acceptable values
        `out` - The output vector
      Returns:
        `(min(v.x, maximum.x), min(v.y, maximum.y), min(v.z, maximum.z), min(v.w, maximum.w))`

    - #### clampMaximumByVectorInPlace

          public static final VectorM4F clampMaximumByVectorInPlace(VectorM4F v,
                                                                    VectorReadable4FType maximum)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `v`.
      Parameters:
        `v` - The input vector
        `maximum` - The vector containing the maximum acceptable values
      Returns:
        `(min(v.x, maximum.x), min(v.y, maximum.y), min(v.z, maximum.z), min(v.w, maximum.w))`

    - #### clampMaximumInPlace

          public static final VectorM4F clampMaximumInPlace(VectorM4F v,
                                                            float maximum)

      Clamp the elements of the vector `v` to the range `[-Infinity .. maximum]` inclusive, saving the result to `v`.
      Parameters:
        `v` - The input vector
        `maximum` - The maximum allowed value
      Returns:
        A vector with both elements equal to at most `maximum` , in `v`

    - #### clampMinimum

          public static final VectorM4F clampMinimum(VectorReadable4FType v,
                                                     float minimum,
                                                     VectorM4F out)

      Clamp the elements of the vector `v` to the range `[minimum .. Infinity]` inclusive, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `out` - The output vector
        `minimum` - The minimum allowed value
      Returns:
        A vector with both elements equal to at least `minimum`

    - #### clampMinimumByVector

          public static final VectorM4F clampMinimumByVector(VectorReadable4FType v,
                                                             VectorReadable4FType minimum,
                                                             VectorM4F out)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `out` - The output vector
        `minimum` - The vector containing the minimum acceptable values
      Returns:
        `(max(v.x, minimum.x), max(v.y, minimum.y), max(v.z, minimum.z), max(v.w, minimum.w))`

    - #### clampMinimumByVectorInPlace

          public static final VectorM4F clampMinimumByVectorInPlace(VectorM4F v,
                                                                    VectorReadable4FType minimum)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `v`.
      Parameters:
        `v` - The input vector
        `minimum` - The vector containing the minimum acceptable values
      Returns:
        `(max(v.x, minimum.x), max(v.y, minimum.y), max(v.z, minimum.z), max(v.w, minimum.w))` , in `v`

    - #### clampMinimumInPlace

          public static final VectorM4F clampMinimumInPlace(VectorM4F v,
                                                            float minimum)

      Clamp the elements of the vector `v` to the range `[minimum .. Infinity]` inclusive, saving the result to `v`.
      Parameters:
        `v` - The input vector
        `minimum` - The minimum allowed value
      Returns:
        A vector with both elements equal to at least `minimum`, in `v`.

    - #### copy

          public static final <T extends VectorWritable4FType> T copy(VectorReadable4FType input,
                                                                      T output)

      Copy all elements of the vector `input` to the vector `output`.
      Type Parameters:
        `T` - The specific type of vector
      Parameters:
        `input` - The input vector
        `output` - The output vector
      Returns:
        output

    - #### distance

          public static final double distance(VectorReadable4FType v0,
                                              VectorReadable4FType v1)

      Calculate the distance between the two vectors `v0` and `v1`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        The distance between the two vectors.

    - #### dotProduct

          public static final double dotProduct(VectorReadable4FType v0,
                                                VectorReadable4FType v1)

      Calculate the scalar product of the vectors `v0` and `v1`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        The scalar product of the two vectors

    - #### interpolateLinear

          public static final VectorM4F interpolateLinear(VectorReadable4FType v0,
                                                          VectorReadable4FType v1,
                                                          double alpha,
                                                          VectorM4F r)

      Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`. The `alpha` parameter controls the degree of interpolation, such that:
      - `interpolateLinear(v0, v1, 0.0, r) -> r = v0`
      - `interpolateLinear(v0, v1, 1.0, r) -> r = v1`
      Parameters:
        `v0` - The left input vector.
        `v1` - The right input vector.
        `alpha` - The interpolation value, between `0.0` and `1.0`.
        `r` - The result vector.
      Returns:
        `r`

    - #### magnitude

          public static final double magnitude(VectorReadable4FType v)

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

    - #### magnitudeSquared

          public static final double magnitudeSquared(VectorReadable4FType v)

      Calculate the squared magnitude of the vector `v`.
      Parameters:
        `v` - The input vector
      Returns:
        The squared magnitude of the input vector

    - #### normalize

          public static final VectorM4F normalize(VectorReadable4FType v,
                                                  VectorM4F out)

      Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `out`. The function returns the zero vector iff the input is the zero vector.
      Parameters:
        `v` - The input vector
        `out` - The output vector
      Returns:
        out

    - #### normalizeInPlace

          public static final VectorM4F normalizeInPlace(VectorM4F v)

      Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `v`. The function returns the zero vector iff the input is the zero vector.
      Parameters:
        `v` - The input vector
      Returns:
        v

    - #### orthoNormalize

          public static final com.io7m.jfunctional.Pair<VectorM4F,VectorM4F> orthoNormalize(VectorReadable4FType v0,
                                                                                            VectorReadable4FType v1)

      Orthonormalize and return the vectors `v0` and `v1` .

      See GSP

      Parameters:
        `v0` - The left vector
        `v1` - The right vector
      Returns:
        A pair `(v0, v1)`, orthonormalized.
      Since:
        5.0.0

    - #### orthoNormalizeInPlace

          public static final void orthoNormalizeInPlace(VectorM4F v0,
                                                         VectorM4F v1)

      Orthonormalize and the vectors `v0` and `v1`.

      See GSP

      Parameters:
        `v0` - The left vector
        `v1` - The right vector
      Since:
        5.0.0

    - #### projection

          public static final VectorM4F projection(VectorReadable4FType p,
                                                   VectorReadable4FType q,
                                                   VectorM4F r)

      Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
      Parameters:
        `p` - The left vector
        `q` - The right vector
        `r` - The output vector
      Returns:
        `((dotProduct p q) / magnitudeSquared q) * q`

    - #### scale

          public static final VectorM4F scale(VectorReadable4FType v,
                                              double r,
                                              VectorM4F out)

      Scale the vector `v` by the scalar `r`, saving the result to `out`.
      Parameters:
        `v` - The input vector
        `r` - The scaling value
        `out` - The output vector
      Returns:
        `(v.x * r, v.y * r, v.z * r, v.w * r)`

    - #### scaleInPlace

          public static final VectorM4F scaleInPlace(VectorM4F v,
                                                     double r)

      Scale the vector `v` by the scalar `r`, saving the result to `v`.
      Parameters:
        `v` - The input vector
        `r` - The scaling value
      Returns:
        `(v.x * r, v.y * r, v.z * r, v.w * r)`

    - #### subtract

          public static final VectorM4F subtract(VectorReadable4FType v0,
                                                 VectorReadable4FType v1,
                                                 VectorM4F out)

      Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `out` - The output vector
      Returns:
        `(v0.x - v1.x, v0.y - v1.y, v0.z - v1.z, v0.w - v1.w)`

    - #### subtractInPlace

          public static final VectorM4F subtractInPlace(VectorM4F v0,
                                                        VectorReadable4FType v1)

      Subtract the vector `v1` from the vector `v0`, saving the result to `v0`.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        `(v0.x - v1.x, v0.y - v1.y, v0.z - v1.z, v0.w - v1.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