VectorM2I (io7m-jtensors-documentation 6.0.0 API)

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

All Implemented Interfaces:

VectorReadable2IType, VectorWritable2IType
```
public class VectorM2I
extends Object
implements VectorReadable2IType, VectorWritable2IType
```
A two-dimensional mutable vector type with integer elements.

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

Constructor Summary

Constructors
Constructor and Description
`VectorM2I()` Default constructor, initializing the vector with values `[0, 0, 0]`.
`VectorM2I(int in_x, int in_y)` Construct a vector initialized with the given values.
`VectorM2I(VectorReadable2IType 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 VectorM2I`	`absolute(VectorReadable2IType v, VectorM2I out)` Calculate the absolute values of the elements in vector `v`, saving the result to `out`.
`static VectorM2I`	`absoluteInPlace(VectorM2I v)` Calculate the absolute values of the elements in vector `v`, saving the result to `v`.
`static VectorM2I`	`add(VectorReadable2IType v0, VectorReadable2IType v1, VectorM2I out)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `out`.
`static VectorM2I`	`addInPlace(VectorM2I v0, VectorReadable2IType v1)` Calculate the element-wise sum of the vectors `v0` and `v1`, saving the result to `v0`.
`static VectorM2I`	`addScaled(VectorReadable2IType v0, VectorReadable2IType v1, double r, VectorM2I 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 VectorM2I`	`addScaledInPlace(VectorM2I v0, VectorReadable2IType 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 double`	`angle(VectorReadable2IType v0, VectorReadable2IType v1)` Calculate the angle between vectors `v0` and `v1`, in radians.
`static VectorM2I`	`clamp(VectorReadable2IType v, int minimum, int maximum, VectorM2I out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2I`	`clampByVector(VectorReadable2IType v, VectorReadable2IType minimum, VectorReadable2IType maximum, VectorM2I 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 VectorM2I`	`clampByVectorInPlace(VectorM2I v, VectorReadable2IType minimum, VectorReadable2IType 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 VectorM2I`	`clampInPlace(VectorM2I v, int minimum, int maximum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2I`	`clampMaximum(VectorReadable2IType v, int maximum, VectorM2I out)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM2I`	`clampMaximumByVector(VectorReadable2IType v, VectorReadable2IType maximum, VectorM2I 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 VectorM2I`	`clampMaximumByVectorInPlace(VectorM2I v, VectorReadable2IType 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 VectorM2I`	`clampMaximumInPlace(VectorM2I v, int maximum)` Clamp the elements of the vector `v` to the range `[-Infinity ..`
`static VectorM2I`	`clampMinimum(VectorReadable2IType v, int minimum, VectorM2I out)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static VectorM2I`	`clampMinimumByVector(VectorReadable2IType v, VectorReadable2IType minimum, VectorM2I 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 VectorM2I`	`clampMinimumByVectorInPlace(VectorM2I v, VectorReadable2IType 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 VectorM2I`	`clampMinimumInPlace(VectorM2I v, int minimum)` Clamp the elements of the vector `v` to the range `[minimum ..`
`static <T extends VectorWritable2IType> T`	`copy(VectorReadable2IType input, T output)` Copy all elements of the vector `input` to the vector `output`.
`void`	`copyFrom2I(VectorReadable2IType in_v)` Set the current vector to the contents of the input vector.
`static int`	`distance(VectorReadable2IType v0, VectorReadable2IType v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static int`	`dotProduct(VectorReadable2IType v0, VectorReadable2IType v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`int`	`getXI()`
`int`	`getYI()`
`int`	`hashCode()`
`static VectorM2I`	`interpolateLinear(VectorReadable2IType v0, VectorReadable2IType v1, double alpha, VectorM2I r)` Linearly interpolate between `v0` and `v1` by the amount `alpha`, saving the result to `r`.
`static int`	`magnitude(VectorReadable2IType v)` Calculate the magnitude of the vector `v`.
`static int`	`magnitudeSquared(VectorReadable2IType v)` Calculate the squared magnitude of the vector `v`.
`static VectorM2I`	`projection(VectorReadable2IType p, VectorReadable2IType q, VectorM2I r)` Calculate the projection of the vector `p` onto the vector `q`, saving the result in `r`.
`static VectorM2I`	`scale(VectorReadable2IType v, double r, VectorM2I out)` Scale the vector `v` by the scalar `r`, saving the result to `out`.
`static VectorM2I`	`scaleInPlace(VectorM2I v, int r)` Scale the vector `v` by the scalar `r`, saving the result to `v`.
`void`	`set2I(int in_x, int in_y)` Set the current `x` and `y` values of the current vector.
`void`	`setXI(int in_x)` Set the current `x` value of the current vector.
`void`	`setYI(int in_y)` Set the current `y` value of the current vector.
`static VectorM2I`	`subtract(VectorReadable2IType v0, VectorReadable2IType v1, VectorM2I out)` Subtract the vector `v1` from the vector `v0`, saving the result to `out`.
`static VectorM2I`	`subtractInPlace(VectorM2I v0, VectorReadable2IType 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
  - VectorM2I
```
public VectorM2I()
```
    Default constructor, initializing the vector with values [0, 0, 0].
  - VectorM2I
```
public VectorM2I(int in_x,
         int in_y)
```
    Construct a vector initialized with the given values.
    
    Parameters:
    in_x - The x value
    in_y - The y value
  - VectorM2I
```
public VectorM2I(VectorReadable2IType 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 VectorM2I absolute(VectorReadable2IType v,
                 VectorM2I out)
                                throws ArithmeticException
```
    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, abs v.z)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - absoluteInPlace
```
public static final VectorM2I absoluteInPlace(VectorM2I v)
                                       throws ArithmeticException
```
    Calculate the absolute values of the elements in vector v, saving the result to v.
    
    Parameters:
    v - The input vector
    
    Returns:
    (abs v.x, abs v.y, abs v.z)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - add
```
public static final VectorM2I add(VectorReadable2IType v0,
            VectorReadable2IType v1,
            VectorM2I out)
                           throws ArithmeticException
```
    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, v0.z + v1.z)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - addInPlace
```
public static final VectorM2I addInPlace(VectorM2I v0,
                   VectorReadable2IType v1)
                                  throws ArithmeticException
```
    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, v0.z + v1.z)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - addScaled
```
public static final VectorM2I addScaled(VectorReadable2IType v0,
                  VectorReadable2IType v1,
                  double r,
                  VectorM2I out)
                                 throws ArithmeticException
```
    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), v0.z + (v1.z * r))
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - addScaledInPlace
```
public static final VectorM2I addScaledInPlace(VectorM2I v0,
                         VectorReadable2IType v1,
                         double r)
                                        throws ArithmeticException
```
    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), v0.z + (v1.z * r))
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - angle
```
public static final double angle(VectorReadable2IType v0,
           VectorReadable2IType 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 VectorM2I clamp(VectorReadable2IType v,
              int minimum,
              int maximum,
              VectorM2I 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 VectorM2I clampByVector(VectorReadable2IType v,
                      VectorReadable2IType minimum,
                      VectorReadable2IType maximum,
                      VectorM2I 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), min(max(v.z, minimum.z), maximum.z))
  - clampByVectorInPlace
```
public static final VectorM2I clampByVectorInPlace(VectorM2I v,
                             VectorReadable2IType minimum,
                             VectorReadable2IType 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), min(max(v.z, minimum.z), maximum.z))
  - clampInPlace
```
public static final VectorM2I clampInPlace(VectorM2I v,
                     int minimum,
                     int 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 VectorM2I clampMaximum(VectorReadable2IType v,
                     int maximum,
                     VectorM2I 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 VectorM2I clampMaximumByVector(VectorReadable2IType v,
                             VectorReadable2IType maximum,
                             VectorM2I 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), min(v.z, maximum.z))
  - clampMaximumByVectorInPlace
```
public static final VectorM2I clampMaximumByVectorInPlace(VectorM2I v,
                                    VectorReadable2IType 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), min(v.z, maximum.z))
  - clampMaximumInPlace
```
public static final VectorM2I clampMaximumInPlace(VectorM2I v,
                            int 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 VectorM2I clampMinimum(VectorReadable2IType v,
                     int minimum,
                     VectorM2I 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 VectorM2I clampMinimumByVector(VectorReadable2IType v,
                             VectorReadable2IType minimum,
                             VectorM2I 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), max(v.z, minimum.z))
  - clampMinimumByVectorInPlace
```
public static final VectorM2I clampMinimumByVectorInPlace(VectorM2I v,
                                    VectorReadable2IType 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), max(v.z, minimum.z)) , in v
  - clampMinimumInPlace
```
public static final VectorM2I clampMinimumInPlace(VectorM2I v,
                            int 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 VectorWritable2IType> T copy(VectorReadable2IType input,
                                      T output)
```
    Copy all elements of the vector input to the vector output.
    
    Type Parameters:
    T - The specific type of vector
    Parameters:
    input - The input vector
    output - The output vector
    
    Returns:
    output
  - distance
```
public static final int distance(VectorReadable2IType v0,
           VectorReadable2IType v1)
                          throws ArithmeticException
```
    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.
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - dotProduct
```
public static final int dotProduct(VectorReadable2IType v0,
             VectorReadable2IType v1)
                            throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - interpolateLinear
```
public static final VectorM2I interpolateLinear(VectorReadable2IType v0,
                          VectorReadable2IType v1,
                          double alpha,
                          VectorM2I r)
                                         throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow.
  - magnitude
```
public static final int magnitude(VectorReadable2IType v)
                           throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - magnitudeSquared
```
public static final int magnitudeSquared(VectorReadable2IType v)
                                  throws ArithmeticException
```
    Calculate the squared magnitude of the vector v.
    
    Parameters:
    v - The input vector
    
    Returns:
    The squared magnitude of the input vector
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - projection
```
public static final VectorM2I projection(VectorReadable2IType p,
                   VectorReadable2IType q,
                   VectorM2I r)
                                  throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - scale
```
public static final VectorM2I scale(VectorReadable2IType v,
              double r,
              VectorM2I out)
                             throws ArithmeticException
```
    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, v.z * r)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - scaleInPlace
```
public static final VectorM2I scaleInPlace(VectorM2I v,
                     int r)
                                    throws ArithmeticException
```
    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, v.z * r)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - subtract
```
public static final VectorM2I subtract(VectorReadable2IType v0,
                 VectorReadable2IType v1,
                 VectorM2I out)
                                throws ArithmeticException
```
    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, v0.z - v1.z)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - subtractInPlace
```
public static final VectorM2I subtractInPlace(VectorM2I v0,
                        VectorReadable2IType v1)
                                       throws ArithmeticException
```
    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, v0.z - v1.z)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - copyFrom2I
```
public final void copyFrom2I(VectorReadable2IType in_v)
```
    Description copied from interface: VectorWritable2IType
    
    Set the current vector to the contents of the input vector.
    
    Specified by:
    
    copyFrom2I in interface VectorWritable2IType
    
    Parameters:
    in_v - The input vector
  - equals
```
public final boolean equals(@Nullable
             Object obj)
```
    Overrides:
    
    equals in class Object
  - getXI
```
public final int getXI()
```
    Specified by:
    
    getXI in interface VectorReadable2IType
    
    Returns:
    The X value of the given vector.
  - getYI
```
public final int getYI()
```
    Specified by:
    
    getYI in interface VectorReadable2IType
    
    Returns:
    The Y value of the given vector.
  - hashCode
```
public final int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - set2I
```
public final void set2I(int in_x,
         int in_y)
```
    Description copied from interface: VectorWritable2IType
    
    Set the current x and y values of the current vector.
    
    Specified by:
    
    set2I in interface VectorWritable2IType
    
    Parameters:
    in_x - The new x value.
    in_y - The new y value.
  - setXI
```
public final void setXI(int in_x)
```
    Description copied from interface: VectorWritable2IType
    
    Set the current x value of the current vector.
    
    Specified by:
    
    setXI in interface VectorWritable2IType
    
    Parameters:
    in_x - The new x value.
  - setYI
```
public final void setYI(int in_y)
```
    Description copied from interface: VectorWritable2IType
    
    Set the current y value of the current vector.
    
    Specified by:
    
    setYI in interface VectorWritable2IType
    
    Parameters:
    in_y - The new y value.
  - toString
```
public final String toString()
```
    Overrides:
    
    toString in class Object

Class VectorM2I

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

VectorM2I

VectorM2I

VectorM2I

Method Detail

absolute

absoluteInPlace

add

addInPlace

addScaled

addScaledInPlace

angle

clamp

clampByVector

clampByVectorInPlace

clampInPlace

clampMaximum

clampMaximumByVector

clampMaximumByVectorInPlace

clampMaximumInPlace

clampMinimum

clampMinimumByVector

clampMinimumByVectorInPlace

clampMinimumInPlace

copy

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

projection

scale

scaleInPlace

subtract

subtractInPlace

copyFrom2I

equals

getXI

getYI

hashCode

set2I

setXI

setYI

toString