com.io7m.jtensors

Class VectorM2F

java.lang.Object

com.io7m.jtensors.VectorM2F

All Implemented Interfaces:

Vector2FType, VectorReadable2FType, VectorWritable2FType

public final class VectorM2F
extends Object
implements Vector2FType

A two-dimensional mutable vector type with float elements.

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

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	VectorM2F.ContextVM2F Preallocated storage to allow all vector functions to run without allocating.

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

Modifier and Type	Method and Description
static <V extends VectorWritable2FType> V	absolute(VectorReadable2FType v, V out) Calculate the absolute values of the elements in vector v, saving the result to out.
static <V extends VectorWritable2FType & VectorReadable2FType> V	absoluteInPlace(V v) Calculate the absolute values of the elements in vector v, modifying the vector in-place.
static <V extends VectorWritable2FType> V	add(VectorReadable2FType v0, VectorReadable2FType v1, V out) Calculate the element-wise sum of the vectors v0 and v1, saving the result to out.
static <V extends VectorWritable2FType & VectorReadable2FType> V	addInPlace(V v0, VectorReadable2FType v1) Calculate the element-wise sum of the vectors v0 and v1, saving the result to v0.
static <V extends VectorWritable2FType> V	addScaled(VectorReadable2FType v0, VectorReadable2FType v1, double r, V 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 <V extends VectorWritable2FType & VectorReadable2FType> V	addScaledInPlace(V 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 <V extends VectorWritable2FType> V	clamp(VectorReadable2FType v, float minimum, float maximum, V out) Clamp the elements of the vector v to the range {@code [minimum ..
static <V extends VectorWritable2FType> V	clampByVector(VectorReadable2FType v, VectorReadable2FType minimum, VectorReadable2FType maximum, V 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 <V extends VectorWritable2FType & VectorReadable2FType> V	clampByVectorInPlace(V 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 <V extends VectorWritable2FType & VectorReadable2FType> V	clampInPlace(V v, float minimum, float maximum) Clamp the elements of the vector v to the range {@code [minimum ..
static <V extends VectorWritable2FType> V	clampMaximum(VectorReadable2FType v, float maximum, V out) Clamp the elements of the vector v to the range {@code [-Infinity ..
static <V extends VectorWritable2FType> V	clampMaximumByVector(VectorReadable2FType v, VectorReadable2FType maximum, V 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 <V extends VectorWritable2FType & VectorReadable2FType> V	clampMaximumByVectorInPlace(V 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 <V extends VectorWritable2FType & VectorReadable2FType> V	clampMaximumInPlace(V v, float maximum) Clamp the elements of the vector v to the range {@code [-Infinity ..
static <V extends VectorWritable2FType> V	clampMinimum(VectorReadable2FType v, float minimum, V out) Clamp the elements of the vector v to the range {@code [minimum ..
static <V extends VectorWritable2FType> V	clampMinimumByVector(VectorReadable2FType v, VectorReadable2FType minimum, V 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 <V extends VectorWritable2FType & VectorReadable2FType> V	clampMinimumByVectorInPlace(V 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 <V extends VectorWritable2FType & VectorReadable2FType> V	clampMinimumInPlace(V v, float minimum) Clamp the elements of the vector v to the range {@code [minimum ..
static <V extends VectorWritable2FType> V	copy(VectorReadable2FType input, V 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(VectorM2F.ContextVM2F c, 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 <V extends VectorWritable2FType> V	interpolateLinear(VectorM2F.ContextVM2F c, VectorReadable2FType v0, VectorReadable2FType v1, double alpha, V 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 <V extends VectorWritable2FType> V	normalize(VectorReadable2FType v, V out) Returns a vector with the same orientation as v but with magnitude equal to 1.0 in out.
static <V extends VectorWritable2FType & VectorReadable2FType> V	normalizeInPlace(V v) Returns a vector with the same orientation as v but with magnitude equal to 1.0 in v.
static <V extends VectorReadable2FType,U extends VectorWritable2FType> void	orthoNormalize(VectorM2F.ContextVM2F c, VectorReadable2FType v0, U v0_out, VectorReadable2FType v1, U v1_out) Orthonormalize and return the vectors v0 and v1 .
static <V extends VectorWritable2FType & VectorReadable2FType,W extends VectorWritable2FType & VectorReadable2FType> void	orthoNormalizeInPlace(VectorM2F.ContextVM2F c, V v0, W v1) Orthonormalize and the vectors v0 and v1.
static <V extends VectorWritable2FType> V	projection(VectorReadable2FType p, VectorReadable2FType q, V r) Calculate the projection of the vector p onto the vector q, saving the result in r.
static <V extends VectorWritable2FType> V	scale(VectorReadable2FType v, double r, V out) Scale the vector v by the scalar r, saving the result to out.
static <V extends VectorWritable2FType & VectorReadable2FType> V	scaleInPlace(V 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 <V extends VectorWritable2FType> V	subtract(VectorReadable2FType v0, VectorReadable2FType v1, V out) Subtract the vector v1 from the vector v0, saving the result to out.
static <V extends VectorWritable2FType & VectorReadable2FType> V	subtractInPlace(V 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 <V extends VectorWritable2FType> V absolute(VectorReadable2FType v,
                                                          V out)

Calculate the absolute values of the elements in vector v, saving the result to out.

Type Parameters:

V - The precise type of vector

Parameters:

v - The input vector

out - The output vector

Returns:

(abs v.x, abs v.y)

absoluteInPlace

public static <V extends VectorWritable2FType & VectorReadable2FType> V absoluteInPlace(V v)

Calculate the absolute values of the elements in vector v, modifying the vector in-place.

Type Parameters:

V - The precise type of vector

Parameters:

v - The input vector

Returns:

(abs v.x, abs v.y)

add

public static <V extends VectorWritable2FType> V add(VectorReadable2FType v0,
                                                     VectorReadable2FType v1,
                                                     V out)

Calculate the element-wise sum of the vectors v0 and v1, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V addInPlace(V v0,
                                                                                   VectorReadable2FType v1)

Calculate the element-wise sum of the vectors v0 and v1, saving the result to v0.

Type Parameters:

V - The precise type of vector

Parameters:

v0 - The left input vector

v1 - The right input vector

Returns:

(v0.x + v1.x, v0.y + v1.y)

addScaled

public static <V extends VectorWritable2FType> V addScaled(VectorReadable2FType v0,
                                                           VectorReadable2FType v1,
                                                           double r,
                                                           V out)

Calculate the element-wise sum of the vectors v0 and the element-wise product of v1 and r, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V addScaledInPlace(V 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.

Type Parameters:

V - The precise type of vector

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 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(AlmostEqualFloat.ContextRelative, float, float)

angle

public static 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 <V extends VectorWritable2FType> V clamp(VectorReadable2FType v,
                                                       float minimum,
                                                       float maximum,
                                                       V out)

Clamp the elements of the vector v to the range [minimum .. maximum] inclusive, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType> V clampByVector(VectorReadable2FType v,
                                                               VectorReadable2FType minimum,
                                                               VectorReadable2FType maximum,
                                                               V 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.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V clampByVectorInPlace(V 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.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V clampInPlace(V v,
                                                                                     float minimum,
                                                                                     float maximum)

Clamp the elements of the vector v to the range [minimum .. maximum] inclusive, saving the result to v.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType> V clampMaximum(VectorReadable2FType v,
                                                              float maximum,
                                                              V out)

Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType> V clampMaximumByVector(VectorReadable2FType v,
                                                                      VectorReadable2FType maximum,
                                                                      V out)

Clamp the elements of the vector v to the inclusive range given by the corresponding elements in maximum, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V clampMaximumByVectorInPlace(V 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.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V clampMaximumInPlace(V v,
                                                                                            float maximum)

Clamp the elements of the vector v to the range [-Infinity .. maximum] inclusive, saving the result to v.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType> V clampMinimum(VectorReadable2FType v,
                                                              float minimum,
                                                              V out)

Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType> V clampMinimumByVector(VectorReadable2FType v,
                                                                      VectorReadable2FType minimum,
                                                                      V out)

Clamp the elements of the vector v to the inclusive range given by the corresponding elements in minimum, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V clampMinimumByVectorInPlace(V 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.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V clampMinimumInPlace(V v,
                                                                                            float minimum)

Clamp the elements of the vector v to the range [minimum .. Infinity] inclusive, saving the result to v.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType> V copy(VectorReadable2FType input,
                                                      V output)

Copy all elements of the vector input to the vector output.

Type Parameters:

V - The precise type of vector

Parameters:

input - The input vector

output - The output vector

Returns:

output

distance

public static double distance(VectorM2F.ContextVM2F c,
                              VectorReadable2FType v0,
                              VectorReadable2FType v1)

Calculate the distance between the two vectors v0 and v1.

Parameters:

c - Preallocated storage

v0 - The left input vector

v1 - The right input vector

Returns:

The distance between the two vectors.

Since:

7.0.0

dotProduct

public static 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 <V extends VectorWritable2FType> V interpolateLinear(VectorM2F.ContextVM2F c,
                                                                   VectorReadable2FType v0,
                                                                   VectorReadable2FType v1,
                                                                   double alpha,
                                                                   V 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

Type Parameters:

V - The precise type of vector

Parameters:

c - Preallocated storage

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

Since:

7.0.0

magnitude

public static 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 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 <V extends VectorWritable2FType> V normalize(VectorReadable2FType v,
                                                           V 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.

Type Parameters:

V - The precise type of vector

Parameters:

v - The input vector

out - The output vector

Returns:

out

normalizeInPlace

public static <V extends VectorWritable2FType & VectorReadable2FType> V normalizeInPlace(V 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.

Type Parameters:

V - The precise type of vector

Parameters:

v - The input vector

Returns:

v

orthoNormalize

public static <V extends VectorReadable2FType,U extends VectorWritable2FType> void orthoNormalize(VectorM2F.ContextVM2F c,
                                                                                                  VectorReadable2FType v0,
                                                                                                  U v0_out,
                                                                                                  VectorReadable2FType v1,
                                                                                                  U v1_out)

Orthonormalize and return the vectors v0 and v1 .

See GSP

Type Parameters:

V - The precise type of readable vectors

U - The precise type of writable vectors

Parameters:

c - Preallocated storage

v0 - The left vector

v0_out - The orthonormalized form of v0

v1 - The right vector

v1_out - The orthonormalized form of v1

Since:

7.0.0

orthoNormalizeInPlace

public static <V extends VectorWritable2FType & VectorReadable2FType,W extends VectorWritable2FType & VectorReadable2FType> void orthoNormalizeInPlace(VectorM2F.ContextVM2F c,
                                                                                                                                                       V v0,
                                                                                                                                                       W v1)

Orthonormalize and the vectors v0 and v1.

See GSP

Type Parameters:

V - The precise type of readable/writable vector

W - The precise type of readable/writable vector

Parameters:

c - Preallocated storage

v0 - The left vector

v1 - The right vector

Since:

7.0.0

projection

public static <V extends VectorWritable2FType> V projection(VectorReadable2FType p,
                                                            VectorReadable2FType q,
                                                            V r)

Calculate the projection of the vector p onto the vector q, saving the result in r.

Type Parameters:

V - The precise type of vector

Parameters:

p - The left vector

q - The right vector

r - The output vector

Returns:

((dotProduct p q) / magnitudeSquared q) * q

scale

public static <V extends VectorWritable2FType> V scale(VectorReadable2FType v,
                                                       double r,
                                                       V out)

Scale the vector v by the scalar r, saving the result to out.

Type Parameters:

V - The precise type of vector

Parameters:

v - The input vector

r - The scaling value

out - The output vector

Returns:

(v.x * r, v.y * r)

scaleInPlace

public static <V extends VectorWritable2FType & VectorReadable2FType> V scaleInPlace(V v,
                                                                                     double r)

Scale the vector v by the scalar r, saving the result to v.

Type Parameters:

V - The precise type of vector

Parameters:

v - The input vector

r - The scaling value

Returns:

(v.x * r, v.y * r)

subtract

public static <V extends VectorWritable2FType> V subtract(VectorReadable2FType v0,
                                                          VectorReadable2FType v1,
                                                          V out)

Subtract the vector v1 from the vector v0, saving the result to out.

Type Parameters:

V - The precise type of vector

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 <V extends VectorWritable2FType & VectorReadable2FType> V subtractInPlace(V v0,
                                                                                        VectorReadable2FType v1)

Subtract the vector v1 from the vector v0, saving the result to v0.

Type Parameters:

V - The precise type of vector

Parameters:

v0 - The left input vector

v1 - The right input vector

Returns:

(v0.x - v1.x, v0.y - v1.y)

copyFrom2F

public 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 boolean equals(@Nullable
                      Object obj)

Overrides:

equals in class Object

getXF

public float getXF()

Specified by:

getXF in interface VectorReadable2FType

Returns:

The X value of the given vector.

setXF

public 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.

getYF

public float getYF()

Specified by:

getYF in interface VectorReadable2FType

Returns:

The Y value of the given vector.

setYF

public 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.

hashCode

public int hashCode()

Overrides:

hashCode in class Object

set2F

public 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.

toString

public String toString()

Overrides:

toString in class Object