Package com.io7m.jtensors.core.unparameterized.vectors

# Class Vectors3I

java.lang.Object
com.io7m.jtensors.core.unparameterized.vectors.Vectors3I

public final class Vectors3I extends Object

Functions over `Vector3I` 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

  Modifier and Type
  Method
  Description
  `static Vector3I`
  `absolute(Vector3I v0)`
  Calculate the absolute of `v0`.
  `static Vector3I`
  `add(Vector3I v0, Vector3I v1)`
  Add `v0` to `v1`.
  `static Vector3I`
  `addScaled(Vector3I v0, Vector3I v1, double r)`
  Add `v0` to `v1 * r`.
  `static Vector3I`
  `clamp(Vector3I v, Vector3I v_min, Vector3I v_max)`
  Clamp the values in `v` by `v_min` and `v_max`.
  `static Vector3I`
  `crossProduct(Vector3I v0, Vector3I v1)`
  Calculate the cross product of the vectors `v0` and `v1`.
  `static long`
  `distance(Vector3I v0, Vector3I v1)`
  Calculate the distance between `v0` and `v1`.
  `static long`
  `dotProduct(Vector3I v0, Vector3I v1)`
  Calculate the scalar product of the vectors `v0` and `v1`.
  `static Vector3I`
  `interpolateBilinear(Vector3I x0y0, Vector3I x1y0, Vector3I x0y1, Vector3I x1y1, double px, double py)`
  Bilinearly interpolate between `x0y0`, `x1y0`, `x0y1`, `x1y1`.
  `static Vector3I`
  `interpolateLinear(Vector3I v0, Vector3I v1, double alpha)`
  Linearly interpolate between `v0` and `v1` by the amount `alpha`.
  `static double`
  `magnitude(Vector3I v0)`
  Calculate the magnitude of the vector `v0`.
  `static long`
  `magnitudeSquared(Vector3I v0)`
  Calculate the squared magnitude of the vector `v0`.
  `static Vector3I`
  `multiply(Vector3I v0, Vector3I v1)`
  Multiply `v0` by `v1`.
  `static Vector3I`
  `negate(Vector3I v)`
  Calculate the negation of `v`.
  `static Vector3I`
  `scale(Vector3I v0, double r)`
  Scale `v0` by `r`.
  `static Vector3I`
  `subtract(Vector3I v0, Vector3I v1)`
  Subtract `v1` from `v0`.
  `static Vector3I`
  `zero()`
  The zero vector.

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

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

- ## Method Details

  - ### absolute

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

  - ### add

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

  - ### multiply

    public static Vector3I multiply(Vector3I v0, Vector3I v1)
    Multiply `v0` by `v1`.
    Parameters:
      `v1` - The right vector
    Returns:
      `(v0.x * v1.x, v0.y * v1.y, v0.z * v1.z)` * @param v0 The left vector
    Since:
      10.0.0

  - ### addScaled

    public static Vector3I addScaled(Vector3I v0, Vector3I 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 + (v1.y * r), v0.z + (v1.z * r))` * @param v0 The left vector

  - ### clamp

    public static Vector3I clamp(Vector3I v, Vector3I v_min, Vector3I 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 Vector3I crossProduct(Vector3I v0, Vector3I 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

  - ### distance

    public static long distance(Vector3I v0, Vector3I v1)
    Calculate the distance between `v0` and `v1`.
    Parameters:
      `v1` - The right vector
    Returns:
      The distance between `v0` and `v1`. * @param v0 The left vector

  - ### dotProduct

    public static long dotProduct(Vector3I v0, Vector3I 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 Vector3I interpolateLinear(Vector3I v0, Vector3I 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)`

  - ### interpolateBilinear

    public static Vector3I interpolateBilinear(Vector3I x0y0, Vector3I x1y0, Vector3I x0y1, Vector3I 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`
    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]` * @return The bilinearly interpolated value

  - ### magnitudeSquared

    public static long magnitudeSquared(Vector3I 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(Vector3I v0)
    Calculate the magnitude of the vector `v0`. * @param v0 The vector
    Returns:
      The magnitude of the vector

  - ### negate

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

  - ### scale

    public static Vector3I scale(Vector3I 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 Vector3I subtract(Vector3I v0, Vector3I v1)
    Subtract `v1` from `v0`.
    Parameters:
      `v1` - The right vector
    Returns:
      `(v0.x - v1.x, v0.y - v1.y, v0.z - v1.z)` * @param v0 The left vector

  - ### zero

    public static Vector3I zero()
    The zero vector.
    Returns:
      `(0, 0, 0)`