com.io7m.jtensors

Class QuaternionI4F

java.lang.Object

com.io7m.jtensors.QuaternionI4F

All Implemented Interfaces:

QuaternionReadable4FType, VectorReadable2FType, VectorReadable3FType, VectorReadable4FType

@EqualityStructural
 @Immutable
public final class QuaternionI4F
extends Object
implements QuaternionReadable4FType

A four-dimensional immutable quaternion type with float elements.

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

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	QuaternionI4F.ContextQI4F The ContextQM4F type contains the minimum storage required for all of the functions of the QuaternionM4F class.

Field Summary

Fields

Modifier and Type	Field and Description
static QuaternionI4F	IDENTITY The "identity" quaternion, [0.0 0.0 0.0 1.0]

Constructor Summary

Constructors

Constructor and Description
QuaternionI4F() Default constructor, initializing the quaternion with values [0.0, 0.0, 0.0, 1.0]
QuaternionI4F(float in_x, float in_y, float in_z, float in_w) Construct a quaternion initialized with the given values.
QuaternionI4F(QuaternionReadable4FType q) Construct a quaternion initialized with the values contained in q.

Method Summary

Modifier and Type	Method and Description
static QuaternionI4F	add(QuaternionReadable4FType q0, QuaternionReadable4FType q1) Calculate the element-wise sum of the quaternions q0 and q1.
static boolean	almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb) Determine whether or not the quaternions qa and qb are equal to within the degree of error given in context.
static QuaternionI4F	conjugate(QuaternionReadable4FType q) Calculate the conjugate of the input quaternion q.
static float	dotProduct(QuaternionReadable4FType q0, QuaternionReadable4FType q1) Calculate the scalar product of the quaternions q0 and q1.
boolean	equals(Object obj)
float	getWF()
float	getXF()
float	getYF()
float	getZF()
int	hashCode()
static QuaternionI4F	interpolateLinear(QuaternionReadable4FType q0, QuaternionReadable4FType q1, float alpha) Linearly interpolate between q0 and q1 by the amount alpha, such that: interpolateLinear(q0, q1, 0.0) = q0 interpolateLinear(q0, q1, 1.0) = q1
static boolean	isNegationOf(com.io7m.jequality.AlmostEqualFloat.ContextRelative context, QuaternionReadable4FType qa, QuaternionReadable4FType qb) Return true iff qa is the negation of qb.
static QuaternionI4F	lookAtWithContext(QuaternionI4F.ContextQI4F context, VectorReadable3FType origin, VectorReadable3FType target, VectorReadable3FType up) Produce a quaternion that represents a rotation that "looks at" the point at target assuming the viewer is at origin, using up as the "up" vector.
static float	magnitude(QuaternionReadable4FType q) Calculate the magnitude of the quaternion q.
static float	magnitudeSquared(QuaternionReadable4FType q) Calculate the squared magnitude of the quaternion q.
static QuaternionI4F	makeFromAxisAngle(VectorReadable3FType axis, double angle) Produce a quaternion that represents a rotation of angle degrees around the axis specified by axis.
static QuaternionI4F	makeFromRotationMatrix3x3(MatrixReadable3x3FType m) Produce a quaternion equivalent to the rotation matrix m.
static QuaternionI4F	makeFromRotationMatrix4x4(MatrixReadable4x4FType m) Produce a quaternion equivalent to the rotation matrix m, writing the result to out.
static <M extends MatrixWritable3x3FType> M	makeRotationMatrix3x3(QuaternionReadable4FType q, M m) Produce a rotation matrix from the quaternion q, saving the result to m.
static <M extends MatrixWritable4x4FType> M	makeRotationMatrix4x4(QuaternionReadable4FType q, M m) Produce a rotation matrix from the quaternion q, saving the result to m.
static QuaternionI4F	multiply(QuaternionReadable4FType q0, QuaternionReadable4FType q1) Multiply the quaternion q0 by the quaternion q1 .
static QuaternionI4F	negate(QuaternionReadable4FType q) Negate the elements of q.
static QuaternionI4F	normalize(QuaternionReadable4FType q) Normalize the quaternion q, preserqing its direction but reducing it to unit length.
static QuaternionI4F	scale(QuaternionReadable4FType q, float r) Scale the quaternion q by the scalar r.
static QuaternionI4F	subtract(QuaternionReadable4FType q0, QuaternionReadable4FType q1) Subtract the quaternion q0 from the quaternion q1.
String	toString()

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Field Detail

IDENTITY

public static final QuaternionI4F IDENTITY

The "identity" quaternion, [0.0 0.0 0.0 1.0]

Constructor Detail

QuaternionI4F

public QuaternionI4F()

Default constructor, initializing the quaternion with values [0.0, 0.0, 0.0, 1.0]

QuaternionI4F

public QuaternionI4F(float in_x,
                     float in_y,
                     float in_z,
                     float in_w)

Construct a quaternion 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

QuaternionI4F

public QuaternionI4F(QuaternionReadable4FType q)

Construct a quaternion initialized with the values contained in q.

Parameters:

q - The source quaternion

Method Detail

add

public static QuaternionI4F add(QuaternionReadable4FType q0,
                                QuaternionReadable4FType q1)

Calculate the element-wise sum of the quaternions q0 and q1.

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

Returns:

(q0.x + q1.x, q0.y + q1.y, q0.z + q1.z, q0.w + q1.w)

almostEqual

public static boolean almostEqual(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                  QuaternionReadable4FType qa,
                                  QuaternionReadable4FType qb)

Determine whether or not the quaternions qa and qb are equal to within the degree of error given in context.

Parameters:

context - The equality context

qa - The left input quaternion

qb - The right input quaternion

Returns:

true if the quaternions are almost equal

Since:

5.0.0

See Also:

AlmostEqualFloat.almostEqual(ContextRelative, float, float)

conjugate

public static QuaternionI4F conjugate(QuaternionReadable4FType q)

Calculate the conjugate of the input quaternion q.

Parameters:

q - The input quaternion

Returns:

The conjugate of the input quaternion

dotProduct

public static float dotProduct(QuaternionReadable4FType q0,
                               QuaternionReadable4FType q1)

Calculate the scalar product of the quaternions q0 and q1.

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

Returns:

The scalar product of the two quaternions

interpolateLinear

public static QuaternionI4F interpolateLinear(QuaternionReadable4FType q0,
                                              QuaternionReadable4FType q1,
                                              float alpha)

Linearly interpolate between q0 and q1 by the amount alpha, such that:

• interpolateLinear(q0, q1, 0.0) = q0
• interpolateLinear(q0, q1, 1.0) = q1

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

alpha - The interpolation value, between 0.0 and 1.0

Returns:

(1 - alpha) * q0 + alpha * q1

isNegationOf

public static boolean isNegationOf(com.io7m.jequality.AlmostEqualFloat.ContextRelative context,
                                   QuaternionReadable4FType qa,
                                   QuaternionReadable4FType qb)

Return true iff qa is the negation of qb.

Each element is compared with (ContextRelative, float, float).

Parameters:

context - The equality context

qa - The left quaternion

qb - The right quaternion

Returns:

true iff qa is the negation of qb

Since:

5.0.0

lookAtWithContext

public static QuaternionI4F lookAtWithContext(QuaternionI4F.ContextQI4F context,
                                              VectorReadable3FType origin,
                                              VectorReadable3FType target,
                                              VectorReadable3FType up)

Produce a quaternion that represents a rotation that "looks at" the point at target assuming the viewer is at origin, using up as the "up" vector.

The function uses storage preallocated in context to avoid any new allocations.

Parameters:

context - Preallocated storage

origin - The origin point

target - The target point

up - The up vector

Returns:

A quaternion looking at the target

Since:

5.0.0

magnitude

public static float magnitude(QuaternionReadable4FType q)

Calculate the magnitude of the quaternion q. Correspondingly, magnitude(normalize(q)) == 1.0.

Parameters:

q - The input quaternion

Returns:

The magnitude of the input quaternion

magnitudeSquared

public static float magnitudeSquared(QuaternionReadable4FType q)

Calculate the squared magnitude of the quaternion q.

Parameters:

q - The input quaternion

Returns:

The squared magnitude of the input quaternion

makeFromAxisAngle

public static QuaternionI4F makeFromAxisAngle(VectorReadable3FType axis,
                                              double angle)

Produce a quaternion that represents a rotation of angle degrees around the axis specified by axis. axis is assumed to be of unit length.

Parameters:

axis - The normalized vector representing the axis

angle - The angle to rotate, in radians

Returns:

A quaternion representing the rotation

See Also:

VectorI3F.normalize(VectorReadable3FType), VectorI4F.normalize(VectorReadable4FType), VectorM3F.normalize(VectorReadable3FType, VectorWritable3FType), VectorM4F.normalize(VectorReadable4FType, VectorWritable4FType)

makeFromRotationMatrix3x3

public static QuaternionI4F makeFromRotationMatrix3x3(MatrixReadable3x3FType m)

Produce a quaternion equivalent to the rotation matrix m.

Parameters:

m - The rotation matrix

Returns:

A quaternion representing the rotation matrix

Since:

5.0.0

makeFromRotationMatrix4x4

public static QuaternionI4F makeFromRotationMatrix4x4(MatrixReadable4x4FType m)

Produce a quaternion equivalent to the rotation matrix m, writing the result to out.

Parameters:

m - The rotation matrix

Returns:

A quaternion representing the rotation matrix

Since:

5.0.0

makeRotationMatrix3x3

public static <M extends MatrixWritable3x3FType> M makeRotationMatrix3x3(QuaternionReadable4FType q,
                                                                         M m)

Produce a rotation matrix from the quaternion q, saving the result to m.

Type Parameters:

M - The precise type of writable matrix.

Parameters:

q - The input quaternion

m - The output matrix

Returns:

m

Since:

5.0.0

makeRotationMatrix4x4

public static <M extends MatrixWritable4x4FType> M makeRotationMatrix4x4(QuaternionReadable4FType q,
                                                                         M m)

Produce a rotation matrix from the quaternion q, saving the result to m.

Type Parameters:

M - The precise type of matrix

Parameters:

q - The input quaternion

m - The output matrix

Returns:

m

Since:

5.0.0

multiply

public static QuaternionI4F multiply(QuaternionReadable4FType q0,
                                     QuaternionReadable4FType q1)

Multiply the quaternion q0 by the quaternion q1 .

Note that this operation is not commutative.

The function is most often used to concatenate quaternions to combine rotations. As an example, assuming that:

• qx represents some rotation around the X axis
• qy represents some rotation around the Y axis
• qz represents some rotation around the Z axis

The following code produces a quaternion qr1 that represents a rotation around the X axis, followed by a rotation around the Y axis, followed by a rotation around the Z axis:

qr0 = QuaternionI4F.multiply(qy, qx); qr1 = QuaternionI4F .multiply(qz, qy);

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

Returns:

The multiplication of the input quaternions

negate

public static QuaternionI4F negate(QuaternionReadable4FType q)

Negate the elements of q.

Parameters:

q - The source quaternion

Returns:

The negation of q

Since:

5.0.0

normalize

public static QuaternionI4F normalize(QuaternionReadable4FType q)

Normalize the quaternion q, preserqing its direction but reducing it to unit length.

Parameters:

q - The input quaternion

Returns:

A quaternion with the same orientation as q but with magnitude equal to 1.0

scale

public static QuaternionI4F scale(QuaternionReadable4FType q,
                                  float r)

Scale the quaternion q by the scalar r.

Parameters:

q - The input quaternion

r - The scaling value

Returns:

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

subtract

public static QuaternionI4F subtract(QuaternionReadable4FType q0,
                                     QuaternionReadable4FType q1)

Subtract the quaternion q0 from the quaternion q1.

Parameters:

q0 - The left input quaternion

q1 - The right input quaternion

Returns:

(q0.x - q1.x, q0.y - q1.y, q0.z - q1.z)

equals

public boolean equals(@Nullable
                      Object obj)

Overrides:

equals in class Object

getWF

public float getWF()

Specified by:

getWF in interface VectorReadable4FType

Returns:

The W value of the given vector.

getXF

public float getXF()

Specified by:

getXF in interface VectorReadable2FType

Returns:

The X value of the given vector.

getYF

public float getYF()

Specified by:

getYF in interface VectorReadable2FType

Returns:

The Y value of the given vector.

getZF

public float getZF()

Specified by:

getZF in interface VectorReadable3FType

Returns:

The Z value of the given vector.

hashCode

public int hashCode()

Overrides:

hashCode in class Object

toString

public String toString()

Overrides:

toString in class Object