VectorM2D (io7m-jtensors-documentation 6.0.2 API)

java.lang.Object
- com.io7m.jtensors.VectorM2D

All Implemented Interfaces:

VectorReadable2DType, VectorWritable2DType
```
public class VectorM2D
extends Object
implements VectorReadable2DType, VectorWritable2DType
```
A two-dimensional mutable vector type with double precision elements.

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

Constructor Summary

Constructors
Constructor and Description
`VectorM2D()` Default constructor, initializing the vector with values `[0.0, 0.0]`.
`VectorM2D(double in_x, double in_y)` Construct a vector initialized with the given values.
`VectorM2D(VectorReadable2DType 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 VectorM2D`	`absolute(VectorReadable2DType v, VectorM2D out)` Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
`static VectorM2D`	`absoluteInPlace(VectorM2D v)` Calculate the absolute values of the elements in vector `v`, modifying the vector in-place.
`static VectorM2D`	`add(VectorReadable2DType v0, VectorReadable2DType v1, VectorM2D out)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
`static VectorM2D`	`addInPlace(VectorM2D v0, VectorReadable2DType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
`static VectorM2D`	`addScaled(VectorReadable2DType v0, VectorReadable2DType v1, double r, VectorM2D 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 VectorM2D`	`addScaledInPlace(VectorM2D v0, VectorReadable2DType 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 boolean`	`almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, VectorReadable2DType qa, VectorReadable2DType qb)` Determine whether or not the vectors `qa` and `qb` are equal to within the degree of error given in `context`.
`static double`	`angle(VectorReadable2DType v0, VectorReadable2DType v1)` Calculate the angle between vectors `v0` and `v1`, in radians.
`static VectorM2D`	`clamp(VectorReadable2DType v, double minimum, double maximum, VectorM2D out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2D`	`clampByVector(VectorReadable2DType v, VectorReadable2DType minimum, VectorReadable2DType maximum, VectorM2D 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 VectorM2D`	`clampByVectorInPlace(VectorM2D v, VectorReadable2DType minimum, VectorReadable2DType 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 VectorM2D`	`clampInPlace(VectorM2D v, double minimum, double maximum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2D`	`clampMaximum(VectorReadable2DType v, double maximum, VectorM2D out)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM2D`	`clampMaximumByVector(VectorReadable2DType v, VectorReadable2DType maximum, VectorM2D 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 VectorM2D`	`clampMaximumByVectorInPlace(VectorM2D v, VectorReadable2DType 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 VectorM2D`	`clampMaximumInPlace(VectorM2D v, double maximum)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM2D`	`clampMinimum(VectorReadable2DType v, double minimum, VectorM2D out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2D`	`clampMinimumByVector(VectorReadable2DType v, VectorReadable2DType minimum, VectorM2D 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 VectorM2D`	`clampMinimumByVectorInPlace(VectorM2D v, VectorReadable2DType 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 VectorM2D`	`clampMinimumInPlace(VectorM2D v, double minimum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorWritable2DType`	`copy(VectorReadable2DType input, VectorWritable2DType 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.
`static double`	`distance(VectorReadable2DType v0, VectorReadable2DType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static double`	`dotProduct(VectorReadable2DType v0, VectorReadable2DType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`double`	`getXD()`
`double`	`getYD()`
`int`	`hashCode()`
`static VectorM2D`	`interpolateLinear(VectorReadable2DType v0, VectorReadable2DType v1, double alpha, VectorM2D r)` Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`.
`static double`	`magnitude(VectorReadable2DType v)` Calculate the magnitude of the vector `v`.
`static double`	`magnitudeSquared(VectorReadable2DType v)` Calculate the squared magnitude of the vector `v`.
`static VectorM2D`	`normalize(VectorReadable2DType v, VectorM2D out)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `out`.
`static VectorM2D`	`normalizeInPlace(VectorM2D v)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `v`.
`static com.io7m.jfunctional.Pair<VectorM2D,VectorM2D>`	`orthoNormalize(VectorReadable2DType v0, VectorReadable2DType v1)` Orthonormalize and return the vectors `v0` and `v1` .
`static void`	`orthoNormalizeInPlace(VectorM2D v0, VectorM2D v1)` Orthonormalize and the vectors `v0` and `v1`.
`static VectorM2D`	`projection(VectorReadable2DType p, VectorReadable2DType q, VectorM2D r)` Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
`static VectorM2D`	`scale(VectorReadable2DType v, double r, VectorM2D out)` Scale the vector `v` by the scalar `r`, saving the result to `out`.
`static VectorM2D`	`scaleInPlace(VectorM2D 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 VectorM2D`	`subtract(VectorReadable2DType v0, VectorReadable2DType v1, VectorM2D out)` Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
`static VectorM2D`	`subtractInPlace(VectorM2D v0, VectorReadable2DType 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
  - VectorM2D
```
public VectorM2D()
```
    Default constructor, initializing the vector with values [0.0, 0.0].
  - VectorM2D
```
public VectorM2D(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
  - VectorM2D
```
public VectorM2D(VectorReadable2DType 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 final VectorM2D absolute(VectorReadable2DType v,
                                       VectorM2D out)
```
    Calculate the absolute values of the elements in vector v, saving the result to out.
    
    Parameters:
    
    v - The input vector
    
    out - The output vector
    
    Returns:
    
    (abs v.x, abs v.y)
  - absoluteInPlace
```
public static final VectorM2D absoluteInPlace(VectorM2D v)
```
    Calculate the absolute values of the elements in vector v, modifying the vector in-place.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    (abs v.x, abs v.y)
  - add
```
public static final VectorM2D add(VectorReadable2DType v0,
                                  VectorReadable2DType v1,
                                  VectorM2D out)
```
    Calculate the element-wise sum of the vectors v0 and v1, saving the result to out.
    
    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 final VectorM2D addInPlace(VectorM2D v0,
                                         VectorReadable2DType v1)
```
    Calculate the element-wise sum of the vectors v0 and v1, saving the result to v0.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    (v0.x + v1.x, v0.y + v1.y)
  - addScaled
```
public static final VectorM2D addScaled(VectorReadable2DType v0,
                                        VectorReadable2DType v1,
                                        double r,
                                        VectorM2D out)
```
    Calculate the element-wise sum of the vectors v0 and the element-wise product of v1 and r, saving the result to out.
    
    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 final VectorM2D addScaledInPlace(VectorM2D v0,
                                               VectorReadable2DType 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.
    
    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 final boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                        VectorReadable2DType qa,
                                        VectorReadable2DType qb)
```
    Determine whether or not the vectors qa and qb are equal to within the degree of error given in context.
    
    Parameters:
    
    context - The equality context
    
    qa - The left input vector
    
    qb - The right input vector
    
    Returns:
    
    true if the vectors are almost equal
    
    Since:
    
    5.0.0
    
    See Also:
    
    AlmostEqualDouble.almostEqual(ContextRelative, double, double)
  - angle
```
public static final double angle(VectorReadable2DType v0,
                                 VectorReadable2DType v1)
```
    Calculate the angle between vectors v0 and v1, in radians.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    The angle between the two vectors, in radians.
  - clamp
```
public static final VectorM2D clamp(VectorReadable2DType v,
                                    double minimum,
                                    double maximum,
                                    VectorM2D out)
```
    Clamp the elements of the vector v to the range [minimum .. maximum] inclusive, saving the result to out.
    
    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
  - clampByVector
```
public static final VectorM2D clampByVector(VectorReadable2DType v,
                                            VectorReadable2DType minimum,
                                            VectorReadable2DType maximum,
                                            VectorM2D 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.
    
    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))
  - clampByVectorInPlace
```
public static final VectorM2D clampByVectorInPlace(VectorM2D v,
                                                   VectorReadable2DType minimum,
                                                   VectorReadable2DType 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.
    
    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 final VectorM2D clampInPlace(VectorM2D v,
                                           double minimum,
                                           double maximum)
```
    Clamp the elements of the vector v to the range [minimum .. maximum] inclusive, saving the result to v.
    
    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 final VectorM2D clampMaximum(VectorReadable2DType v,
                                           double maximum,
                                           VectorM2D out)
```
    Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive, saving the result to out.
    
    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
  - clampMaximumByVector
```
public static final VectorM2D clampMaximumByVector(VectorReadable2DType v,
                                                   VectorReadable2DType maximum,
                                                   VectorM2D out)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum, saving the result to out.
    
    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))
  - clampMaximumByVectorInPlace
```
public static final VectorM2D clampMaximumByVectorInPlace(VectorM2D v,
                                                          VectorReadable2DType maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum, saving the result to v.
    
    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 final VectorM2D clampMaximumInPlace(VectorM2D v,
                                                  double maximum)
```
    Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive, saving the result to v.
    
    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 final VectorM2D clampMinimum(VectorReadable2DType v,
                                           double minimum,
                                           VectorM2D out)
```
    Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive, saving the result to out.
    
    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
  - clampMinimumByVector
```
public static final VectorM2D clampMinimumByVector(VectorReadable2DType v,
                                                   VectorReadable2DType minimum,
                                                   VectorM2D out)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum, saving the result to out.
    
    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))
  - clampMinimumByVectorInPlace
```
public static final VectorM2D clampMinimumByVectorInPlace(VectorM2D v,
                                                          VectorReadable2DType minimum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum, saving the result to v.
    
    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 final VectorM2D clampMinimumInPlace(VectorM2D v,
                                                  double minimum)
```
    Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive, saving the result to v.
    
    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 final VectorWritable2DType copy(VectorReadable2DType input,
                                              VectorWritable2DType output)
```
    Copy all elements of the vector input to the vector output.
    
    Parameters:
    
    input - The input vector
    
    output - The output vector
    
    Returns:
    
    output
  - distance
```
public static final double distance(VectorReadable2DType v0,
                                    VectorReadable2DType v1)
```
    Calculate the distance between the two vectors v0 and v1.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    The distance between the two vectors.
  - dotProduct
```
public static final double dotProduct(VectorReadable2DType v0,
                                      VectorReadable2DType v1)
```
    Calculate the scalar product of the vectors v0 and v1.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    The scalar product of the two vectors
  - interpolateLinear
```
public static final VectorM2D interpolateLinear(VectorReadable2DType v0,
                                                VectorReadable2DType v1,
                                                double alpha,
                                                VectorM2D 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
    Parameters:
    
    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
  - magnitude
```
public static final double magnitude(VectorReadable2DType v)
```
    Calculate the magnitude of the vector v. Correspondingly, magnitude(normalize(v)) == 1.0.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    The magnitude of the input vector
  - magnitudeSquared
```
public static final double magnitudeSquared(VectorReadable2DType v)
```
    Calculate the squared magnitude of the vector v.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    The squared magnitude of the input vector
  - normalize
```
public static final VectorM2D normalize(VectorReadable2DType v,
                                        VectorM2D 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.
    
    Parameters:
    
    v - The input vector
    
    out - The output vector
    
    Returns:
    
    out
  - normalizeInPlace
```
public static final VectorM2D normalizeInPlace(VectorM2D 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.
    
    Parameters:
    
    v - The input vector
    
    Returns:
    
    v
  - orthoNormalize
```
public static final com.io7m.jfunctional.Pair<VectorM2D,VectorM2D> orthoNormalize(VectorReadable2DType v0,
                                                                                  VectorReadable2DType v1)
```
    Orthonormalize and return the vectors v0 and v1 .
    
    See GSP
    
    Parameters:
    
    v0 - The left vector
    
    v1 - The right vector
    
    Returns:
    
    A pair (v0, v1), orthonormalized.
    
    Since:
    
    5.0.0
  - orthoNormalizeInPlace
```
public static final void orthoNormalizeInPlace(VectorM2D v0,
                                               VectorM2D v1)
```
    Orthonormalize and the vectors v0 and v1.
    
    See GSP
    
    Parameters:
    
    v0 - The left vector
    
    v1 - The right vector
    
    Since:
    
    5.0.0
  - projection
```
public static final VectorM2D projection(VectorReadable2DType p,
                                         VectorReadable2DType q,
                                         VectorM2D r)
```
    Calculate the projection of the vector p onto the vector q, saving the result in r.
    
    Parameters:
    
    p - The left vector
    
    q - The right vector
    
    r - The output vector
    
    Returns:
    
    ((dotProduct p q) / magnitudeSquared q) * q
  - scale
```
public static final VectorM2D scale(VectorReadable2DType v,
                                    double r,
                                    VectorM2D out)
```
    Scale the vector v by the scalar r, saving the result to out.
    
    Parameters:
    
    v - The input vector
    
    r - The scaling value
    
    out - The output vector
    
    Returns:
    
    (v.x * r, v.y * r)
  - scaleInPlace
```
public static final VectorM2D scaleInPlace(VectorM2D v,
                                           double r)
```
    Scale the vector v by the scalar r, saving the result to v.
    
    Parameters:
    
    v - The input vector
    
    r - The scaling value
    
    Returns:
    
    (v.x * r, v.y * r)
  - subtract
```
public static final VectorM2D subtract(VectorReadable2DType v0,
                                       VectorReadable2DType v1,
                                       VectorM2D out)
```
    Subtract the vector v1 from the vector v0, saving the result to out.
    
    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 final VectorM2D subtractInPlace(VectorM2D v0,
                                              VectorReadable2DType v1)
```
    Subtract the vector v1 from the vector v0, saving the result to v0.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    (v0.x - v1.x, v0.y - v1.y)
  - copyFrom2D
```
public final 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
  - equals
```
public final boolean equals(@Nullable
                            Object obj)
```
    Overrides:
    
    equals in class Object
  - getXD
```
public final double getXD()
```
    Specified by:
    
    getXD in interface VectorReadable2DType
    
    Returns:
    
    The X value of the given vector.
  - getYD
```
public final double getYD()
```
    Specified by:
    
    getYD in interface VectorReadable2DType
    
    Returns:
    
    The Y value of the given vector.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - set2D
```
public final 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.
  - setXD
```
public final 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.
  - setYD
```
public final 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.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object

Class VectorM2D

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

VectorM2D

VectorM2D

VectorM2D

Method Detail

absolute

absoluteInPlace

add

addInPlace

addScaled

addScaledInPlace

almostEqual

angle

clamp

clampByVector

clampByVectorInPlace

clampInPlace

clampMaximum

clampMaximumByVector

clampMaximumByVectorInPlace

clampMaximumInPlace

clampMinimum

clampMinimumByVector

clampMinimumByVectorInPlace

clampMinimumInPlace

copy

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

normalize

normalizeInPlace

orthoNormalize

orthoNormalizeInPlace

projection

scale

scaleInPlace

subtract

subtractInPlace

copyFrom2D

equals

getXD

getYD

hashCode

set2D

setXD

setYD

toString