com.io7m.jtensors.parameterized

## Class PVectorM2D<T>

- java.lang.Object
- - com.io7m.jtensors.parameterized.PVectorM2D<T>

- Type Parameters:
    `T` - A phantom type parameter.
  All Implemented Interfaces:
    PVector2DType<T>, PVectorReadable2DType<T>, PVectorWritable2DType<T>, Vector2DType, VectorReadable2DType, VectorWritable2DType

      public final class PVectorM2D<T>
      extends Object
      implements PVector2DType<T>

  A two-dimensional mutable vector type with `double` elements.

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

  Since:
    7.0.0

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `PVectorM2D.ContextPVM2D` Preallocated storage to allow all vector functions to run without allocating.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `PVectorM2D()` Default constructor, initializing the vector with values `[0.0, 0.0]`.
    `PVectorM2D(double in_x, double in_y)` Construct a vector initialized with the given values.
    `PVectorM2D(PVectorReadable2DType<T> in_x)` Construct a vector initialized with the values given in the vector `in_x`.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static <T,V extends PVectorWritable2DType<T>> V` | `absolute(PVectorReadable2DType<T> v, V out)` Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
    `static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `absoluteInPlace(V v)` Calculate the absolute values of the elements in vector `v`, modifying the vector in-place.
    `static <T,V extends PVectorWritable2DType<T>> V` | `add(PVectorReadable2DType<T> v0, PVectorReadable2DType<T> v1, V out)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
    `static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `addInPlace(V v0, PVectorReadable2DType<T> v1)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
    `static <T,V extends PVectorWritable2DType<T>> V` | `addScaled(PVectorReadable2DType<T> v0, PVectorReadable2DType<T> v1, double r, V 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 <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `addScaledInPlace(V v0, PVectorReadable2DType<T> 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 <T> boolean` | `almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, PVectorReadable2DType<T> qa, PVectorReadable2DType<T> qb)` Determine whether or not the vectors `qa` and `qb` are equal to within the degree of error given in `context`.
    `static <T> double` | `angle(PVectorReadable2DType<T> v0, PVectorReadable2DType<T> v1)` Calculate the angle between vectors `v0` and `v1`, in radians.
    `static <T,V extends PVectorWritable2DType<T>> V` | `clamp(PVectorReadable2DType<T> v, double minimum, double maximum, V out)` Clamp the elements of the vector `v` to the range {@code [minimum ..
    `static <T,V extends PVectorWritable2DType<T>> V` | `clampByPVector(PVectorReadable2DType<T> v, PVectorReadable2DType<T> minimum, PVectorReadable2DType<T> maximum, V 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 <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `clampByPVectorInPlace(V v, PVectorReadable2DType<T> minimum, PVectorReadable2DType<T> 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 <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `clampInPlace(V v, double minimum, double maximum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
    `static <T,V extends PVectorWritable2DType<T>> V` | `clampMaximum(PVectorReadable2DType<T> v, double maximum, V out)` Clamp the elements of the vector `v` to the range {@code [-Infinity ..
    `static <T,V extends PVectorWritable2DType<T>> V` | `clampMaximumByPVector(PVectorReadable2DType<T> v, PVectorReadable2DType<T> maximum, V 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 <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `clampMaximumByPVectorInPlace(V v, PVectorReadable2DType<T> 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 <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `clampMaximumInPlace(V v, double maximum)` Clamp the elements of the vector `v` to the range {@code [-Infinity ..
    `static <T,V extends PVectorWritable2DType<T>> V` | `clampMinimum(PVectorReadable2DType<T> v, double minimum, V out)` Clamp the elements of the vector `v` to the range {@code [minimum ..
    `static <T,V extends PVectorWritable2DType<T>> V` | `clampMinimumByPVector(PVectorReadable2DType<T> v, PVectorReadable2DType<T> minimum, V 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 <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `clampMinimumByPVectorInPlace(V v, PVectorReadable2DType<T> 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 <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `clampMinimumInPlace(V v, double minimum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
    `static <T,U extends PVectorReadable2DType<T>,V extends PVectorWritable2DType<T>> V` | `copy(U input, V output)` Copy all elements of the vector `input` to the vector `output`.
    `void` | `copyFrom2D(VectorReadable2DType in_v)` Set the current vector to the contents of the input vector.
    `void` | `copyFromTyped2D(PVectorReadable2DType<T> in_v)` Set the current vector to the contents of the input vector.
    `static <T> double` | `distance(PVectorM2D.ContextPVM2D c, PVectorReadable2DType<T> v0, PVectorReadable2DType<T> v1)` Calculate the distance between the two vectors `v0` and `v1`.
    `static <T> double` | `dotProduct(PVectorReadable2DType<T> v0, PVectorReadable2DType<T> v1)` Calculate the scalar product of the vectors `v0` and `v1`.
    `boolean` | `equals(Object obj)`
    `double` | `getXD()`
    `double` | `getYD()`
    `int` | `hashCode()`
    `static <T,V extends PVectorWritable2DType<T>> V` | `interpolateLinear(PVectorM2D.ContextPVM2D c, PVectorReadable2DType<T> v0, PVectorReadable2DType<T> v1, double alpha, V r)` Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`.
    `static <T> double` | `magnitude(PVectorReadable2DType<T> v)` Calculate the magnitude of the vector `v`.
    `static <T> double` | `magnitudeSquared(PVectorReadable2DType<T> v)` Calculate the squared magnitude of the vector `v`.
    `static <T,V extends PVectorWritable2DType<T>> V` | `normalize(PVectorReadable2DType<T> v, V out)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `out`.
    `static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `normalizeInPlace(V v)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `v`.
    `static <T,V extends PVectorWritable2DType<T>> void` | `orthoNormalize(PVectorM2D.ContextPVM2D c, PVectorReadable2DType<T> v0, V v0_out, PVectorReadable2DType<T> v1, V v1_out)` Orthonormalize and return the vectors `v0` and `v1` .
    `static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> void` | `orthoNormalizeInPlace(PVectorM2D.ContextPVM2D c, V v0, V v1)` Orthonormalize and the vectors `v0` and `v1`.
    `static <T,V extends PVectorWritable2DType<T>> V` | `projection(PVectorReadable2DType<T> p, PVectorReadable2DType<T> q, V r)` Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
    `static <T,V extends PVectorWritable2DType<T>> V` | `scale(PVectorReadable2DType<T> v, double r, V out)` Scale the vector `v` by the scalar `r`, saving the result to `out`.
    `static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `scaleInPlace(V v, double r)` Scale the vector `v` by the scalar `r`, saving the result to `v`.
    `void` | `set2D(double in_x, double in_y)` Set the current `x` and `y` values of the current vector.
    `void` | `setXD(double in_x)` Set the current `x` value of the current vector.
    `void` | `setYD(double in_y)` Set the current `y` value of the current vector.
    `static <T,V extends PVectorWritable2DType<T>> V` | `subtract(PVectorReadable2DType<T> v0, PVectorReadable2DType<T> v1, V out)` Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
    `static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V` | `subtractInPlace(V v0, PVectorReadable2DType<T> 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

    - #### PVectorM2D

          public PVectorM2D()

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

    - #### PVectorM2D

          public PVectorM2D(double in_x,
                            double in_y)

      Construct a vector initialized with the given values.
      Parameters:
        `in_x` - The `x` value
        `in_y` - The `y` value

    - #### PVectorM2D

          public PVectorM2D(PVectorReadable2DType<T> in_x)

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

  - ### Method Detail

    - #### absolute

          public static <T,V extends PVectorWritable2DType<T>> V absolute(PVectorReadable2DType<T> v,
                                                                          V out)

      Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      Parameters:
        `v` - The input vector
        `out` - The output vector
      Returns:
        `(abs v.x, abs v.y)`

    - #### absoluteInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V absoluteInPlace(V v)

      Calculate the absolute values of the elements in vector `v`, modifying the vector in-place.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      Parameters:
        `v` - The input vector
      Returns:
        `(abs v.x, abs v.y)`

    - #### add

          public static <T,V extends PVectorWritable2DType<T>> V add(PVectorReadable2DType<T> v0,
                                                                     PVectorReadable2DType<T> v1,
                                                                     V out)

      Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `out` - The output vector
      Returns:
        `(v0.x + v1.x, v0.y + v1.y)`

    - #### addInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V addInPlace(V v0,
                                                                                                       PVectorReadable2DType<T> v1)

      Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        `(v0.x + v1.x, v0.y + v1.y)`

    - #### addScaled

          public static <T,V extends PVectorWritable2DType<T>> V addScaled(PVectorReadable2DType<T> v0,
                                                                           PVectorReadable2DType<T> v1,
                                                                           double r,
                                                                           V out)

      Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      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))`

    - #### addScaledInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V addScaledInPlace(V v0,
                                                                                                             PVectorReadable2DType<T> 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`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      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))`

    - #### almostEqual

          public static <T> boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                                PVectorReadable2DType<T> qa,
                                                PVectorReadable2DType<T> qb)

      Determine whether or not the vectors `qa` and `qb` are equal to within the degree of error given in `context`.
      Type Parameters:
        `T` - A phantom type parameter.
      Parameters:
        `context` - The equality context
        `qa` - The left input vector
        `qb` - The right input vector
      Returns:
        `true` if the vectors are almost equal
      Since:
        7.0.0
      See Also:
        `AlmostEqualDouble.almostEqual(ContextRelative, double, double)`

    - #### angle

          public static <T> double angle(PVectorReadable2DType<T> v0,
                                         PVectorReadable2DType<T> v1)

      Calculate the angle between vectors `v0` and `v1`, in radians.
      Type Parameters:
        `T` - A phantom type parameter.
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        The angle between the two vectors, in radians.

    - #### clamp

          public static <T,V extends PVectorWritable2DType<T>> V clamp(PVectorReadable2DType<T> v,
                                                                       double minimum,
                                                                       double maximum,
                                                                       V out)

      Clamp the elements of the vector `v` to the range `[minimum .. maximum]` inclusive, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      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`

    - #### clampByPVector

          public static <T,V extends PVectorWritable2DType<T>> V clampByPVector(PVectorReadable2DType<T> v,
                                                                                PVectorReadable2DType<T> minimum,
                                                                                PVectorReadable2DType<T> maximum,
                                                                                V 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`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      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))`

    - #### clampByPVectorInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V clampByPVectorInPlace(V v,
                                                                                                                  PVectorReadable2DType<T> minimum,
                                                                                                                  PVectorReadable2DType<T> 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`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      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))`

    - #### clampInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V clampInPlace(V v,
                                                                                                         double minimum,
                                                                                                         double maximum)

      Clamp the elements of the vector `v` to the range `[minimum .. maximum]` inclusive, saving the result to `v`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      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 <T,V extends PVectorWritable2DType<T>> V clampMaximum(PVectorReadable2DType<T> v,
                                                                              double maximum,
                                                                              V out)

      Clamp the elements of the vector `v` to the range `[-Infinity .. maximum]` inclusive, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      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`

    - #### clampMaximumByPVector

          public static <T,V extends PVectorWritable2DType<T>> V clampMaximumByPVector(PVectorReadable2DType<T> v,
                                                                                       PVectorReadable2DType<T> maximum,
                                                                                       V out)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      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))`

    - #### clampMaximumByPVectorInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V clampMaximumByPVectorInPlace(V v,
                                                                                                                         PVectorReadable2DType<T> maximum)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`, saving the result to `v`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      Parameters:
        `v` - The input vector
        `maximum` - The vector containing the maximum acceptable values
      Returns:
        `(min(v.x, maximum.x), min(v.y, maximum.y))`

    - #### clampMaximumInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V clampMaximumInPlace(V v,
                                                                                                                double maximum)

      Clamp the elements of the vector `v` to the range `[-Infinity .. maximum]` inclusive, saving the result to `v`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      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 <T,V extends PVectorWritable2DType<T>> V clampMinimum(PVectorReadable2DType<T> v,
                                                                              double minimum,
                                                                              V out)

      Clamp the elements of the vector `v` to the range `[minimum .. Infinity]` inclusive, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      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`

    - #### clampMinimumByPVector

          public static <T,V extends PVectorWritable2DType<T>> V clampMinimumByPVector(PVectorReadable2DType<T> v,
                                                                                       PVectorReadable2DType<T> minimum,
                                                                                       V out)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      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))`

    - #### clampMinimumByPVectorInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V clampMinimumByPVectorInPlace(V v,
                                                                                                                         PVectorReadable2DType<T> minimum)

      Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`, saving the result to `v`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      Parameters:
        `v` - The input vector
        `minimum` - The vector containing the minimum acceptable values
      Returns:
        `(max(v.x, minimum.x), max(v.y, minimum.y))` , in `v`

    - #### clampMinimumInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V clampMinimumInPlace(V v,
                                                                                                                double minimum)

      Clamp the elements of the vector `v` to the range `[minimum .. Infinity]` inclusive, saving the result to `v`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      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 <T,U extends PVectorReadable2DType<T>,V extends PVectorWritable2DType<T>> V copy(U input,
                                                                                                         V output)

      Copy all elements of the vector `input` to the vector `output`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable vector
        `U` - The precise type of writable vector
      Parameters:
        `input` - The input vector
        `output` - The output vector
      Returns:
        output

    - #### distance

          public static <T> double distance(PVectorM2D.ContextPVM2D c,
                                            PVectorReadable2DType<T> v0,
                                            PVectorReadable2DType<T> v1)

      Calculate the distance between the two vectors `v0` and `v1`.
      Type Parameters:
        `T` - A phantom type parameter.
      Parameters:
        `c` - Preallocated storage
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        The distance between the two vectors.

    - #### dotProduct

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

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

    - #### interpolateLinear

          public static <T,V extends PVectorWritable2DType<T>> V interpolateLinear(PVectorM2D.ContextPVM2D c,
                                                                                   PVectorReadable2DType<T> v0,
                                                                                   PVectorReadable2DType<T> v1,
                                                                                   double alpha,
                                                                                   V 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`
      Type Parameters:
        `V` - The precise type of vector
        `T` - A phantom type parameter
      Parameters:
        `c` - Preallocated storage
        `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`
      Since:
        7.0.0

    - #### magnitude

          public static <T> double magnitude(PVectorReadable2DType<T> v)

      Calculate the magnitude of the vector `v`. Correspondingly, `magnitude(normalize(v)) == 1.0`.
      Type Parameters:
        `T` - A phantom type parameter.
      Parameters:
        `v` - The input vector
      Returns:
        The magnitude of the input vector

    - #### magnitudeSquared

          public static <T> double magnitudeSquared(PVectorReadable2DType<T> v)

      Calculate the squared magnitude of the vector `v`.
      Type Parameters:
        `T` - A phantom type parameter.
      Parameters:
        `v` - The input vector
      Returns:
        The squared magnitude of the input vector

    - #### normalize

          public static <T,V extends PVectorWritable2DType<T>> V normalize(PVectorReadable2DType<T> v,
                                                                           V 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.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      Parameters:
        `v` - The input vector
        `out` - The output vector
      Returns:
        out

    - #### normalizeInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V normalizeInPlace(V 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.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      Parameters:
        `v` - The input vector
      Returns:
        v

    - #### orthoNormalize

          public static <T,V extends PVectorWritable2DType<T>> void orthoNormalize(PVectorM2D.ContextPVM2D c,
                                                                                   PVectorReadable2DType<T> v0,
                                                                                   V v0_out,
                                                                                   PVectorReadable2DType<T> v1,
                                                                                   V v1_out)

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

      See GSP

      Type Parameters:
        `T` - A phantom type parameter
        `V` - The precise type of vector
      Parameters:
        `c` - Preallocated storage
        `v0` - The left vector
        `v0_out` - The orthonormalized form of `v0`
        `v1` - The right vector
        `v1_out` - The orthonormalized form of `v1`
      Since:
        7.0.0

    - #### orthoNormalizeInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> void orthoNormalizeInPlace(PVectorM2D.ContextPVM2D c,
                                                                                                                     V v0,
                                                                                                                     V v1)

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

      See GSP

      Type Parameters:
        `V` - The precise type of vector
        `T` - A phantom type parameter
      Parameters:
        `c` - Preallocated storage
        `v0` - The left vector
        `v1` - The right vector
      Since:
        7.0.0

    - #### projection

          public static <T,V extends PVectorWritable2DType<T>> V projection(PVectorReadable2DType<T> p,
                                                                            PVectorReadable2DType<T> q,
                                                                            V r)

      Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      Parameters:
        `p` - The left vector
        `q` - The right vector
        `r` - The output vector
      Returns:
        `((dotProduct p q) / magnitudeSquared q) * q`

    - #### scale

          public static <T,V extends PVectorWritable2DType<T>> V scale(PVectorReadable2DType<T> v,
                                                                       double r,
                                                                       V out)

      Scale the vector `v` by the scalar `r`, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      Parameters:
        `v` - The input vector
        `r` - The scaling value
        `out` - The output vector
      Returns:
        `(v.x * r, v.y * r)`

    - #### scaleInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V scaleInPlace(V v,
                                                                                                         double r)

      Scale the vector `v` by the scalar `r`, saving the result to `v`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      Parameters:
        `v` - The input vector
        `r` - The scaling value
      Returns:
        `(v.x * r, v.y * r)`

    - #### subtract

          public static <T,V extends PVectorWritable2DType<T>> V subtract(PVectorReadable2DType<T> v0,
                                                                          PVectorReadable2DType<T> v1,
                                                                          V out)

      Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of writable vector
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
        `out` - The output vector
      Returns:
        `(v0.x - v1.x, v0.y - v1.y)`

    - #### subtractInPlace

          public static <T,V extends PVectorWritable2DType<T> & PVectorReadable2DType<T>> V subtractInPlace(V v0,
                                                                                                            PVectorReadable2DType<T> v1)

      Subtract the vector `v1` from the vector `v0`, saving the result to `v0`.
      Type Parameters:
        `T` - A phantom type parameter.
        `V` - The precise type of readable/writable vector
      Parameters:
        `v0` - The left input vector
        `v1` - The right input vector
      Returns:
        `(v0.x - v1.x, v0.y - v1.y)`

    - #### copyFrom2D

          public void copyFrom2D(VectorReadable2DType in_v)

      Description copied from interface: `VectorWritable2DType`
      Set the current vector to the contents of the input vector.
      Specified by:
        `copyFrom2D` in interface `VectorWritable2DType`
      Parameters:
        `in_v` - The input vector

    - #### copyFromTyped2D

          public void copyFromTyped2D(PVectorReadable2DType<T> in_v)

      Description copied from interface: `PVectorWritable2DType`
      Set the current vector to the contents of the input vector.
      Specified by:
        `copyFromTyped2D` in interface `PVectorWritable2DType<T>`
      Parameters:
        `in_v` - The input vector

    - #### equals

          public boolean equals(@Nullable
                                Object obj)

      Overrides:
        `equals` in class `Object`

    - #### getXD

          public double getXD()

      Specified by:
        `getXD` in interface `VectorReadable2DType`
      Returns:
        The X value of the given vector.

    - #### setXD

          public void setXD(double in_x)

      Description copied from interface: `VectorWritable2DType`
      Set the current `x` value of the current vector.
      Specified by:
        `setXD` in interface `VectorWritable2DType`
      Parameters:
        `in_x` - The new `x` value.

    - #### getYD

          public double getYD()

      Specified by:
        `getYD` in interface `VectorReadable2DType`
      Returns:
        The Y value of the given vector.

    - #### setYD

          public void setYD(double in_y)

      Description copied from interface: `VectorWritable2DType`
      Set the current `y` value of the current vector.
      Specified by:
        `setYD` in interface `VectorWritable2DType`
      Parameters:
        `in_y` - The new `y` value.

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### set2D

          public void set2D(double in_x,
                            double in_y)

      Description copied from interface: `VectorWritable2DType`
      Set the current `x` and `y` values of the current vector.
      Specified by:
        `set2D` in interface `VectorWritable2DType`
      Parameters:
        `in_x` - The new `x` value.
        `in_y` - The new `y` value.

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`

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