com.io7m.jtensors.parameterized

Class PVectorM4D<T>

java.lang.Object

com.io7m.jtensors.parameterized.PVectorM4D<T>

Type Parameters:

T - A phantom type parameter

All Implemented Interfaces:

PVector2DType<T>, PVector3DType<T>, PVector4DType<T>, PVectorReadable2DType<T>, PVectorReadable3DType<T>, PVectorReadable4DType<T>, PVectorWritable2DType<T>, PVectorWritable3DType<T>, PVectorWritable4DType<T>, Vector2DType, Vector3DType, Vector4DType, VectorReadable2DType, VectorReadable3DType, VectorReadable4DType, VectorWritable2DType, VectorWritable3DType, VectorWritable4DType

public final class PVectorM4D<T>
extends Object
implements PVector4DType<T>

A four-dimensional mutable vector type with double elements.

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

Since:

7.0.0

Nested Class Summary

Nested Classes

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

Constructor Summary

Constructors

Constructor and Description
PVectorM4D() Default constructor, initializing the vector with values [0.0, 0.0, 0.0, 1.0].
PVectorM4D(double in_x, double in_y, double in_z, double in_w) Construct a vector initialized with the given values.
PVectorM4D(PVectorReadable4DType<T> in_v) Construct a vector initialized with the values given in the vector v.

Method Summary

Modifier and Type	Method and Description
static <T,V extends PVectorWritable4DType<T>> V	absolute(PVectorReadable4DType<T> v, V out) Calculate the absolute values of the elements in vector v, saving the result to out.
static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	absoluteInPlace(V v) Calculate the absolute values of the elements in vector v, modifying the vector in-place.
static <T,V extends PVectorWritable4DType<T>> V	add(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1, V out) Calculate the element-wise sum of the vectors v0 and v1, saving the result to out.
static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	addInPlace(V v0, PVectorReadable4DType<T> v1) Calculate the element-wise sum of the vectors v0 and v1, saving the result to v0.
static <T,V extends PVectorWritable4DType<T>> V	addScaled(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> 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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	addScaledInPlace(V v0, PVectorReadable4DType<T> 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 <T> boolean	almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context, PVectorReadable4DType<T> va, PVectorReadable4DType<T> vb) Determine whether or not the vectors va and vb are equal to within the degree of error given in context.
static <T,V extends PVectorWritable4DType<T>> V	clamp(PVectorReadable4DType<T> v, double minimum, double maximum, V out) Clamp the elements of the vector v to the range {@code [minimum ..
static <T,V extends PVectorWritable4DType<T>> V	clampByPVector(PVectorReadable4DType<T> v, PVectorReadable4DType<T> minimum, PVectorReadable4DType<T> 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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	clampByPVectorInPlace(V v, PVectorReadable4DType<T> minimum, PVectorReadable4DType<T> 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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	clampInPlace(V v, double minimum, double maximum) Clamp the elements of the vector v to the range {@code [minimum ..
static <T,V extends PVectorWritable4DType<T>> V	clampMaximum(PVectorReadable4DType<T> v, double maximum, V out) Clamp the elements of the vector v to the range {@code [-Infinity ..
static <T,V extends PVectorWritable4DType<T>> V	clampMaximumByPVector(PVectorReadable4DType<T> v, PVectorReadable4DType<T> 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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	clampMaximumByPVectorInPlace(V v, PVectorReadable4DType<T> 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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	clampMaximumInPlace(V v, double maximum) Clamp the elements of the vector v to the range {@code [-Infinity ..
static <T,V extends PVectorWritable4DType<T>> V	clampMinimum(PVectorReadable4DType<T> v, double minimum, V out) Clamp the elements of the vector v to the range {@code [minimum ..
static <T,V extends PVectorWritable4DType<T>> V	clampMinimumByPVector(PVectorReadable4DType<T> v, PVectorReadable4DType<T> 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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	clampMinimumByPVectorInPlace(V v, PVectorReadable4DType<T> 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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	clampMinimumInPlace(V v, double minimum) Clamp the elements of the vector v to the range {@code [minimum ..
static <T,V extends PVectorWritable4DType<T>> V	copy(PVectorReadable4DType<T> input, V output) Copy all elements of the vector input to the vector output.
void	copyFrom2D(VectorReadable2DType in_v) Set the current vector to the contents of the input vector.
void	copyFrom3D(VectorReadable3DType in_v) Set the current vector to the contents of the input vector.
void	copyFrom4D(VectorReadable4DType in_v) Set the current vector to the contents of the input vector.
void	copyFromTyped2D(PVectorReadable2DType<T> in_v) Set the current vector to the contents of the input vector.
void	copyFromTyped3D(PVectorReadable3DType<T> in_v) Set the current vector to the contents of the input vector.
void	copyFromTyped4D(PVectorReadable4DType<T> in_v) Set the current vector to the contents of the input vector.
static <T> double	distance(PVectorM4D.ContextPVM4D c, PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1) Calculate the distance between the two vectors v0 and v1.
static <T> double	dotProduct(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1) Calculate the scalar product of the vectors v0 and v1.
boolean	equals(Object obj)
double	getWD()
double	getXD()
double	getYD()
double	getZD()
int	hashCode()
static <T,V extends PVectorWritable4DType<T>> V	interpolateLinear(PVectorM4D.ContextPVM4D c, PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1, double alpha, V r) Linearly interpolate between v0 and v1 by the amount alpha, saving the result to r.
static <T> double	magnitude(PVectorReadable4DType<T> v) Calculate the magnitude of the vector v.
static <T> double	magnitudeSquared(PVectorReadable4DType<T> v) Calculate the squared magnitude of the vector v.
static <T,V extends PVectorWritable4DType<T>> V	normalize(PVectorReadable4DType<T> v, V out) Returns a vector with the same orientation as v but with magnitude equal to 1.0 in out.
static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	normalizeInPlace(V v) Returns a vector with the same orientation as v but with magnitude equal to 1.0 in v.
static <T,V extends PVectorWritable4DType<T>> void	orthoNormalize(PVectorM4D.ContextPVM4D c, PVectorReadable4DType<T> v0, V v0_out, PVectorReadable4DType<T> v1, V v1_out) Orthonormalize and return the vectors v0 and v1 .
static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> void	orthoNormalizeInPlace(PVectorM4D.ContextPVM4D c, V v0, V v1) Orthonormalize and the vectors v0 and v1.
static <T,V extends PVectorWritable4DType<T>> V	projection(PVectorReadable4DType<T> p, PVectorReadable4DType<T> q, V r) Calculate the projection of the vector p onto the vector q, saving the result in r.
static <T,V extends PVectorWritable4DType<T>> V	scale(PVectorReadable4DType<T> v, double r, V out) Scale the vector v by the scalar r, saving the result to out.
static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	scaleInPlace(V v, double r) Scale the vector v by the scalar r, saving the result to v.
void	set2D(double in_x, double in_y) Set the current x and y values of the current vector.
void	set3D(double in_x, double in_y, double in_z) Set the current x, y and z values of the current vector.
void	set4D(double in_x, double in_y, double in_z, double in_w) Set the current x, y, z and w values of the current vector.
void	setWD(double in_w) Set the current w value of the current vector.
void	setXD(double in_x) Set the current x value of the current vector.
void	setYD(double in_y) Set the current y value of the current vector.
void	setZD(double in_z) Set the current z value of the current vector.
static <T,V extends PVectorWritable4DType<T>> V	subtract(PVectorReadable4DType<T> v0, PVectorReadable4DType<T> v1, V out) Subtract the vector v1 from the vector v0, saving the result to out.
static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V	subtractInPlace(V v0, PVectorReadable4DType<T> 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

PVectorM4D

public PVectorM4D()

Default constructor, initializing the vector with values [0.0, 0.0, 0.0, 1.0].

PVectorM4D

public PVectorM4D(double in_x,
                  double in_y,
                  double in_z,
                  double in_w)

Construct a vector initialized with the given values.

Parameters:

in_x - The x value

in_y - The y value

in_z - The z value

in_w - The w value

PVectorM4D

public PVectorM4D(PVectorReadable4DType<T> in_v)

Construct a vector initialized with the values given in the vector v.

Parameters:

in_v - The source vector

Method Detail

absolute

public static <T,V extends PVectorWritable4DType<T>> V absolute(PVectorReadable4DType<T> v,
                                                                V out)

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

Type Parameters:

T - A phantom type parameter

V - The precise type of vector

Parameters:

v - The input vector

out - The output vector

Returns:

(abs v.x, abs v.y, abs v.z, abs.w)

absoluteInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V absoluteInPlace(V v)

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

Type Parameters:

T - A phantom type parameter

V - The precise type of vector

Parameters:

v - The input vector

Returns:

(abs v.x, abs v.y, abs v.z, abs v.w)

add

public static <T,V extends PVectorWritable4DType<T>> V add(PVectorReadable4DType<T> v0,
                                                           PVectorReadable4DType<T> v1,
                                                           V out)

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

Type Parameters:

T - A phantom type parameter

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, v0.z + v1.z, v0.w + v1.w)

addInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V addInPlace(V v0,
                                                                                             PVectorReadable4DType<T> v1)

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

Type Parameters:

T - A phantom type parameter

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, v0.z + v1.z, v0.w + v1.w)

addScaled

public static <T,V extends PVectorWritable4DType<T>> V addScaled(PVectorReadable4DType<T> v0,
                                                                 PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), v0.z + (v1.z * r), v0.w + (v1.w * r))

addScaledInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V addScaledInPlace(V v0,
                                                                                                   PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), v0.z + (v1.z * r), v0.w + (v1.w * r))

almostEqual

public static <T> boolean almostEqual(com.io7m.jequality.AlmostEqualDouble.ContextRelative context,
                                      PVectorReadable4DType<T> va,
                                      PVectorReadable4DType<T> vb)

Determine whether or not the vectors va and vb are equal to within the degree of error given in context.

Type Parameters:

T - A phantom type parameter

Parameters:

context - The equality context

va - The left input vector

vb - The right input vector

Returns:

true if the vectors are almost equal

Since:

7.0.0

See Also:

AlmostEqualDouble.almostEqual(AlmostEqualDouble.ContextRelative, double, double)

clamp

public static <T,V extends PVectorWritable4DType<T>> V clamp(PVectorReadable4DType<T> v,
                                                             double minimum,
                                                             double maximum,
                                                             V out)

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

Type Parameters:

T - A phantom type parameter

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

clampByPVector

public static <T,V extends PVectorWritable4DType<T>> V clampByPVector(PVectorReadable4DType<T> v,
                                                                      PVectorReadable4DType<T> minimum,
                                                                      PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), min(max(v.z, minimum.z), maximum.z), min(max(v.w, minimum.w), maximum.w))

clampByPVectorInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V clampByPVectorInPlace(V v,
                                                                                                        PVectorReadable4DType<T> minimum,
                                                                                                        PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), min(max(v.z, minimum.z), maximum.z), min(max(v.w, minimum.w), maximum.w))

clampInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V clampInPlace(V v,
                                                                                               double minimum,
                                                                                               double maximum)

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

Type Parameters:

T - A phantom type parameter

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 <T,V extends PVectorWritable4DType<T>> V clampMaximum(PVectorReadable4DType<T> v,
                                                                    double maximum,
                                                                    V out)

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

Type Parameters:

T - A phantom type parameter

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

clampMaximumByPVector

public static <T,V extends PVectorWritable4DType<T>> V clampMaximumByPVector(PVectorReadable4DType<T> v,
                                                                             PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), min(v.z, maximum.z), min(v.w, maximum.w))

clampMaximumByPVectorInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V clampMaximumByPVectorInPlace(V v,
                                                                                                               PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), min(v.z, maximum.z), min(v.w, maximum.w))

clampMaximumInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V clampMaximumInPlace(V v,
                                                                                                      double maximum)

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

Type Parameters:

T - A phantom type parameter

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 <T,V extends PVectorWritable4DType<T>> V clampMinimum(PVectorReadable4DType<T> v,
                                                                    double minimum,
                                                                    V out)

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

Type Parameters:

T - A phantom type parameter

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

clampMinimumByPVector

public static <T,V extends PVectorWritable4DType<T>> V clampMinimumByPVector(PVectorReadable4DType<T> v,
                                                                             PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), max(v.z, minimum.z), max(v.w, minimum.w))

clampMinimumByPVectorInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V clampMinimumByPVectorInPlace(V v,
                                                                                                               PVectorReadable4DType<T> 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:

T - A phantom type parameter

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), max(v.z, minimum.z), max(v.w, minimum.w)) , in v

clampMinimumInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V clampMinimumInPlace(V v,
                                                                                                      double minimum)

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

Type Parameters:

T - A phantom type parameter

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 <T,V extends PVectorWritable4DType<T>> V copy(PVectorReadable4DType<T> input,
                                                            V output)

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

Type Parameters:

T - A phantom type parameter

V - The precise type of vector

Parameters:

input - The input vector

output - The output vector

Returns:

output

distance

public static <T> double distance(PVectorM4D.ContextPVM4D c,
                                  PVectorReadable4DType<T> v0,
                                  PVectorReadable4DType<T> v1)

Calculate the distance between the two vectors v0 and v1.

Type Parameters:

T - A phantom type parameter

Parameters:

c - Preallocated storage

v0 - The left input vector

v1 - The right input vector

Returns:

The distance between the two vectors.

dotProduct

public static <T> double dotProduct(PVectorReadable4DType<T> v0,
                                    PVectorReadable4DType<T> v1)

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

interpolateLinear

public static <T,V extends PVectorWritable4DType<T>> V interpolateLinear(PVectorM4D.ContextPVM4D c,
                                                                         PVectorReadable4DType<T> v0,
                                                                         PVectorReadable4DType<T> 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:

T - A phantom type parameter

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 <T> double magnitude(PVectorReadable4DType<T> v)

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

magnitudeSquared

public static <T> double magnitudeSquared(PVectorReadable4DType<T> v)

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

normalize

public static <T,V extends PVectorWritable4DType<T>> V normalize(PVectorReadable4DType<T> 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:

T - A phantom type parameter

V - The precise type of vector

Parameters:

v - The input vector

out - The output vector

Returns:

out

normalizeInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> 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:

T - A phantom type parameter

V - The precise type of vector

Parameters:

v - The input vector

Returns:

v

orthoNormalize

public static <T,V extends PVectorWritable4DType<T>> void orthoNormalize(PVectorM4D.ContextPVM4D c,
                                                                         PVectorReadable4DType<T> v0,
                                                                         V v0_out,
                                                                         PVectorReadable4DType<T> v1,
                                                                         V v1_out)

Orthonormalize and return the vectors v0 and v1 .

See GSP

Type Parameters:

T - A phantom type parameter

V - The precise type of vector

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 <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> void orthoNormalizeInPlace(PVectorM4D.ContextPVM4D c,
                                                                                                           V v0,
                                                                                                           V v1)

Orthonormalize and the vectors v0 and v1.

See GSP

Type Parameters:

V - The precise type of vector

T - A phantom type parameter

Parameters:

c - Preallocated storage

v0 - The left vector

v1 - The right vector

Since:

7.0.0

projection

public static <T,V extends PVectorWritable4DType<T>> V projection(PVectorReadable4DType<T> p,
                                                                  PVectorReadable4DType<T> q,
                                                                  V r)

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

Type Parameters:

T - A phantom type parameter

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 <T,V extends PVectorWritable4DType<T>> V scale(PVectorReadable4DType<T> v,
                                                             double r,
                                                             V out)

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

Type Parameters:

T - A phantom type parameter

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, v.z * r, v.w * r)

scaleInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V scaleInPlace(V v,
                                                                                               double r)

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

Type Parameters:

T - A phantom type parameter

V - The precise type of vector

Parameters:

v - The input vector

r - The scaling value

Returns:

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

subtract

public static <T,V extends PVectorWritable4DType<T>> V subtract(PVectorReadable4DType<T> v0,
                                                                PVectorReadable4DType<T> v1,
                                                                V out)

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

Type Parameters:

T - A phantom type parameter

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, v0.z - v1.z, v0.w - v1.w)

subtractInPlace

public static <T,V extends PVectorWritable4DType<T> & PVectorReadable4DType<T>> V subtractInPlace(V v0,
                                                                                                  PVectorReadable4DType<T> v1)

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

Type Parameters:

T - A phantom type parameter

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, v0.z - v1.z, v0.w - v1.w)

copyFrom2D

public void copyFrom2D(VectorReadable2DType in_v)

Description copied from interface: VectorWritable2DType

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

Specified by:

copyFrom2D in interface VectorWritable2DType

Parameters:

in_v - The input vector

copyFrom3D

public void copyFrom3D(VectorReadable3DType in_v)

Description copied from interface: VectorWritable3DType

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

Specified by:

copyFrom3D in interface VectorWritable3DType

Parameters:

in_v - The input vector

copyFrom4D

public void copyFrom4D(VectorReadable4DType in_v)

Description copied from interface: VectorWritable4DType

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

Specified by:

copyFrom4D in interface VectorWritable4DType

Parameters:

in_v - The input vector

copyFromTyped2D

public void copyFromTyped2D(PVectorReadable2DType<T> in_v)

Description copied from interface: PVectorWritable2DType

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

Specified by:

copyFromTyped2D in interface PVectorWritable2DType<T>

Parameters:

in_v - The input vector

copyFromTyped3D

public void copyFromTyped3D(PVectorReadable3DType<T> in_v)

Description copied from interface: PVectorWritable3DType

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

Specified by:

copyFromTyped3D in interface PVectorWritable3DType<T>

Parameters:

in_v - The input vector

copyFromTyped4D

public void copyFromTyped4D(PVectorReadable4DType<T> in_v)

Description copied from interface: PVectorWritable4DType

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

Specified by:

copyFromTyped4D in interface PVectorWritable4DType<T>

Parameters:

in_v - The input vector

equals

public boolean equals(@Nullable
                      Object obj)

Overrides:

equals in class Object

getWD

public double getWD()

Specified by:

getWD in interface VectorReadable4DType

Returns:

The W value of the given vector.

setWD

public void setWD(double in_w)

Description copied from interface: VectorWritable4DType

Set the current w value of the current vector.

Specified by:

setWD in interface VectorWritable4DType

Parameters:

in_w - The new w value.

getXD

public double getXD()

Specified by:

getXD in interface VectorReadable2DType

Returns:

The X value of the given vector.

setXD

public void setXD(double in_x)

Description copied from interface: VectorWritable2DType

Set the current x value of the current vector.

Specified by:

setXD in interface VectorWritable2DType

Parameters:

in_x - The new x value.

getYD

public double getYD()

Specified by:

getYD in interface VectorReadable2DType

Returns:

The Y value of the given vector.

setYD

public void setYD(double in_y)

Description copied from interface: VectorWritable2DType

Set the current y value of the current vector.

Specified by:

setYD in interface VectorWritable2DType

Parameters:

in_y - The new y value.

getZD

public double getZD()

Specified by:

getZD in interface VectorReadable3DType

Returns:

The Z value of the given vector.

setZD

public void setZD(double in_z)

Description copied from interface: VectorWritable3DType

Set the current z value of the current vector.

Specified by:

setZD in interface VectorWritable3DType

Parameters:

in_z - The new z value.

hashCode

public int hashCode()

Overrides:

hashCode in class Object

set2D

public void set2D(double in_x,
                  double in_y)

Description copied from interface: VectorWritable2DType

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

Specified by:

set2D in interface VectorWritable2DType

Parameters:

in_x - The new x value.

in_y - The new y value.

set3D

public void set3D(double in_x,
                  double in_y,
                  double in_z)

Description copied from interface: VectorWritable3DType

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

Specified by:

set3D in interface VectorWritable3DType

Parameters:

in_x - The new x value.

in_y - The new y value.

in_z - The new z value.

set4D

public void set4D(double in_x,
                  double in_y,
                  double in_z,
                  double in_w)

Description copied from interface: VectorWritable4DType

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

Specified by:

set4D in interface VectorWritable4DType

Parameters:

in_x - The new x value.

in_y - The new y value.

in_z - The new z value.

in_w - The new w value.

toString

public String toString()

Overrides:

toString in class Object