PVectorI2L (io7m-jtensors-documentation 7.0.0-beta0011 API)

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

Type Parameters:

T - A phantom type parameter.

All Implemented Interfaces:

PVectorReadable2LType<T>, VectorReadable2LType
```
@Immutable
public final class PVectorI2L<T>
extends Object
implements PVectorReadable2LType<T>
```
A two-dimensional immutable vector type with integer elements.

Values of this type are immutable and can therefore be safely accessed from multiple threads.

Since:

7.0.0

Constructor Summary

Constructors
Constructor and Description
`PVectorI2L()` Default constructor, initializing the vector with values `[0, 0, 0]`.
`PVectorI2L(long in_x, long in_y)` Construct a vector initialized with the given values.
`PVectorI2L(PVectorReadable2LType<T> in_v)` Construct a vector initialized with the values given in the vector `in_v`.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> PVectorI2L<T>`	`absolute(PVectorReadable2LType<T> v)` Calculate the absolute values of the elements in vector `v`.
`static <T> PVectorI2L<T>`	`add(PVectorReadable2LType<T> v0, PVectorReadable2LType<T> v1)` Calculate the element-wise sum of the vectors `v0` and `v1`.
`static <T> PVectorI2L<T>`	`addScaled(PVectorReadable2LType<T> v0, PVectorReadable2LType<T> v1, double r)` Calculate the element-wise sum of the vectors `v0` and the element-wise product of `v1` and `r`.
`static <T> double`	`angle(PVectorReadable2LType<T> v0, PVectorReadable2LType<T> v1)` Calculate the angle between the vectors `v0` and `v1` in radians.
`static <T> PVectorI2L<T>`	`clamp(PVectorReadable2LType<T> v, long minimum, long maximum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static <T> PVectorI2L<T>`	`clampByPVector(PVectorReadable2LType<T> v, PVectorReadable2LType<T> minimum, PVectorReadable2LType<T> maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum` and `maximum`.
`static <T> PVectorI2L<T>`	`clampMaximum(PVectorReadable2LType<T> v, long maximum)` Clamp the elements of the vector `v` to the range {@code [-Infinity ..
`static <T> PVectorI2L<T>`	`clampMaximumByPVector(PVectorReadable2LType<T> v, PVectorReadable2LType<T> maximum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `maximum`.
`static <T> PVectorI2L<T>`	`clampMinimum(PVectorReadable2LType<T> v, long minimum)` Clamp the elements of the vector `v` to the range {@code [minimum ..
`static <T> PVectorI2L<T>`	`clampMinimumByPVector(PVectorReadable2LType<T> v, PVectorReadable2LType<T> minimum)` Clamp the elements of the vector `v` to the inclusive range given by the corresponding elements in `minimum`.
`static <T> long`	`distance(PVectorReadable2LType<T> v0, PVectorReadable2LType<T> v1)` Calculate the distance between the two vectors `v0` and `v1`.
`static <T> long`	`dotProduct(PVectorReadable2LType<T> v0, PVectorReadable2LType<T> v1)` Calculate the scalar product of the vectors `v0` and `v1`.
`boolean`	`equals(Object obj)`
`long`	`getXL()`
`long`	`getYL()`
`int`	`hashCode()`
`static <T> PVectorI2L<T>`	`interpolateLinear(PVectorReadable2LType<T> v0, PVectorReadable2LType<T> v1, double alpha)` Linearly interpolate between `v0` and `v1` by the amount `alpha`.
`static <T> long`	`magnitude(PVectorReadable2LType<T> v)` Calculate the magnitude of the vector `v`.
`static <T> long`	`magnitudeSquared(PVectorReadable2LType<T> v)` Calculate the squared magnitude of the vector `v`.
`static <T> PVectorI2L<T>`	`projection(PVectorReadable2LType<T> p, PVectorReadable2LType<T> q)` Calculate the projection of the vector `p` onto the vector `q`.
`static <T> PVectorI2L<T>`	`scale(PVectorReadable2LType<T> v, double r)` Scale the vector `v` by the scalar `r`.
`static <T> PVectorI2L<T>`	`subtract(PVectorReadable2LType<T> v0, PVectorReadable2LType<T> v1)` Subtract the vector `v1` from the vector `v0`.
`String`	`toString()`
`static <T> PVectorI2L<T>`	`zero()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - PVectorI2L
```
public PVectorI2L()
```
    Default constructor, initializing the vector with values [0, 0, 0].
  - PVectorI2L
```
public PVectorI2L(long in_x,
                  long in_y)
```
    Construct a vector initialized with the given values.
    
    Parameters:
    
    in_x - The x value
    
    in_y - The y value
  - PVectorI2L
```
public PVectorI2L(PVectorReadable2LType<T> in_v)
```
    Construct a vector initialized with the values given in the vector in_v.
    
    Parameters:
    
    in_v - The input vector
- Method Detail
  - absolute
```
public static <T> PVectorI2L<T> absolute(PVectorReadable2LType<T> v)
                                  throws ArithmeticException
```
    Calculate the absolute values of the elements in vector v.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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
    
    Since:
    
    7.0.0
  - add
```
public static <T> PVectorI2L<T> add(PVectorReadable2LType<T> v0,
                                    PVectorReadable2LType<T> v1)
                             throws ArithmeticException
```
    Calculate the element-wise sum 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:
    
    (v0.x + v1.x, v0.y + v1.y)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - addScaled
```
public static <T> PVectorI2L<T> addScaled(PVectorReadable2LType<T> v0,
                                          PVectorReadable2LType<T> v1,
                                          double r)
                                   throws ArithmeticException
```
    Calculate the element-wise sum of the vectors v0 and the element-wise product of v1 and r.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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))
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - angle
```
public static <T> double angle(PVectorReadable2LType<T> v0,
                               PVectorReadable2LType<T> v1)
```
    Calculate the angle between the 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> PVectorI2L<T> clamp(PVectorReadable2LType<T> v,
                                      long minimum,
                                      long maximum)
```
    Clamp the elements of the vector v to the range [minimum .. maximum] inclusive.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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
    
    Since:
    
    7.0.0
  - clampByPVector
```
public static <T> PVectorI2L<T> clampByPVector(PVectorReadable2LType<T> v,
                                               PVectorReadable2LType<T> minimum,
                                               PVectorReadable2LType<T> maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum and maximum.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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))
    
    Since:
    
    7.0.0
  - clampMaximum
```
public static <T> PVectorI2L<T> clampMaximum(PVectorReadable2LType<T> v,
                                             long maximum)
```
    Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    maximum - The maximum allowed value
    
    Returns:
    
    A vector with both elements equal to at most maximum
    
    Since:
    
    7.0.0
  - clampMaximumByPVector
```
public static <T> PVectorI2L<T> clampMaximumByPVector(PVectorReadable2LType<T> v,
                                                      PVectorReadable2LType<T> maximum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    maximum - The vector containing the maximum acceptable values
    
    Returns:
    
    (min(v.x, maximum.x), min(v.y, maximum.y))
    
    Since:
    
    7.0.0
  - clampMinimum
```
public static <T> PVectorI2L<T> clampMinimum(PVectorReadable2LType<T> v,
                                             long minimum)
```
    Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    minimum - The minimum allowed value
    
    Returns:
    
    A vector with both elements equal to at least minimum
    
    Since:
    
    7.0.0
  - clampMinimumByPVector
```
public static <T> PVectorI2L<T> clampMinimumByPVector(PVectorReadable2LType<T> v,
                                                      PVectorReadable2LType<T> minimum)
```
    Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    minimum - The vector containing the minimum acceptable values
    
    Returns:
    
    (max(v.x, minimum.x), max(v.y, minimum.y))
    
    Since:
    
    7.0.0
  - distance
```
public static <T> long distance(PVectorReadable2LType<T> v0,
                                PVectorReadable2LType<T> v1)
                         throws ArithmeticException
```
    Calculate the distance between the two vectors v0 and v1.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    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
    
    Since:
    
    7.0.0
  - dotProduct
```
public static <T> long dotProduct(PVectorReadable2LType<T> v0,
                                  PVectorReadable2LType<T> v1)
                           throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
    
    Since:
    
    7.0.0
  - interpolateLinear
```
public static <T> PVectorI2L<T> interpolateLinear(PVectorReadable2LType<T> v0,
                                                  PVectorReadable2LType<T> v1,
                                                  double alpha)
                                           throws ArithmeticException
```
    Linearly interpolate between v0 and v1 by the amount alpha. The alpha parameter controls the degree of interpolation, such that:
    - interpolateLinear(v0, v1, 0.0, r) → r = v0
    - interpolateLinear(v0, v1, 1.0, r) → r = v1
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v0 - The left input vector.
    
    v1 - The right input vector.
    
    alpha - The interpolation value, between 0.0 and 1.0.
    
    Returns:
    
    (1 - alpha) * v0 + alpha * v1
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow.
    
    Since:
    
    7.0.0
  - magnitude
```
public static <T> long magnitude(PVectorReadable2LType<T> v)
                          throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
    
    Since:
    
    7.0.0
  - magnitudeSquared
```
public static <T> long magnitudeSquared(PVectorReadable2LType<T> v)
                                 throws ArithmeticException
```
    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
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
    
    Since:
    
    7.0.0
  - projection
```
public static <T> PVectorI2L<T> projection(PVectorReadable2LType<T> p,
                                           PVectorReadable2LType<T> q)
                                    throws ArithmeticException
```
    Calculate the projection of the vector p onto the vector q.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    p - The left vector
    
    q - The right vector
    
    Returns:
    
    ((dotProduct p q) / magnitudeSquared q) * q
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
    
    Since:
    
    7.0.0
  - scale
```
public static <T> PVectorI2L<T> scale(PVectorReadable2LType<T> v,
                                      double r)
                               throws ArithmeticException
```
    Scale the vector v by the scalar r.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v - The input vector
    
    r - The scaling value
    
    Returns:
    
    (v.x * r, v.y * r)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - subtract
```
public static <T> PVectorI2L<T> subtract(PVectorReadable2LType<T> v0,
                                         PVectorReadable2LType<T> v1)
                                  throws ArithmeticException
```
    Subtract the vector v1 from the vector v0.
    
    Type Parameters:
    
    T - A phantom type parameter.
    
    Parameters:
    
    v0 - The left input vector
    
    v1 - The right input vector
    
    Returns:
    
    (v0.x - v1.x, v0.y - v1.y)
    
    Throws:
    
    ArithmeticException - Iff an internal arithmetic operation causes an integer overflow
  - zero
```
public static <T> PVectorI2L<T> zero()
```
    Type Parameters:
    
    T - A phantom type parameter.
    
    Returns:
    
    The zero vector.
  - equals
```
public boolean equals(@Nullable
                      Object obj)
```
    Overrides:
    
    equals in class Object
  - getXL
```
public long getXL()
```
    Specified by:
    
    getXL in interface VectorReadable2LType
    
    Returns:
    
    The X value of the given vector.
  - getYL
```
public long getYL()
```
    Specified by:
    
    getYL in interface VectorReadable2LType
    
    Returns:
    
    The Y value of the given vector.
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object

Class PVectorI2L<T>

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

PVectorI2L

PVectorI2L

PVectorI2L

Method Detail

absolute

add

addScaled

angle

clamp

clampByPVector

clampMaximum

clampMaximumByPVector

clampMinimum

clampMinimumByPVector

distance

dotProduct

interpolateLinear

magnitude

magnitudeSquared

projection

scale

subtract

zero

equals

getXL

getYL

hashCode

toString