# Class PVectors2D

java.lang.Object
com.io7m.jtensors.core.parameterized.vectors.PVectors2D

public final class PVectors2D extends Object

Functions over `PVector2D` 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 <T> PVector2D<T>`
  `absolute(PVector2D<T> v0)`
  Calculate the absolute of `v0`.
  `static <T> PVector2D<T>`
  `add(PVector2D<T> v0, PVector2D<T> v1)`
  Add `v0` to `v1`.
  `static <T> PVector2D<T>`
  `addScaled(PVector2D<T> v0, PVector2D<T> v1, double r)`
  Add `v0` to `v1 * r`.
  `static <T> double`
  `angle(PVector2D<T> v0, PVector2D<T> v1)`
  Calculate the angle between the vectors `v0` and `v1` in radians.
  `static <T> PVector2D<T>`
  `clamp(PVector2D<T> v, PVector2D<T> v_min, PVector2D<T> v_max)`
  Clamp the values in `v` by `v_min` and `v_max`.
  `static <T> double`
  `distance(PVector2D<T> v0, PVector2D<T> v1)`
  Calculate the distance between `v0` and `v1`.
  `static <T> double`
  `dotProduct(PVector2D<T> v0, PVector2D<T> v1)`
  Calculate the scalar product of the vectors `v0` and `v1`.
  `static <T> PVector2D<T>`
  `interpolateBilinear(PVector2D<T> x0y0, PVector2D<T> x1y0, PVector2D<T> x0y1, PVector2D<T> x1y1, double px, double py)`
  Bilinearly interpolate between `x0y0`, `x1y0`, `x0y1`, `x1y1`.
  `static <T> PVector2D<T>`
  `interpolateLinear(PVector2D<T> v0, PVector2D<T> v1, double alpha)`
  Linearly interpolate between `v0` and `v1` by the amount `alpha`.
  `static <T> double`
  `magnitude(PVector2D<T> v0)`
  Calculate the magnitude of the vector `v0`.
  `static <T> double`
  `magnitudeSquared(PVector2D<T> v0)`
  Calculate the squared magnitude of the vector `v0`.
  `static <T> PVector2D<T>`
  `multiply(PVector2D<T> v0, PVector2D<T> v1)`
  Multiply `v0` by `v1`.
  `static <T> PVector2D<T>`
  `negate(PVector2D<T> v)`
  Calculate the negation of `v`.
  `static <T> PVector2D<T>`
  `normalize(PVector2D<T> v0)`
  Normalize the vector `v0`.
  `static <T> PVector2D<T>`
  `scale(PVector2D<T> v0, double r)`
  Scale `v0` by `r`.
  `static <T> PVector2D<T>`
  `subtract(PVector2D<T> v0, PVector2D<T> v1)`
  Subtract `v1` from `v0`.
  `static <A> PVector2D<A>`
  `toParameterized(Vector2D v)`
  `static <A> Vector2D`
  `toUnparameterized(PVector2D<A> v)`
  `static <T> PVector2D<T>`
  `zero()`
  The zero vector.

  ### Methods inherited from class Object

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

- ## Method Details

  - ### absolute

    public static <T> PVector2D<T> absolute(PVector2D<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)`

  - ### add

    public static <T> PVector2D<T> add(PVector2D<T> v0, PVector2D<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 + v1.y)`

  - ### multiply

    public static <T> PVector2D<T> multiply(PVector2D<T> v0, PVector2D<T> v1)
    Multiply `v0` by `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 * v1.y)`
    Since:
      10.0.0

  - ### addScaled

    public static <T> PVector2D<T> addScaled(PVector2D<T> v0, PVector2D<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 + (v1.y * r))`

  - ### angle

    public static <T> double angle(PVector2D<T> v0, PVector2D<T> v1)
    Calculate the angle between the vectors `v0` and `v1` in radians.
    Type Parameters:
      `T` - A phantom type parameter * @return The angle between the two vectors, in radians.
    Parameters:
      `v0` - The left input vector
      `v1` - The right input vector

  - ### clamp

    public static <T> PVector2D<T> clamp(PVector2D<T> v, PVector2D<T> v_min, PVector2D<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()))`

  - ### distance

    public static <T> double distance(PVector2D<T> v0, PVector2D<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(PVector2D<T> v0, PVector2D<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> PVector2D<T> interpolateLinear(PVector2D<T> v0, PVector2D<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> PVector2D<T> interpolateBilinear(PVector2D<T> x0y0, PVector2D<T> x1y0, PVector2D<T> x0y1, PVector2D<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(PVector2D<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(PVector2D<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> PVector2D<T> negate(PVector2D<T> v)
    Calculate the negation of `v`.
    Type Parameters:
      `T` - A phantom type parameter * @param v The vector
    Returns:
      `(-v.x, -v.y)`

  - ### normalize

    public static <T> PVector2D<T> normalize(PVector2D<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> PVector2D<T> scale(PVector2D<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)`

  - ### subtract

    public static <T> PVector2D<T> subtract(PVector2D<T> v0, PVector2D<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 - v1.y)`

  - ### zero

    public static <T> PVector2D<T> zero()
    The zero vector.
    Type Parameters:
      `T` - A phantom type parameter
    Returns:
      `(0, 0)`

  - ### toUnparameterized

    public static <A> Vector2D toUnparameterized(PVector2D<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> PVector2D<A> toParameterized(Vector2D 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