com.io7m.jtensors.core.unparameterized.vectors

## Class Vectors3L

- java.lang.Object
- - com.io7m.jtensors.core.unparameterized.vectors.Vectors3L

-     public final class Vectors3L
      extends Object

  Functions over `Vector3L` 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 and Description
    --- | ---
    `static Vector3L` | `absolute(Vector3L v0)` Calculate the absolute of `v0`.
    `static Vector3L` | `add(Vector3L v0, Vector3L v1)` Add `v0` to `v1`.
    `static Vector3L` | `addScaled(Vector3L v0, Vector3L v1, double r)` Add `v0` to `v1 * r`.
    `static Vector3L` | `clamp(Vector3L v, Vector3L v_min, Vector3L v_max)` Clamp the values in `v` by `v_min` and `v_max`.
    `static Vector3L` | `crossProduct(Vector3L v0, Vector3L v1)` Calculate the cross product of the vectors `v0` and `v1`.
    `static long` | `dotProduct(Vector3L v0, Vector3L v1)` Calculate the scalar product of the vectors `v0` and `v1`.
    `static Vector3L` | `interpolateLinear(Vector3L v0, Vector3L v1, double alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
    `static double` | `magnitude(Vector3L v0)` Calculate the magnitude of the vector `v0`.
    `static long` | `magnitudeSquared(Vector3L v0)` Calculate the squared magnitude of the vector `v0`.
    `static Vector3L` | `negate(Vector3L v)` Calculate the negation of `v`.
    `static Vector3L` | `scale(Vector3L v0, double r)` Scale `v0` by `r`.
    `static Vector3L` | `subtract(Vector3L v0, Vector3L v1)` Subtract `v1` from `v0`.
    `static Vector3L` | `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 Vector3L absolute(Vector3L v0)

      Calculate the absolute of `v0`.
      Returns:
        `(abs v0.x, abs v0.y, abs v0.z)` * @param v0 The vector

    - #### add

          public static Vector3L add(Vector3L v0,
                                     Vector3L v1)

      Add `v0` to `v1`.
      Parameters:
        `v1` - The right vector
      Returns:
        `(v0.x + v1.x, v0.y + v0.y, v0.z + v1.z)` * @param v0 The left vector

    - #### addScaled

          public static Vector3L addScaled(Vector3L v0,
                                           Vector3L v1,
                                           double r)

      Add `v0` to `v1 * r`.
      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))` * @param v0 The left vector

    - #### clamp

          public static Vector3L clamp(Vector3L v,
                                       Vector3L v_min,
                                       Vector3L v_max)

      Clamp the values in `v` by `v_min` and `v_max`.
      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()))` * @param v The source vector

    - #### crossProduct

          public static Vector3L crossProduct(Vector3L v0,
                                              Vector3L v1)

      Calculate the cross product of the vectors `v0` and `v1`. * @param v0 The left vector
      Parameters:
        `v1` - The right vector
      Returns:
        The cross product of the two vectors

    - #### dotProduct

          public static long dotProduct(Vector3L v0,
                                        Vector3L v1)

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

    - #### interpolateLinear

          public static Vector3L interpolateLinear(Vector3L v0,
                                                   Vector3L 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`
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `alpha` - The interpolation value in the range `[0, 1]` * @return `((1 - alpha) * v0) + (alpha * v1)`

    - #### magnitudeSquared

          public static long magnitudeSquared(Vector3L v0)

      Calculate the squared magnitude of the vector `v0`. * @param v0 The vector
      Returns:
        The squared magnitude of the vector

    - #### magnitude

          public static double magnitude(Vector3L v0)

      Calculate the magnitude of the vector `v0`. * @param v0 The vector
      Returns:
        The magnitude of the vector

    - #### negate

          public static Vector3L negate(Vector3L v)

      Calculate the negation of `v`.
      Returns:
        `(-v.x, -v.y, -v.z)` * @param v The vector

    - #### scale

          public static Vector3L scale(Vector3L v0,
                                       double r)

      Scale `v0` by `r`.
      Parameters:
        `r` - The scaling value
      Returns:
        `(v0.x * r, v0.y * r, v0.z * r)` * @param v0 The left vector

    - #### subtract

          public static Vector3L subtract(Vector3L v0,
                                          Vector3L v1)

      Subtract `v1` from `v0`.
      Parameters:
        `v1` - The right vector
      Returns:
        `(v0.x - v1.x, v0.y - v0.y, v0.z - v1.z)` * @param v0 The left vector

    - #### zero

          public static Vector3L zero()

      The zero vector.
      Returns:
        `(0, 0, 0)`

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