Module com.io7m.jtensors.core
Package com.io7m.jtensors.core.parameterized.vectors

## Class PVectors4F

- java.lang.Object
- - com.io7m.jtensors.core.parameterized.vectors.PVectors4F

-     public final class PVectors4F
      extends Object

  Functions over `PVector4F` values.

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

  Since:
    8.0.0

- - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method | Description
    --- | --- | ---
    `static <T> PVector4F<T>` | `absolute​(PVector4F<T> v0)` | Calculate the absolute of `v0`.
    `static <T> PVector4F<T>` | `add​(PVector4F<T> v0, PVector4F<T> v1)` | Add `v0` to `v1`.
    `static <T> PVector4F<T>` | `addScaled​(PVector4F<T> v0, PVector4F<T> v1, double r)` | Add `v0` to `v1 * r`.
    `static <T> PVector4F<T>` | `clamp​(PVector4F<T> v, PVector4F<T> v_min, PVector4F<T> v_max)` | Clamp the values in `v` by `v_min` and `v_max`.
    `static <T> double` | `distance​(PVector4F<T> v0, PVector4F<T> v1)` | Calculate the distance between `v0` and `v1`.
    `static <T> double` | `dotProduct​(PVector4F<T> v0, PVector4F<T> v1)` | Calculate the scalar product of the vectors `v0` and `v1`.
    `static <T> PVector4F<T>` | `interpolateBilinear​(PVector4F<T> x0y0, PVector4F<T> x1y0, PVector4F<T> x0y1, PVector4F<T> x1y1, double px, double py)` | Bilinearly interpolate between `x0y0`, `x1y0`, `x0y1`, `x1y1`.
    `static <T> PVector4F<T>` | `interpolateLinear​(PVector4F<T> v0, PVector4F<T> v1, double alpha)` | Linearly interpolate between `v0` and `v1` by the amount `alpha`.
    `static <T> double` | `magnitude​(PVector4F<T> v0)` | Calculate the magnitude of the vector `v0`.
    `static <T> double` | `magnitudeSquared​(PVector4F<T> v0)` | Calculate the squared magnitude of the vector `v0`.
    `static <T> PVector4F<T>` | `negate​(PVector4F<T> v)` | Calculate the negation of `v`.
    `static <T> PVector4F<T>` | `normalize​(PVector4F<T> v0)` | Normalize the vector `v0`.
    `static <T> PVector4F<T>` | `scale​(PVector4F<T> v0, double r)` | Scale `v0` by `r`.
    `static <T> PVector4F<T>` | `subtract​(PVector4F<T> v0, PVector4F<T> v1)` | Subtract `v1` from `v0`.
    `static <A> PVector4F<A>` | `toParameterized​(Vector4F v)` |
    `static <A> Vector4F` | `toUnparameterized​(PVector4F<A> v)` |
    `static <T> PVector4F<T>` | `zero​()` | The zero vector.

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

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Method Detail

    - #### absolute

          public static <T> PVector4F<T> absolute​(PVector4F<T> v0)

      Calculate the absolute of `v0`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The vector
      Returns:
        `(abs v0.x, abs v0.y, abs v0.z, abs v0.w)`

    - #### add

          public static <T> PVector4F<T> add​(PVector4F<T> v0,
                                             PVector4F<T> v1)

      Add `v0` to `v1`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The left vector
      Parameters:
        `v1` - The right vector
      Returns:
        `(v0.x + v1.x, v0.y + v0.y, v0.z + v1.z, v0.w + v1.w)`

    - #### addScaled

          public static <T> PVector4F<T> addScaled​(PVector4F<T> v0,
                                                   PVector4F<T> v1,
                                                   double r)

      Add `v0` to `v1 * r`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The left vector
      Parameters:
        `v1` - The right vector
        `r` - The scaling value
      Returns:
        `(v0.x + (v1.x * r), v0.y + (v0.y * r), v0.z + (v1.z * r), v0.w + (v1.w * r))`

    - #### clamp

          public static <T> PVector4F<T> clamp​(PVector4F<T> v,
                                               PVector4F<T> v_min,
                                               PVector4F<T> v_max)

      Clamp the values in `v` by `v_min` and `v_max`.
      Type Parameters:
        `T` - A phantom type parameter * @param v The source vector
      Parameters:
        `v_min` - The minimum vector
        `v_max` - The maximum vector
      Returns:
        `(max(min(v.x, v_max.x()), v_min.x()), max(min(v.y, v_max.y()), v_min.y()), max(min(v.z, v_max.z()), v_min.z()), max(min(v.w, v_max.w()), v_min.w()))`

    - #### distance

          public static <T> double distance​(PVector4F<T> v0,
                                            PVector4F<T> v1)

      Calculate the distance between `v0` and `v1`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The left vector
      Parameters:
        `v1` - The right vector
      Returns:
        The distance between `v0` and `v1`.

    - #### dotProduct

          public static <T> double dotProduct​(PVector4F<T> v0,
                                              PVector4F<T> v1)

      Calculate the scalar product of the vectors `v0` and `v1`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The left vector
      Parameters:
        `v1` - The right vector
      Returns:
        The scalar product of the two vectors

    - #### interpolateLinear

          public static <T> PVector4F<T> interpolateLinear​(PVector4F<T> v0,
                                                           PVector4F<T> v1,
                                                           double alpha)

      Linearly interpolate between `v0` and `v1` by the amount `alpha`.

      The `alpha` parameter controls the degree of interpolation, such that:

      - `interpolateLinear(v0, v1, 0.0) = v0`
      - `interpolateLinear(v0, v1, 1.0) = v1`
      Type Parameters:
        `T` - A phantom type parameter * @return `((1 - alpha) * v0) + (alpha * v1)`
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `alpha` - The interpolation value in the range `[0, 1]`

    - #### interpolateBilinear

          public static <T> PVector4F<T> interpolateBilinear​(PVector4F<T> x0y0,
                                                             PVector4F<T> x1y0,
                                                             PVector4F<T> x0y1,
                                                             PVector4F<T> x1y1,
                                                             double px,
                                                             double py)

      Bilinearly interpolate between `x0y0`, `x1y0`, `x0y1`, `x1y1`.

      The `px` and `py` parameters control the degree of interpolation, such that:

      - `interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 0.0, 0.0) = x0y0`
      - `interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 1.0, 0.0) = x1y0`
      - `interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 0.0, 1.0) = x0y1`
      - `interpolateBilinear(x0y0, x1y0, x0y1, x1y1, 1.0, 1.0) = x1y1`
      Type Parameters:
        `T` - A phantom type parameter * @return The bilinearly interpolated value
      Parameters:
        `x0y0` - The top left input vector
        `x1y0` - The top right input vector
        `x0y1` - The bottom left input vector
        `x1y1` - The bottom right input vector
        `px` - The X interpolation value in the range `[0, 1]`
        `py` - The Y interpolation value in the range `[0, 1]`

    - #### magnitudeSquared

          public static <T> double magnitudeSquared​(PVector4F<T> v0)

      Calculate the squared magnitude of the vector `v0`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The vector
      Returns:
        The squared magnitude of the vector

    - #### magnitude

          public static <T> double magnitude​(PVector4F<T> v0)

      Calculate the magnitude of the vector `v0`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The vector
      Returns:
        The magnitude of the vector

    - #### negate

          public static <T> PVector4F<T> negate​(PVector4F<T> v)

      Calculate the negation of `v`.
      Type Parameters:
        `T` - A phantom type parameter * @param v The vector
      Returns:
        `(-v.x, -v.y, -v.z, -v.w)`

    - #### normalize

          public static <T> PVector4F<T> normalize​(PVector4F<T> v0)

      Normalize the vector `v0`.

      If the magnitude of the vector is zero, the function returns `v0`.

      Type Parameters:
        `T` - A phantom type parameter * @param v0 The vector
      Returns:
        A normalized copy of `v0`

    - #### scale

          public static <T> PVector4F<T> scale​(PVector4F<T> v0,
                                               double r)

      Scale `v0` by `r`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The left vector
      Parameters:
        `r` - The scaling value
      Returns:
        `(v0.x * r, v0.y * r, v0.z * r, v0.w * r)`

    - #### subtract

          public static <T> PVector4F<T> subtract​(PVector4F<T> v0,
                                                  PVector4F<T> v1)

      Subtract `v1` from `v0`.
      Type Parameters:
        `T` - A phantom type parameter * @param v0 The left vector
      Parameters:
        `v1` - The right vector
      Returns:
        `(v0.x - v1.x, v0.y - v0.y, v0.z - v1.z, v0.w - v1.w)`

    - #### zero

          public static <T> PVector4F<T> zero​()

      The zero vector.
      Type Parameters:
        `T` - A phantom type parameter
      Returns:
        `(0, 0, 0, 0)`

    - #### toUnparameterized

          public static <A> Vector4F toUnparameterized​(PVector4F<A> v)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a coordinate system)
      Parameters:
        `v` - The input vector
      Returns:
        A vector equal to `m` but without type parameters

    - #### toParameterized

          public static <A> PVector4F<A> toParameterized​(Vector4F v)

      Type Parameters:
        `A` - A phantom type parameter (possibly representing a coordinate system)
      Parameters:
        `v` - The input vector
      Returns:
        A vector equal to `v` with type parameters

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