Class Quaternion

java.lang.Object

org.ojalgo.scalar.Quaternion

All Implemented Interfaces:

Comparable<Quaternion>, Field<Scalar<Quaternion>>, Group, Group.Additive<Scalar<Quaternion>>, Group.Multiplicative<Scalar<Quaternion>>, NormedVectorSpace<Scalar<Quaternion>, Quaternion>, Operation, Operation.Addition<Scalar<Quaternion>>, Operation.Division<Scalar<Quaternion>>, Operation.Multiplication<Scalar<Quaternion>>, Operation.Subtraction<Scalar<Quaternion>>, Ring<Scalar<Quaternion>>, ScalarOperation, ScalarOperation.Addition<Scalar<Quaternion>, Quaternion>, ScalarOperation.Division<Scalar<Quaternion>, Quaternion>, ScalarOperation.Multiplication<Scalar<Quaternion>, Quaternion>, ScalarOperation.Subtraction<Scalar<Quaternion>, Quaternion>, VectorSpace<Scalar<Quaternion>, Quaternion>, Scalar<Quaternion>, SelfDeclaringScalar<Quaternion>, Access1D<Double>, Access2D<Double>, Access2D.Collectable<Double,Mutate2D>, AccessScalar<Quaternion>, Structure1D, Structure2D, Transformation2D<Double>, Tensor<Quaternion, Scalar<Quaternion>>, NumberContext.Enforceable<Quaternion>, NumberDefinition

public final class Quaternion
extends Object
implements SelfDeclaringScalar<Quaternion>, Access2D<Double>, Transformation2D<Double>, Access2D.Collectable<Double,Mutate2D>

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static enum	Quaternion.RotationAxis

Nested classes/interfaces inherited from interface Access2D

Access2D.Aggregatable<N>, Access2D.Collectable<N,R>, Access2D.ColumnView<N>, Access2D.ElementView<N>, Access2D.RowView<N>, Access2D.SelectionView<N>, Access2D.Sliceable<N>, Access2D.Visitable<N>

Nested classes/interfaces inherited from interface Group

Group.Additive<T>, Group.Multiplicative<T>

Nested classes/interfaces inherited from interface Operation

Operation.Addition<T>, Operation.Division<T>, Operation.Multiplication<T>, Operation.Subtraction<T>

Nested classes/interfaces inherited from interface Scalar

Scalar.Factory<N>

Nested classes/interfaces inherited from interface ScalarOperation

ScalarOperation.Addition<T,N>, ScalarOperation.Division<T,N>, ScalarOperation.Multiplication<T,N>, ScalarOperation.Subtraction<T,N>

Nested classes/interfaces inherited from interface Structure1D

Structure1D.BasicMapper<T>, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.Logical<S,B>, Structure1D.LongIndex, Structure1D.LoopCallback

Nested classes/interfaces inherited from interface Structure2D

Structure2D.IntRowColumn, Structure2D.Logical<S,B>, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R>, Structure2D.Reshapable, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>

Field Summary

Fields

Modifier and Type	Field	Description
private static final double	ARGUMENT_TOLERANCE
static final Scalar.Factory<Quaternion>	FACTORY
final double	i
static final Quaternion	I
static final Quaternion	IJK
static final Quaternion	INFINITY
final double	j
static final Quaternion	J
final double	k
static final Quaternion	K
private final boolean	myPureForSure
private final boolean	myRealForSure
private final double	myScalar
static final Quaternion	NaN
static final Quaternion	NEG
static final Quaternion	ONE
static final Quaternion	TWO
static final Quaternion	ZERO

Constructor Summary

Constructors

Modifier	Constructor	Description
	Quaternion()
(package private)	Quaternion(double scalar)
private	Quaternion(double[] vector)
private	Quaternion(double scalar, double[] vector)
(package private)	Quaternion(double i, double j, double k)
(package private)	Quaternion(double scalar, double i, double j, double k)

Method Summary

Modifier and Type	Method	Description
Quaternion	add(double arg)
Quaternion	add(Quaternion arg)
double	angle()
private double	calculateSumOfSquaresAll()
private double	calculateSumOfSquaresVector()
int	compareTo(Quaternion other)	First compares the real values.
Quaternion	conjugate()	This method will (most likely) be moved to some other interface in the future! Just have to figure out where it fits...
long	count()	count() == countRows() * countColumns()
long	countColumns()	Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
long	countRows()	Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.
Quaternion	divide(double arg)
Quaternion	divide(Quaternion arg)	Will calculate this * reciprocal(arg) which is not the same as reciprocal(arg) * this.
double	doubleValue()
double	doubleValue(int index)
double	doubleValue(int row, int col)	Extracts one element of this matrix as a double.
Quaternion	enforce(NumberContext context)
boolean	equals(Object obj)
float	floatValue()
Quaternion	get()
Double	get(long index)
Double	get(long row, long col)
int	getColDim()
double	getDeterminant()	The fourth power of the norm of a quaternion is the determinant of the corresponding matrix.
Quaternion	getPureVersor()
int	getRowDim()
double	getVectorLength()
int	hashCode()
int	intValue()
Quaternion	invert()	The multiplicative inverse.
boolean	isAbsolute()
static boolean	isAbsolute(Quaternion value)
static boolean	isInfinite(Quaternion value)
static boolean	isNaN(Quaternion value)
boolean	isPure()
boolean	isReal()
static boolean	isReal(Quaternion value)
boolean	isSmall(double comparedTo)
static boolean	isSmall(double comparedTo, Quaternion value)
boolean	isZero()	Tests if this scalar value is exactly zero.
long	longValue()
static Quaternion	makePolar(double norm, double[] unit, double angle)
static Quaternion	makeRotation(Quaternion.RotationAxis axis, double angle)	Create a Quaternion that captures a rotation about the provided axis by the provided angle.
Quaternion	multiply(double arg)
Quaternion	multiply(Quaternion arg)
Quaternion	negate()	The additive inverse of this.
double	norm()	this == this.signum().multiply(this.norm())
static Quaternion	of(double i, double j, double k)
static Quaternion	of(double scalar, double i, double j, double k)
Quaternion	power(int power)	Multiply by itself power times.
double	scalar()
Quaternion	signum()	this == this.signum().multiply(this.norm())
Quaternion	subtract(double arg)
Quaternion	subtract(Quaternion arg)
void	supplyTo(Mutate2D receiver)
BigDecimal	toBigDecimal()
MatrixStore<ComplexNumber>	toComplexMatrix()
MatrixStore<Double>	toMultiplicationMatrix()
MatrixStore<Double>	toMultiplicationVector()
MatrixStore<Double>	toRotationMatrix()
(package private) MatrixStore<Double>	toRotationMatrixVersor()
String	toString()
String	toString(NumberContext context)
<T extends Mutate2D.ModifiableReceiver<Double>> void	transform(T transformable)
(package private) <T extends Mutate2D.ModifiableReceiver<Double>> void	transformVersor(T transformable)
double[]	unit()
static Quaternion	valueOf(double value)
static Quaternion	valueOf(Comparable<?> number)
PhysicalStore<Double>	vector()
Quaternion	versor()

Methods inherited from class Object

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

Methods inherited from interface Access1D

asCollectable1D, asKeyed1D, asList, axpy, dot, select, supplyTo, toList, toRawCopy1D

Methods inherited from interface Access2D

asCollectable2D, asKeyed2D, byteValue, byteValue, byteValue, byteValue, columns, columns, columns, doubleValue, doubleValue, elements, floatValue, floatValue, floatValue, floatValue, intValue, intValue, intValue, intValue, longValue, longValue, longValue, longValue, nonzeros, rows, rows, rows, select, select, shortValue, shortValue, shortValue, shortValue, toRawCopy2D

Methods inherited from interface Access2D.Collectable

collect

Methods inherited from interface NumberDefinition

booleanValue, byteValue, shortValue

Methods inherited from interface Scalar

add, dimensions, divide, multiply, rank, subtract, toPlainString

Methods inherited from interface SelfDeclaringScalar

add, divide, multiply, subtract

Methods inherited from interface Structure2D

firstInColumn, firstInRow, getMaxDim, getMinDim, isEmpty, isFat, isScalar, isSquare, isTall, isVector, limitOfColumn, limitOfRow, size

Methods inherited from interface Tensor

components, isSameShape

Field Details

FACTORY

public static final Scalar.Factory<Quaternion> FACTORY

I

public static final Quaternion I

IJK

public static final Quaternion IJK

INFINITY

public static final Quaternion INFINITY

J

public static final Quaternion J

K

public static final Quaternion K

NaN

public static final Quaternion NaN

NEG

public static final Quaternion NEG

ONE

public static final Quaternion ONE

TWO

public static final Quaternion TWO

ZERO

public static final Quaternion ZERO

ARGUMENT_TOLERANCE

private static final double ARGUMENT_TOLERANCE

i

public final double i

j

public final double j

k

public final double k

myPureForSure

private final boolean myPureForSure

myRealForSure

private final boolean myRealForSure

myScalar

private final double myScalar

Constructor Details

Quaternion

public Quaternion()

Quaternion

private Quaternion(double scalar,
 double[] vector)

Quaternion

private Quaternion(double[] vector)

Quaternion

Quaternion(double scalar)

Quaternion

Quaternion(double i,
 double j,
 double k)

Quaternion

Quaternion(double scalar,
 double i,
 double j,
 double k)

Method Details

isAbsolute

public static boolean isAbsolute(Quaternion value)

isInfinite

public static boolean isInfinite(Quaternion value)

isNaN

public static boolean isNaN(Quaternion value)

isReal

public static boolean isReal(Quaternion value)

isSmall

public static boolean isSmall(double comparedTo,
 Quaternion value)

makePolar

public static Quaternion makePolar(double norm,
 double[] unit,
 double angle)

makeRotation

public static Quaternion makeRotation(Quaternion.RotationAxis axis,
 double angle)

Create a Quaternion that captures a rotation about the provided axis by the provided angle.

The quaternion representation of the rotation may be expressed as:

q = cos(θ / 2) + sin(θ / 2) * (ub * i + uc * j + ud * k)

where θ is the angle of rotation and

[ub, uc, ud]

is the axis of rotation. This method accepts a single axis, so only a single imaginary component is populated.

To rotate in multiple axes, multiply multiple quaternions:

Quaternion xRotation = Quaternion.makeRotation(RotationAxis.X, Math.toRadians(-3));
Quaternion yRotation = Quaternion.makeRotation(RotationAxis.Y, Math.toRadians(2));
Quaternion zRotation = Quaternion.makeRotation(RotationAxis.Z, Math.toRadians(45));
Quaternion zyxRotation = zRotation.multiply(yRotation).multiply(xRotation);

This creates a rotation in ZYX order.

Parameters:

axis - the axis to rotate about, non-null

angle - the angle, in radians to rotate about the axis

Returns:

the quaternion

of

public static Quaternion of(double i,
 double j,
 double k)

of

public static Quaternion of(double scalar,
 double i,
 double j,
 double k)

valueOf

public static Quaternion valueOf(Comparable<?> number)

valueOf

public static Quaternion valueOf(double value)

add

public Quaternion add(double arg)

Specified by:

add in interface ScalarOperation.Addition<Scalar<Quaternion>, Quaternion>

Specified by:

add in interface SelfDeclaringScalar<Quaternion>

Returns:

this + scalarAddend.

add

public Quaternion add(Quaternion arg)

Specified by:

add in interface ScalarOperation.Addition<Scalar<Quaternion>, Quaternion>

Specified by:

add in interface SelfDeclaringScalar<Quaternion>

Returns:

this + scalarAddend.

angle

public double angle()

compareTo

public int compareTo(Quaternion other)

First compares the real values. Only if they are equal will compare the imaginary part.

Specified by:

compareTo in interface Comparable<Quaternion>

conjugate

public Quaternion conjugate()

Description copied from interface: VectorSpace

This method will (most likely) be moved to some other interface in the future! Just have to figure out where it fits...

The conjugate transpose of a matrix and/or the conjugate of a scalar/field like ComplexNumber or Quaternion.

The conjugate transpose of a real matrix is simply its transpose.

Specified by:

conjugate in interface SelfDeclaringScalar<Quaternion>

Specified by:

conjugate in interface VectorSpace<Scalar<Quaternion>, Quaternion>

count

public long count()

Description copied from interface: Structure2D

count() == countRows() * countColumns()

Specified by:

count in interface Structure1D

Specified by:

count in interface Structure2D

countColumns

public long countColumns()

Description copied from interface: Structure2D

Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.

Specified by:

countColumns in interface Structure2D

Returns:

The number of columns

countRows

public long countRows()

Description copied from interface: Structure2D

Only need to implement if the structure may contain more than Integer.MAX_VALUE elements.

Specified by:

countRows in interface Structure2D

Returns:

The number of rows

divide

public Quaternion divide(double arg)

Specified by:

divide in interface ScalarOperation.Division<Scalar<Quaternion>, Quaternion>

Specified by:

divide in interface SelfDeclaringScalar<Quaternion>

Returns:

this / scalarDivisor.

divide

public Quaternion divide(Quaternion arg)

Will calculate this * reciprocal(arg) which is not the same as reciprocal(arg) * this.

Specified by:

divide in interface ScalarOperation.Division<Scalar<Quaternion>, Quaternion>

Specified by:

divide in interface SelfDeclaringScalar<Quaternion>

Returns:

this / scalarDivisor.

doubleValue

public double doubleValue()

Specified by:

doubleValue in interface NumberDefinition

doubleValue

public double doubleValue(int index)

Specified by:

doubleValue in interface Access1D<Double>

Specified by:

doubleValue in interface Access2D<Double>

doubleValue

public double doubleValue(int row,
 int col)

Description copied from interface: Access2D

Extracts one element of this matrix as a double.

Specified by:

doubleValue in interface Access2D<Double>

Parameters:

row - A row index.

col - A column index.

Returns:

One matrix element

enforce

public Quaternion enforce(NumberContext context)

Specified by:

enforce in interface NumberContext.Enforceable<Quaternion>

equals

public boolean equals(Object obj)

Overrides:

equals in class Object

floatValue

public float floatValue()

Specified by:

floatValue in interface NumberDefinition

get

public Quaternion get()

Specified by:

get in interface AccessScalar<Quaternion>

get

public Double get(long index)

Specified by:

get in interface Access1D<Double>

Specified by:

get in interface Access2D<Double>

get

public Double get(long row,
 long col)

Specified by:

get in interface Access2D<Double>

getColDim

public int getColDim()

Specified by:

getColDim in interface Structure2D

Returns:

The number of columns

getDeterminant

public double getDeterminant()

The fourth power of the norm of a quaternion is the determinant of the corresponding matrix.

getPureVersor

public Quaternion getPureVersor()

Returns:

A normalised Quaternion with the real/scalar part "removed".

getRowDim

public int getRowDim()

Specified by:

getRowDim in interface Structure2D

Returns:

The number of rows

getVectorLength

public double getVectorLength()

hashCode

public int hashCode()

Overrides:

hashCode in class Object

intValue

public int intValue()

Specified by:

intValue in interface NumberDefinition

invert

public Quaternion invert()

Description copied from interface: Group.Multiplicative

The multiplicative inverse.

Specified by:

invert in interface Group.Multiplicative<Scalar<Quaternion>>

Specified by:

invert in interface SelfDeclaringScalar<Quaternion>

Returns:

IDENTITY / this.

isAbsolute

public boolean isAbsolute()

Specified by:

isAbsolute in interface Scalar<Quaternion>

Returns:

true if this is equal to its own norm, modulus or absolute value (non-negative real part and no imaginary part); otherwise false.

See Also:

• Scalar.isAbsolute()

isPure

public boolean isPure()

isReal

public boolean isReal()

isSmall

public boolean isSmall(double comparedTo)

Specified by:

isSmall in interface NormedVectorSpace<Scalar<Quaternion>, Quaternion>

Parameters:

comparedTo - What to compare with

Returns:

true if this is small compared to the magnitude of the input reference value.

isZero

public boolean isZero()

Description copied from interface: Scalar

Tests if this scalar value is exactly zero.

Each implementation should test for zero as exactly as possible based on what's achievable with that specific scalar type. The purpose is NOT to have similar behavior between different implementations, but rather to leverage the full precision and capabilities of each type.

For example:

• Primitive types (like double) should use exact equality comparison
• High-precision types (like Quadruple) should check both base and remainder components
• Arbitrary-precision types (like BigDecimal) should use their built-in zero detection
• Complex types should check both real and imaginary parts

This method should NOT use tolerance-based comparisons or approximate zero detection, as those are better handled by context-aware methods like NormedVectorSpace.isSmall(double).

Specified by:

isZero in interface Scalar<Quaternion>

Returns:

true if this scalar represents exactly zero, false otherwise

See Also:

• NormedVectorSpace.isSmall(double)

longValue

public long longValue()

Specified by:

longValue in interface NumberDefinition

multiply

public Quaternion multiply(double arg)

Specified by:

multiply in interface ScalarOperation.Multiplication<Scalar<Quaternion>, Quaternion>

Specified by:

multiply in interface SelfDeclaringScalar<Quaternion>

Returns:

this * scalarMultiplicand.

multiply

public Quaternion multiply(Quaternion arg)

Specified by:

multiply in interface ScalarOperation.Multiplication<Scalar<Quaternion>, Quaternion>

Specified by:

multiply in interface SelfDeclaringScalar<Quaternion>

Returns:

this * multiplicand.

negate

public Quaternion negate()

Description copied from interface: Group.Additive

The additive inverse of this.

Specified by:

negate in interface Group.Additive<Scalar<Quaternion>>

Specified by:

negate in interface SelfDeclaringScalar<Quaternion>

Returns:

-this.

norm

public double norm()

Description copied from interface: NormedVectorSpace

this == this.signum().multiply(this.norm())

Specified by:

norm in interface NormedVectorSpace<Scalar<Quaternion>, Quaternion>

Returns:

The norm

power

public Quaternion power(int power)

Description copied from interface: Operation.Multiplication

Multiply by itself power times.

Specified by:

power in interface Operation.Multiplication<Scalar<Quaternion>>

Specified by:

power in interface SelfDeclaringScalar<Quaternion>

scalar

public double scalar()

signum

public Quaternion signum()

Description copied from interface: NormedVectorSpace

this == this.signum().multiply(this.norm())

Specified by:

signum in interface NormedVectorSpace<Scalar<Quaternion>, Quaternion>

Specified by:

signum in interface SelfDeclaringScalar<Quaternion>

Returns:

A unit "vector"

subtract

public Quaternion subtract(double arg)

Specified by:

subtract in interface ScalarOperation.Subtraction<Scalar<Quaternion>, Quaternion>

Specified by:

subtract in interface SelfDeclaringScalar<Quaternion>

Returns:

this - scalarSubtrahend.

subtract

public Quaternion subtract(Quaternion arg)

Specified by:

subtract in interface ScalarOperation.Subtraction<Scalar<Quaternion>, Quaternion>

Specified by:

subtract in interface SelfDeclaringScalar<Quaternion>

Returns:

this - scalarSubtrahend.

supplyTo

public void supplyTo(Mutate2D receiver)

Specified by:

supplyTo in interface Access2D.Collectable<Double,Mutate2D>

toBigDecimal

public BigDecimal toBigDecimal()

Specified by:

toBigDecimal in interface Scalar<Quaternion>

toComplexMatrix

public MatrixStore<ComplexNumber> toComplexMatrix()

toMultiplicationMatrix

public MatrixStore<Double> toMultiplicationMatrix()

toMultiplicationVector

public MatrixStore<Double> toMultiplicationVector()

toRotationMatrix

public MatrixStore<Double> toRotationMatrix()

toString

public String toString()

Overrides:

toString in class Object

See Also:

• Object.toString()

toString

public String toString(NumberContext context)

Specified by:

toString in interface Scalar<Quaternion>

transform

public <T extends Mutate2D.ModifiableReceiver<Double>>
void transform(T transformable)

Specified by:

transform in interface Transformation2D<Double>

unit

public double[] unit()

vector

public PhysicalStore<Double> vector()

versor

public Quaternion versor()

calculateSumOfSquaresAll

private double calculateSumOfSquaresAll()

calculateSumOfSquaresVector

private double calculateSumOfSquaresVector()

toRotationMatrixVersor

MatrixStore<Double> toRotationMatrixVersor()

transformVersor

<T extends Mutate2D.ModifiableReceiver<Double>>
void transformVersor(T transformable)