com.io7m.jtensors

Class VectorM4L

java.lang.Object

com.io7m.jtensors.VectorM4L

All Implemented Interfaces:

Vector2LType, Vector3LType, Vector4LType, VectorReadable2LType, VectorReadable3LType, VectorReadable4LType, VectorWritable2LType, VectorWritable3LType, VectorWritable4LType

public final class VectorM4L
extends Object
implements Vector4LType

A four-dimensional mutable vector type with integer elements.

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

Since:

5.3.0

Nested Class Summary

Nested Classes

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

Constructor Summary

Constructors

Constructor and Description
VectorM4L() Default constructor, initializing the vector with values [0, 0, 0, 1].
VectorM4L(long in_x, long in_y, long in_z, long in_w) Construct a vector initialized with the given values.
VectorM4L(VectorReadable4LType 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 VectorWritable4LType> V	absolute(VectorReadable4LType v, V out) Calculate the absolute values of the elements in vector v, saving the result to out.
static <V extends VectorWritable4LType & VectorReadable4LType> V	absoluteInPlace(V v) Calculate the absolute values of the elements in vector v, saving the result to v.
static <V extends VectorWritable4LType> V	add(VectorReadable4LType v0, VectorReadable4LType v1, V out) Calculate the element-wise sum of the vectors v0 and v1, saving the result to out.
static <V extends VectorWritable4LType & VectorReadable4LType> V	addInPlace(V v0, VectorReadable4LType v1) Calculate the element-wise sum of the vectors v0 and v1, saving the result to v0.
static <V extends VectorWritable4LType> V	addScaled(VectorReadable4LType v0, VectorReadable4LType 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 VectorWritable4LType & VectorReadable4LType> V	addScaledInPlace(V v0, VectorReadable4LType 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 <V extends VectorWritable4LType> V	clamp(VectorReadable4LType v, long minimum, long maximum, V out) Clamp the elements of the vector v to the range {@code [minimum ..
static <V extends VectorWritable4LType> V	clampByVector(VectorReadable4LType v, VectorReadable4LType minimum, VectorReadable4LType 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 VectorWritable4LType & VectorReadable4LType> V	clampByVectorInPlace(V v, VectorReadable4LType minimum, VectorReadable4LType 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 VectorWritable4LType & VectorReadable4LType> V	clampInPlace(V v, long minimum, long maximum) Clamp the elements of the vector v to the range {@code [minimum ..
static <V extends VectorWritable4LType> V	clampMaximum(VectorReadable4LType v, long maximum, V out) Clamp the elements of the vector v to the range {@code [-Infinity ..
static <V extends VectorWritable4LType> V	clampMaximumByVector(VectorReadable4LType v, VectorReadable4LType 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 VectorWritable4LType & VectorReadable4LType> V	clampMaximumByVectorInPlace(V v, VectorReadable4LType 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 VectorWritable4LType & VectorReadable4LType> V	clampMaximumInPlace(V v, long maximum) Clamp the elements of the vector v to the range {@code [-Infinity ..
static <V extends VectorWritable4LType> V	clampMinimum(VectorReadable4LType v, long minimum, V out) Clamp the elements of the vector v to the range {@code [minimum ..
static <V extends VectorWritable4LType> V	clampMinimumByVector(VectorReadable4LType v, VectorReadable4LType 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 VectorWritable4LType & VectorReadable4LType> V	clampMinimumByVectorInPlace(V v, VectorReadable4LType 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 VectorWritable4LType & VectorReadable4LType> V	clampMinimumInPlace(V v, long minimum) Clamp the elements of the vector v to the range {@code [minimum ..
static <T extends VectorWritable4LType> T	copy(VectorReadable4LType input, T output) Copy all elements of the vector input to the vector output.
void	copyFrom2L(VectorReadable2LType in_v) Set the current vector to the contents of the input vector.
void	copyFrom3L(VectorReadable3LType in_v) Set the current vector to the contents of the input vector.
void	copyFrom4L(VectorReadable4LType in_v) Set the current vector to the contents of the input vector.
static long	distance(VectorM4L.ContextVM4L c, VectorReadable4LType v0, VectorReadable4LType v1) Calculate the distance between the two vectors v0 and v1.
static long	dotProduct(VectorReadable4LType v0, VectorReadable4LType v1) Calculate the scalar product of the vectors v0 and v1.
boolean	equals(Object obj)
long	getWL()
long	getXL()
long	getYL()
long	getZL()
int	hashCode()
static <V extends VectorWritable4LType> V	interpolateLinear(VectorM4L.ContextVM4L c, VectorReadable4LType v0, VectorReadable4LType v1, double alpha, V r) Linearly interpolate between v0 and v1 by the amount alpha, saving the result to r.
static long	magnitude(VectorReadable4LType v) Calculate the magnitude of the vector v.
static long	magnitudeSquared(VectorReadable4LType v) Calculate the squared magnitude of the vector v.
static <V extends VectorWritable4LType> V	projection(VectorReadable4LType p, VectorReadable4LType q, V r) Calculate the projection of the vector p onto the vector q, saving the result in r.
static <V extends VectorWritable4LType> V	scale(VectorReadable4LType v, double r, V out) Scale the vector v by the scalar r, saving the result to out.
static <V extends VectorWritable4LType & VectorReadable4LType> V	scaleInPlace(V v, long r) Scale the vector v by the scalar r, saving the result to v.
void	set2L(long in_x, long in_y) Set the current x and y values of the current vector.
void	set3L(long in_x, long in_y, long in_z) Set the current x, y and z values of the current vector.
void	set4L(long in_x, long in_y, long in_z, long in_w) Set the current x, y, z and w values of the current vector.
void	setWL(long in_w) Set the current w value of the current vector.
void	setXL(long in_x) Set the current x value of the current vector.
void	setYL(long in_y) Set the current y value of the current vector.
void	setZL(long in_z) Set the current z value of the current vector.
static <V extends VectorWritable4LType> V	subtract(VectorReadable4LType v0, VectorReadable4LType v1, V out) Subtract the vector v1 from the vector v0, saving the result to out.
static <V extends VectorWritable4LType & VectorReadable4LType> V	subtractInPlace(V v0, VectorReadable4LType 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

VectorM4L

public VectorM4L()

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

VectorM4L

public VectorM4L(long in_x,
                 long in_y,
                 long in_z,
                 long 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

VectorM4L

public VectorM4L(VectorReadable4LType 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 VectorWritable4LType> V absolute(VectorReadable4LType v,
                                                          V out)
                                                   throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

absoluteInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V absoluteInPlace(V v)
                                                                                 throws ArithmeticException

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

Type Parameters:

V - The precise type of vector

Parameters:

v - The input vector

Returns:

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

add

public static <V extends VectorWritable4LType> V add(VectorReadable4LType v0,
                                                     VectorReadable4LType v1,
                                                     V out)
                                              throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

addInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V addInPlace(V v0,
                                                                                   VectorReadable4LType v1)
                                                                            throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

addScaled

public static <V extends VectorWritable4LType> V addScaled(VectorReadable4LType v0,
                                                           VectorReadable4LType v1,
                                                           double r,
                                                           V 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.

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

addScaledInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V addScaledInPlace(V v0,
                                                                                         VectorReadable4LType 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.

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

clamp

public static <V extends VectorWritable4LType> V clamp(VectorReadable4LType v,
                                                       long minimum,
                                                       long 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 VectorWritable4LType> V clampByVector(VectorReadable4LType v,
                                                               VectorReadable4LType minimum,
                                                               VectorReadable4LType 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), min(max(v.z, minimum.z), maximum.z), min(max(v.w, minimum.w), maximum.w))

clampByVectorInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V clampByVectorInPlace(V v,
                                                                                             VectorReadable4LType minimum,
                                                                                             VectorReadable4LType 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), min(max(v.z, minimum.z), maximum.z), min(max(v.w, minimum.w), maximum.w))

clampInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V clampInPlace(V v,
                                                                                     long minimum,
                                                                                     long 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 VectorWritable4LType> V clampMaximum(VectorReadable4LType v,
                                                              long 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 VectorWritable4LType> V clampMaximumByVector(VectorReadable4LType v,
                                                                      VectorReadable4LType 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), min(v.z, maximum.z), min(v.w, maximum.w))

clampMaximumByVectorInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V clampMaximumByVectorInPlace(V v,
                                                                                                    VectorReadable4LType 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), min(v.z, maximum.z), min(v.w, maximum.w))

clampMaximumInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V clampMaximumInPlace(V v,
                                                                                            long 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 VectorWritable4LType> V clampMinimum(VectorReadable4LType v,
                                                              long 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 VectorWritable4LType> V clampMinimumByVector(VectorReadable4LType v,
                                                                      VectorReadable4LType 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), max(v.z, minimum.z), max(v.w, minimum.w))

clampMinimumByVectorInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V clampMinimumByVectorInPlace(V v,
                                                                                                    VectorReadable4LType 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), max(v.z, minimum.z), max(v.w, minimum.w)) , in v

clampMinimumInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V clampMinimumInPlace(V v,
                                                                                            long 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 <T extends VectorWritable4LType> T copy(VectorReadable4LType input,
                                                      T output)

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

Type Parameters:

T - The specific vector type

Parameters:

input - The input vector

output - The output vector

Returns:

output

distance

public static long distance(VectorM4L.ContextVM4L c,
                            VectorReadable4LType v0,
                            VectorReadable4LType v1)
                     throws ArithmeticException

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.

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

dotProduct

public static long dotProduct(VectorReadable4LType v0,
                              VectorReadable4LType 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 <V extends VectorWritable4LType> V interpolateLinear(VectorM4L.ContextVM4L c,
                                                                   VectorReadable4LType v0,
                                                                   VectorReadable4LType 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 long magnitude(VectorReadable4LType 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 long magnitudeSquared(VectorReadable4LType 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 <V extends VectorWritable4LType> V projection(VectorReadable4LType p,
                                                            VectorReadable4LType q,
                                                            V r)
                                                     throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

scale

public static <V extends VectorWritable4LType> V scale(VectorReadable4LType v,
                                                       double r,
                                                       V out)
                                                throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

scaleInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V scaleInPlace(V v,
                                                                                     long r)
                                                                              throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

subtract

public static <V extends VectorWritable4LType> V subtract(VectorReadable4LType v0,
                                                          VectorReadable4LType v1,
                                                          V out)
                                                   throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

subtractInPlace

public static <V extends VectorWritable4LType & VectorReadable4LType> V subtractInPlace(V v0,
                                                                                        VectorReadable4LType v1)
                                                                                 throws ArithmeticException

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

Throws:

ArithmeticException - Iff an internal arithmetic operation causes an integer overflow

copyFrom2L

public void copyFrom2L(VectorReadable2LType in_v)

Description copied from interface: VectorWritable2LType

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

Specified by:

copyFrom2L in interface VectorWritable2LType

Parameters:

in_v - The input vector

copyFrom3L

public void copyFrom3L(VectorReadable3LType in_v)

Description copied from interface: VectorWritable3LType

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

Specified by:

copyFrom3L in interface VectorWritable3LType

Parameters:

in_v - The input vector

copyFrom4L

public void copyFrom4L(VectorReadable4LType in_v)

Description copied from interface: VectorWritable4LType

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

Specified by:

copyFrom4L in interface VectorWritable4LType

Parameters:

in_v - The input vector

equals

public boolean equals(@Nullable
                      Object obj)

Overrides:

equals in class Object

getWL

public long getWL()

Specified by:

getWL in interface VectorReadable4LType

Returns:

The W value of the given vector.

setWL

public void setWL(long in_w)

Description copied from interface: VectorWritable4LType

Set the current w value of the current vector.

Specified by:

setWL in interface VectorWritable4LType

Parameters:

in_w - The new w value.

getXL

public long getXL()

Specified by:

getXL in interface VectorReadable2LType

Returns:

The X value of the given vector.

setXL

public void setXL(long in_x)

Description copied from interface: VectorWritable2LType

Set the current x value of the current vector.

Specified by:

setXL in interface VectorWritable2LType

Parameters:

in_x - The new x value.

getYL

public long getYL()

Specified by:

getYL in interface VectorReadable2LType

Returns:

The Y value of the given vector.

setYL

public void setYL(long in_y)

Description copied from interface: VectorWritable2LType

Set the current y value of the current vector.

Specified by:

setYL in interface VectorWritable2LType

Parameters:

in_y - The new y value.

getZL

public long getZL()

Specified by:

getZL in interface VectorReadable3LType

Returns:

The Z value of the given vector.

setZL

public void setZL(long in_z)

Description copied from interface: VectorWritable3LType

Set the current z value of the current vector.

Specified by:

setZL in interface VectorWritable3LType

Parameters:

in_z - The new z value.

hashCode

public int hashCode()

Overrides:

hashCode in class Object

set2L

public void set2L(long in_x,
                  long in_y)

Description copied from interface: VectorWritable2LType

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

Specified by:

set2L in interface VectorWritable2LType

Parameters:

in_x - The new x value.

in_y - The new y value.

set3L

public void set3L(long in_x,
                  long in_y,
                  long in_z)

Description copied from interface: VectorWritable3LType

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

Specified by:

set3L in interface VectorWritable3LType

Parameters:

in_x - The new x value.

in_y - The new y value.

in_z - The new z value.

set4L

public void set4L(long in_x,
                  long in_y,
                  long in_z,
                  long in_w)

Description copied from interface: VectorWritable4LType

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

Specified by:

set4L in interface VectorWritable4LType

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