com.io7m.jtensors

Class VectorM3I

java.lang.Object

com.io7m.jtensors.VectorM3I

All Implemented Interfaces:

VectorReadable2IType, VectorReadable3IType, VectorWritable2IType, VectorWritable3IType

public class VectorM3I
extends Object
implements VectorReadable3IType, VectorWritable3IType

A three-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
VectorM3I() Default constructor, initializing the vector with values [0, 0, 0].
VectorM3I(int in_x, int in_y, int in_z) Construct a vector initialized with the given values.
VectorM3I(VectorReadable3IType in_v) Construct a vector initialized with the values given in the vector in_v.

Method Summary

Modifier and Type	Method and Description
static VectorM3I	absolute(VectorReadable3IType v, VectorM3I out) Calculate the absolute values of the elements in vector v, saving the result to out.
static VectorM3I	absoluteInPlace(VectorM3I v) Calculate the absolute values of the elements in vector v, saving the result to v.
static VectorM3I	add(VectorReadable3IType v0, VectorReadable3IType v1, VectorM3I out) Calculate the element-wise sum of the vectors v0 and v1, saving the result to out.
static VectorM3I	addInPlace(VectorM3I v0, VectorReadable3IType v1) Calculate the element-wise sum of the vectors v0 and v1, saving the result to v0.
static VectorM3I	addScaled(VectorReadable3IType v0, VectorReadable3IType v1, double r, VectorM3I 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 VectorM3I	addScaledInPlace(VectorM3I v0, VectorReadable3IType 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 VectorM3I	clamp(VectorReadable3IType v, int minimum, int maximum, VectorM3I out) Clamp the elements of the vector v to the range [minimum ..
static VectorM3I	clampByVector(VectorReadable3IType v, VectorReadable3IType minimum, VectorReadable3IType maximum, VectorM3I 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 VectorM3I	clampByVectorInPlace(VectorM3I v, VectorReadable3IType minimum, VectorReadable3IType 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 VectorM3I	clampInPlace(VectorM3I v, int minimum, int maximum) Clamp the elements of the vector v to the range [minimum ..
static VectorM3I	clampMaximum(VectorReadable3IType v, int maximum, VectorM3I out) Clamp the elements of the vector v to the range [-Infinity ..
static VectorM3I	clampMaximumByVector(VectorReadable3IType v, VectorReadable3IType maximum, VectorM3I 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 VectorM3I	clampMaximumByVectorInPlace(VectorM3I v, VectorReadable3IType 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 VectorM3I	clampMaximumInPlace(VectorM3I v, int maximum) Clamp the elements of the vector v to the range [-Infinity ..
static VectorM3I	clampMinimum(VectorReadable3IType v, int minimum, VectorM3I out) Clamp the elements of the vector v to the range [minimum ..
static VectorM3I	clampMinimumByVector(VectorReadable3IType v, VectorReadable3IType minimum, VectorM3I 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 VectorM3I	clampMinimumByVectorInPlace(VectorM3I v, VectorReadable3IType 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 VectorM3I	clampMinimumInPlace(VectorM3I v, int minimum) Clamp the elements of the vector v to the range [minimum ..
static <T extends VectorWritable3IType> T	copy(VectorReadable3IType 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.
void	copyFrom3I(VectorReadable3IType in_v) Set the current vector to the contents of the input vector.
static int	distance(VectorReadable3IType v0, VectorReadable3IType v1) Calculate the distance between the two vectors v0 and v1.
static int	dotProduct(VectorReadable3IType v0, VectorReadable3IType v1) Calculate the scalar product of the vectors v0 and v1.
boolean	equals(Object obj)
int	getXI()
int	getYI()
int	getZI()
int	hashCode()
static VectorM3I	interpolateLinear(VectorReadable3IType v0, VectorReadable3IType v1, double alpha, VectorM3I r) Linearly interpolate between v0 and v1 by the amount alpha, saving the result to r.
static int	magnitude(VectorReadable3IType v) Calculate the magnitude of the vector v.
static int	magnitudeSquared(VectorReadable3IType v) Calculate the squared magnitude of the vector v.
static VectorM3I	projection(VectorReadable3IType p, VectorReadable3IType q, VectorM3I r) Calculate the projection of the vector p onto the vector q, saving the result in r.
static VectorM3I	scale(VectorReadable3IType v, double r, VectorM3I out) Scale the vector v by the scalar r, saving the result to out.
static VectorM3I	scaleInPlace(VectorM3I 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	set3I(int in_x, int in_y, int in_z) Set the current x, y and z 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.
void	setZI(int in_z) Set the current z value of the current vector.
static VectorM3I	subtract(VectorReadable3IType v0, VectorReadable3IType v1, VectorM3I out) Subtract the vector v1 from the vector v0, saving the result to out.
static VectorM3I	subtractInPlace(VectorM3I v0, VectorReadable3IType 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

VectorM3I

public VectorM3I()

Default constructor, initializing the vector with values [0, 0, 0].

VectorM3I

public VectorM3I(int in_x,
                 int in_y,
                 int in_z)

Construct a vector initialized with the given values.

Parameters:

in_x - The x value

in_y - The y value

in_z - The z value

VectorM3I

public VectorM3I(VectorReadable3IType 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 VectorM3I absolute(VectorReadable3IType v,
                                       VectorM3I 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 VectorM3I absoluteInPlace(VectorM3I 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 VectorM3I add(VectorReadable3IType v0,
                                  VectorReadable3IType v1,
                                  VectorM3I 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 VectorM3I addInPlace(VectorM3I v0,
                                         VectorReadable3IType 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 VectorM3I addScaled(VectorReadable3IType v0,
                                        VectorReadable3IType v1,
                                        double r,
                                        VectorM3I 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 VectorM3I addScaledInPlace(VectorM3I v0,
                                               VectorReadable3IType 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

clamp

public static final VectorM3I clamp(VectorReadable3IType v,
                                    int minimum,
                                    int maximum,
                                    VectorM3I 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 VectorM3I clampByVector(VectorReadable3IType v,
                                            VectorReadable3IType minimum,
                                            VectorReadable3IType maximum,
                                            VectorM3I 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 VectorM3I clampByVectorInPlace(VectorM3I v,
                                                   VectorReadable3IType minimum,
                                                   VectorReadable3IType 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 VectorM3I clampInPlace(VectorM3I 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 VectorM3I clampMaximum(VectorReadable3IType v,
                                           int maximum,
                                           VectorM3I 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 VectorM3I clampMaximumByVector(VectorReadable3IType v,
                                                   VectorReadable3IType maximum,
                                                   VectorM3I 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 VectorM3I clampMaximumByVectorInPlace(VectorM3I v,
                                                          VectorReadable3IType 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 VectorM3I clampMaximumInPlace(VectorM3I 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 VectorM3I clampMinimum(VectorReadable3IType v,
                                           int minimum,
                                           VectorM3I 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 VectorM3I clampMinimumByVector(VectorReadable3IType v,
                                                   VectorReadable3IType minimum,
                                                   VectorM3I 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 VectorM3I clampMinimumByVectorInPlace(VectorM3I v,
                                                          VectorReadable3IType 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 VectorM3I clampMinimumInPlace(VectorM3I 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 VectorWritable3IType> T copy(VectorReadable3IType 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(VectorReadable3IType v0,
                                 VectorReadable3IType 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(VectorReadable3IType v0,
                                   VectorReadable3IType 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 VectorM3I interpolateLinear(VectorReadable3IType v0,
                                                VectorReadable3IType v1,
                                                double alpha,
                                                VectorM3I 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(VectorReadable3IType 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(VectorReadable3IType 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 VectorM3I projection(VectorReadable3IType p,
                                         VectorReadable3IType q,
                                         VectorM3I 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 VectorM3I scale(VectorReadable3IType v,
                                    double r,
                                    VectorM3I 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 VectorM3I scaleInPlace(VectorM3I 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 VectorM3I subtract(VectorReadable3IType v0,
                                       VectorReadable3IType v1,
                                       VectorM3I 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 VectorM3I subtractInPlace(VectorM3I v0,
                                              VectorReadable3IType 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

copyFrom3I

public final void copyFrom3I(VectorReadable3IType in_v)

Description copied from interface: VectorWritable3IType

Set the current vector to the contents of the input vector.

Specified by:

copyFrom3I in interface VectorWritable3IType

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.

getZI

public final int getZI()

Specified by:

getZI in interface VectorReadable3IType

Returns:

The Z 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.

set3I

public final void set3I(int in_x,
                        int in_y,
                        int in_z)

Description copied from interface: VectorWritable3IType

Set the current x, y and z values of the current vector.

Specified by:

set3I in interface VectorWritable3IType

Parameters:

in_x - The new x value.

in_y - The new y value.

in_z - The new z 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.

setZI

public final void setZI(int in_z)

Description copied from interface: VectorWritable3IType

Set the current z value of the current vector.

Specified by:

setZI in interface VectorWritable3IType

Parameters:

in_z - The new z value.

toString

public final String toString()

Overrides:

toString in class Object