VectorM2F (io7m-jtensors-documentation 6.0.0 API)

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

All Implemented Interfaces:

VectorReadable2FType, VectorWritable2FType
```
public class VectorM2F
extends Object
implements VectorReadable2FType, VectorWritable2FType
```
A two-dimensional mutable vector type with single precision elements.

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

Constructor Summary

Constructors
Constructor and Description
`VectorM2F()` Default constructor, initializing the vector with values `[0.0, 0.0]`.
`VectorM2F(float in_x, float in_y)` Construct a vector initialized with the given values.
`VectorM2F(VectorReadable2FType in_v)` Construct a vector initialized with the values given in the vector `in_v`.

Method Summary

Methods
Modifier and Type	Method and Description
`static VectorM2F`	`absolute(VectorReadable2FType v, VectorM2F out)` Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
`static VectorM2F`	`absoluteInPlace(VectorM2F v)` Calculate the absolute values of the elements in vector `v`, modifying the vector in-place.
`static VectorM2F`	`add(VectorReadable2FType v0, VectorReadable2FType v1, VectorM2F out)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
`static VectorM2F`	`addInPlace(VectorM2F v0, VectorReadable2FType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
`static VectorM2F`	`addScaled(VectorReadable2FType v0, VectorReadable2FType v1, double r, VectorM2F 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 VectorM2F`	`addScaledInPlace(VectorM2F v0, VectorReadable2FType 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.AlmostEqualFloat.ContextRelative context, VectorReadable2FType qa, VectorReadable2FType qb)` Determine whether or not the vectors `qa` and `qb` are equal to within the degree of error given in `context`.
`static double`	`angle(VectorReadable2FType v0, VectorReadable2FType v1)` Calculate the angle between vectors `v0` and `v1`, in radians.
`static VectorM2F`	`clamp(VectorReadable2FType v, float minimum, float maximum, VectorM2F out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2F`	`clampByVector(VectorReadable2FType v, VectorReadable2FType minimum, VectorReadable2FType maximum, VectorM2F 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 VectorM2F`	`clampByVectorInPlace(VectorM2F v, VectorReadable2FType minimum, VectorReadable2FType 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 VectorM2F`	`clampInPlace(VectorM2F v, float minimum, float maximum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2F`	`clampMaximum(VectorReadable2FType v, float maximum, VectorM2F out)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM2F`	`clampMaximumByVector(VectorReadable2FType v, VectorReadable2FType maximum, VectorM2F 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 VectorM2F`	`clampMaximumByVectorInPlace(VectorM2F v, VectorReadable2FType 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 VectorM2F`	`clampMaximumInPlace(VectorM2F v, float maximum)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM2F`	`clampMinimum(VectorReadable2FType v, float minimum, VectorM2F out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2F`	`clampMinimumByVector(VectorReadable2FType v, VectorReadable2FType minimum, VectorM2F 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 VectorM2F`	`clampMinimumByVectorInPlace(VectorM2F v, VectorReadable2FType 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 VectorM2F`	`clampMinimumInPlace(VectorM2F v, float minimum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static <T extends VectorWritable2FType> T`	`copy(VectorReadable2FType input, T output)` Copy all elements of the vector `input` to the vector `output`.
`void`	`copyFrom2F(VectorReadable2FType in_v)` Set the current vector to the contents of the input vector.
`static double`	`distance(VectorReadable2FType v0, VectorReadable2FType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static float`	`dotProduct(VectorReadable2FType v0, VectorReadable2FType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`float`	`getXF()`
`float`	`getYF()`
`int`	`hashCode()`
`static VectorM2F`	`interpolateLinear(VectorReadable2FType v0, VectorReadable2FType v1, double alpha, VectorM2F r)` Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`.
`static double`	`magnitude(VectorReadable2FType v)` Calculate the magnitude of the vector `v`.
`static double`	`magnitudeSquared(VectorReadable2FType v)` Calculate the squared magnitude of the vector `v`.
`static VectorM2F`	`normalize(VectorReadable2FType v, VectorM2F out)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `out`.
`static VectorM2F`	`normalizeInPlace(VectorM2F v)` Returns a vector with the same orientation as `v` but with magnitude equal to `1.0` in `v`.
`static com.io7m.jfunctional.Pair<VectorM2F,VectorM2F>`	`orthoNormalize(VectorReadable2FType v0, VectorReadable2FType v1)` Orthonormalize and return the vectors `v0` and `v1` .
`static void`	`orthoNormalizeInPlace(VectorM2F v0, VectorM2F v1)` Orthonormalize and the vectors `v0` and `v1`.
`static VectorM2F`	`projection(VectorReadable2FType p, VectorReadable2FType q, VectorM2F r)` Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
`static VectorM2F`	`scale(VectorReadable2FType v, double r, VectorM2F out)` Scale the vector `v` by the scalar `r`, saving the result to `out`.
`static VectorM2F`	`scaleInPlace(VectorM2F v, double r)` Scale the vector `v` by the scalar `r`, saving the result to `v`.
`void`	`set2F(float in_x, float in_y)` Set the current `x` and `y` values of the current vector.
`void`	`setXF(float in_x)` Set the current `x` value of the current vector.
`void`	`setYF(float in_y)` Set the current `y` value of the current vector.
`static VectorM2F`	`subtract(VectorReadable2FType v0, VectorReadable2FType v1, VectorM2F out)` Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
`static VectorM2F`	`subtractInPlace(VectorM2F v0, VectorReadable2FType 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
  - VectorM2F
```
public VectorM2F()
```
    Default constructor, initializing the vector with values [0.0, 0.0].
  - VectorM2F
```
public VectorM2F(float in_x,
         float in_y)
```
    Construct a vector initialized with the given values.
    
    Parameters:
    in_x - The x value
    in_y - The y value
  - VectorM2F
```
public VectorM2F(VectorReadable2FType in_v)
```
    Construct a vector initialized with the values given in the vector in_v.
    
    Parameters:
    in_v - The source vector
- Method Detail
  - absolute
```
public static final VectorM2F absolute(VectorReadable2FType v,
                 VectorM2F 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 VectorM2F absoluteInPlace(VectorM2F 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 VectorM2F add(VectorReadable2FType v0,
            VectorReadable2FType v1,
            VectorM2F 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 VectorM2F addInPlace(VectorM2F v0,
                   VectorReadable2FType 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 VectorM2F addScaled(VectorReadable2FType v0,
                  VectorReadable2FType v1,
                  double r,
                  VectorM2F 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 VectorM2F addScaledInPlace(VectorM2F v0,
                         VectorReadable2FType 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.AlmostEqualFloat.ContextRelative context,
                  VectorReadable2FType qa,
                  VectorReadable2FType 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:
    AlmostEqualFloat.almostEqual(ContextRelative, float, float)
  - angle
```
public static final double angle(VectorReadable2FType v0,
           VectorReadable2FType 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 VectorM2F clamp(VectorReadable2FType v,
              float minimum,
              float maximum,
              VectorM2F 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 VectorM2F clampByVector(VectorReadable2FType v,
                      VectorReadable2FType minimum,
                      VectorReadable2FType maximum,
                      VectorM2F 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 VectorM2F clampByVectorInPlace(VectorM2F v,
                             VectorReadable2FType minimum,
                             VectorReadable2FType 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 VectorM2F clampInPlace(VectorM2F v,
                     float minimum,
                     float 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 VectorM2F clampMaximum(VectorReadable2FType v,
                     float maximum,
                     VectorM2F 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 VectorM2F clampMaximumByVector(VectorReadable2FType v,
                             VectorReadable2FType maximum,
                             VectorM2F 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 VectorM2F clampMaximumByVectorInPlace(VectorM2F v,
                                    VectorReadable2FType 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 VectorM2F clampMaximumInPlace(VectorM2F v,
                            float 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 VectorM2F clampMinimum(VectorReadable2FType v,
                     float minimum,
                     VectorM2F 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 VectorM2F clampMinimumByVector(VectorReadable2FType v,
                             VectorReadable2FType minimum,
                             VectorM2F 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 VectorM2F clampMinimumByVectorInPlace(VectorM2F v,
                                    VectorReadable2FType 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 VectorM2F clampMinimumInPlace(VectorM2F v,
                            float 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 <T extends VectorWritable2FType> T copy(VectorReadable2FType input,
                                      T output)
```
    Copy all elements of the vector input to the vector output.
    
    Type Parameters:
    T - The specific vector type
    Parameters:
    input - The input vector
    output - The output vector
    
    Returns:
    output
  - distance
```
public static final double distance(VectorReadable2FType v0,
              VectorReadable2FType 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 float dotProduct(VectorReadable2FType v0,
               VectorReadable2FType 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 VectorM2F interpolateLinear(VectorReadable2FType v0,
                          VectorReadable2FType v1,
                          double alpha,
                          VectorM2F 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(VectorReadable2FType 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(VectorReadable2FType 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 VectorM2F normalize(VectorReadable2FType v,
                  VectorM2F 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 VectorM2F normalizeInPlace(VectorM2F 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<VectorM2F,VectorM2F> orthoNormalize(VectorReadable2FType v0,
                                                            VectorReadable2FType 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(VectorM2F v0,
                         VectorM2F 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 VectorM2F projection(VectorReadable2FType p,
                   VectorReadable2FType q,
                   VectorM2F 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 VectorM2F scale(VectorReadable2FType v,
              double r,
              VectorM2F 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 VectorM2F scaleInPlace(VectorM2F 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 VectorM2F subtract(VectorReadable2FType v0,
                 VectorReadable2FType v1,
                 VectorM2F 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 VectorM2F subtractInPlace(VectorM2F v0,
                        VectorReadable2FType 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)
  - copyFrom2F
```
public final void copyFrom2F(VectorReadable2FType in_v)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom2F in interface VectorWritable2FType
    
    Parameters:
    in_v - The input vector
  - equals
```
public final boolean equals(@Nullable
             Object obj)
```
    Overrides:
    
    equals in class Object
  - getXF
```
public final float getXF()
```
    Specified by:
    
    getXF in interface VectorReadable2FType
    
    Returns:
    The X value of the given vector.
  - getYF
```
public final float getYF()
```
    Specified by:
    
    getYF in interface VectorReadable2FType
    
    Returns:
    The Y value of the given vector.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - set2F
```
public final void set2F(float in_x,
         float in_y)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current x and y values of the current vector.
    
    Specified by:
    
    set2F in interface VectorWritable2FType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
  - setXF
```
public final void setXF(float in_x)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current x value of the current vector.
    
    Specified by:
    
    setXF in interface VectorWritable2FType
    
    Parameters:
    in_x - The new x value.
  - setYF
```
public final void setYF(float in_y)
```
    Description copied from interface: VectorWritable2FType
    
    Set the current y value of the current vector.
    
    Specified by:
    
    setYF in interface VectorWritable2FType
    
    Parameters:
    in_y - The new y value.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object

Class VectorM2F

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

VectorM2F

VectorM2F

VectorM2F

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

copyFrom2F

equals

getXF

getYF

hashCode

set2F

setXF

setYF

toString