java.lang.Object
- org.ojalgo.scalar.Quaternion

All Implemented Interfaces:

java.lang.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<java.lang.Double>, Access2D<java.lang.Double>, Access2D.Collectable<java.lang.Double,Mutate2D>, AccessScalar<Quaternion>, Structure1D, Structure2D, Transformation2D<java.lang.Double>, Tensor<Quaternion,Scalar<Quaternion>>, NumberContext.Enforceable<Quaternion>, NumberDefinition
```
public final class Quaternion
extends java.lang.Object
implements SelfDeclaringScalar<Quaternion>, Access2D<java.lang.Double>, Transformation2D<java.lang.Double>, Access2D.Collectable<java.lang.Double,Mutate2D>
```

Nested Class Summary

Nested Classes
Modifier and Type Class Description

static class Quaternion.RotationAxis
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D
  Access2D.Aggregatable<N extends java.lang.Comparable<N>>, Access2D.Collectable<N extends java.lang.Comparable<N>,R extends Mutate2D>, Access2D.ColumnView<N extends java.lang.Comparable<N>>, Access2D.ElementView<N extends java.lang.Comparable<N>>, Access2D.RowView<N extends java.lang.Comparable<N>>, Access2D.SelectionView<N extends java.lang.Comparable<N>>, Access2D.Sliceable<N extends java.lang.Comparable<N>>, Access2D.Visitable<N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group
  Group.Additive<T>, Group.Multiplicative<T>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation
  Operation.Addition<T>, Operation.Division<T>, Operation.Multiplication<T>, Operation.Subtraction<T>
- Nested classes/interfaces inherited from interface org.ojalgo.scalar.Scalar
  Scalar.Factory<N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation
  ScalarOperation.Addition<T,N extends java.lang.Comparable<N>>, ScalarOperation.Division<T,N extends java.lang.Comparable<N>>, ScalarOperation.Multiplication<T,N extends java.lang.Comparable<N>>, ScalarOperation.Subtraction<T,N extends java.lang.Comparable<N>>
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D
  Structure1D.BasicMapper<T>, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.Logical<S extends Structure1D,B extends Structure1D.Logical<S,B>>, Structure1D.LongIndex, Structure1D.LoopCallback
- Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D
  Structure2D.IntRowColumn, Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,B>>, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.Reshapable, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>

Field Summary

Fields
Modifier and Type	Field	Description
`private static double`	`ARGUMENT_TOLERANCE`
`static Scalar.Factory<Quaternion>`	`FACTORY`
`double`	`i`
`static Quaternion`	`I`
`static Quaternion`	`IJK`
`static Quaternion`	`INFINITY`
`double`	`j`
`static Quaternion`	`J`
`double`	`k`
`static Quaternion`	`K`
`private boolean`	`myPureForSure`
`private boolean`	`myRealForSure`
`private double`	`myScalar`
`static Quaternion`	`NaN`
`static Quaternion`	`NEG`
`static Quaternion`	`ONE`
`static Quaternion`	`TWO`
`static 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

All Methods Static Methods Instance Methods Concrete Methods
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(java.lang.Object obj)`
`float`	`floatValue()`
`Quaternion`	`get()`
`java.lang.Double`	`get(long index)`
`java.lang.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)`
`java.math.BigDecimal`	`toBigDecimal()`
`MatrixStore<ComplexNumber>`	`toComplexMatrix()`
`MatrixStore<java.lang.Double>`	`toMultiplicationMatrix()`
`MatrixStore<java.lang.Double>`	`toMultiplicationVector()`
`MatrixStore<java.lang.Double>`	`toRotationMatrix()`
`(package private) MatrixStore<java.lang.Double>`	`toRotationMatrixVersor()`
`java.lang.String`	`toString()`
`java.lang.String`	`toString(NumberContext context)`
`<T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void`	`transform(T transformable)`
`(package private) <T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void`	`transformVersor(T transformable)`
`double[]`	`unit()`
`static Quaternion`	`valueOf(double value)`
`static Quaternion`	`valueOf(java.lang.Comparable<?> number)`
`PhysicalStore<java.lang.Double>`	`vector()`
`Quaternion`	`versor()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.ojalgo.structure.Access1D
asCollectable1D, asKeyed1D, asList, axpy, dot, select, supplyTo, toList, toRawCopy1D

Methods inherited from interface org.ojalgo.structure.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 org.ojalgo.structure.Access2D.Collectable
collect

Methods inherited from interface org.ojalgo.type.NumberDefinition
booleanValue, byteValue, shortValue

Methods inherited from interface org.ojalgo.scalar.Scalar
add, dimensions, divide, multiply, rank, subtract, toPlainString

Methods inherited from interface org.ojalgo.scalar.SelfDeclaringScalar
add, divide, multiply, subtract

Methods inherited from interface org.ojalgo.structure.Structure2D
firstInColumn, firstInRow, getMaxDim, getMinDim, isEmpty, isFat, isScalar, isSquare, isTall, isVector, limitOfColumn, limitOfRow, size

Methods inherited from interface org.ojalgo.tensor.Tensor
components, isSameShape

- Field Detail
  - 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 Detail
  - 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 Detail
  - 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(java.lang.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 java.lang.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<java.lang.Double>
    
    Specified by:
    
    doubleValue in interface Access2D<java.lang.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<java.lang.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(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object
  - floatValue
```
public float floatValue()
```
    Specified by:
    
    floatValue in interface NumberDefinition
  - get
```
public Quaternion get()
```
    Specified by:
    
    get in interface AccessScalar<Quaternion>
  - get
```
public java.lang.Double get(long index)
```
    Specified by:
    
    get in interface Access1D<java.lang.Double>
    
    Specified by:
    
    get in interface Access2D<java.lang.Double>
  - get
```
public java.lang.Double get(long row,
                            long col)
```
    Specified by:
    
    get in interface Access2D<java.lang.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 java.lang.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<java.lang.Double,Mutate2D>
  - toBigDecimal
```
public java.math.BigDecimal toBigDecimal()
```
    Specified by:
    
    toBigDecimal in interface Scalar<Quaternion>
  - toComplexMatrix
```
public MatrixStore<ComplexNumber> toComplexMatrix()
```
  - toMultiplicationMatrix
```
public MatrixStore<java.lang.Double> toMultiplicationMatrix()
```
  - toMultiplicationVector
```
public MatrixStore<java.lang.Double> toMultiplicationVector()
```
  - toRotationMatrix
```
public MatrixStore<java.lang.Double> toRotationMatrix()
```
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
    
    See Also:
    
    Object.toString()
  - toString
```
public java.lang.String toString(NumberContext context)
```
    Specified by:
    
    toString in interface Scalar<Quaternion>
  - transform
```
public <T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void transform(T transformable)
```
    Specified by:
    
    transform in interface Transformation2D<java.lang.Double>
  - unit
```
public double[] unit()
```
  - vector
```
public PhysicalStore<java.lang.Double> vector()
```
  - versor
```
public Quaternion versor()
```
  - calculateSumOfSquaresAll
```
private double calculateSumOfSquaresAll()
```
  - calculateSumOfSquaresVector
```
private double calculateSumOfSquaresVector()
```
  - toRotationMatrixVersor
```
MatrixStore<java.lang.Double> toRotationMatrixVersor()
```
  - transformVersor
```
<T extends Mutate2D.ModifiableReceiver<java.lang.Double>> void transformVersor(T transformable)
```

Class Quaternion

Nested Class Summary

Nested classes/interfaces inherited from interface org.ojalgo.structure.Access2D

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Group

Nested classes/interfaces inherited from interface org.ojalgo.algebra.Operation

Nested classes/interfaces inherited from interface org.ojalgo.scalar.Scalar

Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure1D

Nested classes/interfaces inherited from interface org.ojalgo.structure.Structure2D

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.structure.Access1D

Methods inherited from interface org.ojalgo.structure.Access2D

Methods inherited from interface org.ojalgo.structure.Access2D.Collectable

Methods inherited from interface org.ojalgo.type.NumberDefinition

Methods inherited from interface org.ojalgo.scalar.Scalar

Methods inherited from interface org.ojalgo.scalar.SelfDeclaringScalar

Methods inherited from interface org.ojalgo.structure.Structure2D

Methods inherited from interface org.ojalgo.tensor.Tensor

Field Detail

FACTORY

I

IJK

INFINITY

J

K

NaN

NEG

ONE

TWO

ZERO

ARGUMENT_TOLERANCE

i

j

k

myPureForSure

myRealForSure

myScalar

Constructor Detail

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Quaternion

Method Detail

isAbsolute

isInfinite

isNaN

isReal

isSmall

makePolar

makeRotation

of

of

valueOf

valueOf

add

add

angle

compareTo

conjugate

count

countColumns

countRows

divide

divide

doubleValue

doubleValue

doubleValue

enforce

equals

floatValue

get

get

get

getColDim

getDeterminant