Quaternion (ojAlgo 45.1.1 API)

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

All Implemented Interfaces:

Serializable, Comparable<Quaternion>, Iterable<Double>, Access1D<Double>, Access2D<Double>, Access2D.Collectable<Double,Mutate2D.Receiver<Double>>, AccessScalar<Quaternion>, Structure1D, Structure2D, 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>, TransformationMatrix<Double,PhysicalStore<Double>>, Scalar<Quaternion>, NumberContext.Enforceable<Quaternion>

Direct Known Subclasses:

Quaternion.Versor
```
public class Quaternion
extends Number
implements Scalar<Quaternion>, NumberContext.Enforceable<Quaternion>, Access2D<Double>, TransformationMatrix<Double,PhysicalStore<Double>>, Access2D.Collectable<Double,Mutate2D.Receiver<Double>>
```
See Also:

Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type Class and Description

static class Quaternion.RotationAxis

static class Quaternion.Versor
- Nested classes/interfaces inherited from interface org.ojalgo.scalar.Scalar
  Scalar.Factory<N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.algebra.ScalarOperation
  ScalarOperation.Addition<T,N extends Number>, ScalarOperation.Division<T,N extends Number>, ScalarOperation.Multiplication<T,N extends Number>, ScalarOperation.Subtraction<T,N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.access.Access2D
  Access2D.Aggregatable<N extends Number>, Access2D.Collectable<N extends Number,R extends Mutate2D.Receiver<N>>, Access2D.Elements, Access2D.ElementView<N extends Number>, Access2D.IndexOf, Access2D.Sliceable<N extends Number>, Access2D.Visitable<N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.matrix.transformation.TransformationMatrix
  TransformationMatrix.Transformable<N extends Number>
- Nested classes/interfaces inherited from interface org.ojalgo.access.Structure2D
  Structure2D.IntRowColumn, Structure2D.LongRowColumn, Structure2D.ReducibleTo1D<R extends Structure1D>, Structure2D.RowColumnCallback, Structure2D.RowColumnKey<R,C>, Structure2D.RowColumnMapper<R,C>
- Nested classes/interfaces inherited from interface org.ojalgo.access.Structure1D
  Structure1D.BasicMapper<T>, Structure1D.IndexCallback, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.LongIndex, Structure1D.LoopCallback

Nested Classes
Modifier and Type	Class and Description
`static class`	`Quaternion.RotationAxis`
`static class`	`Quaternion.Versor`

Field Summary

Fields
Modifier and Type	Field and Description
`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`
`static Quaternion`	`NEG`
`static Quaternion`	`ONE`
`static Quaternion`	`ZERO`

Constructor Summary

Constructors
Constructor and Description

Quaternion()

Constructors
Constructor and Description
`Quaternion()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Quaternion`	`add(double arg)`
`Quaternion`	`add(Quaternion arg)`
`double`	`angle()`
`int`	`compareTo(Quaternion reference)`
`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()`
`long`	`countRows()`
`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(long index)`
`double`	`doubleValue(long row, long 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)`
`double`	`getDeterminant()` The fourth power of the norm of a quaternion is the determinant of the corresponding matrix.
`Quaternion`	`getPureVersor()`
`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)`
`long`	`longValue()`
`static Quaternion`	`makePolar(double norm, double[] unit, double angle)`
`static Quaternion.Versor`	`makeRotation(Quaternion.RotationAxis axis, double 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)`
`double`	`scalar()`
`Quaternion.Versor`	`signum()` `this == this.signum().multiply(this.norm())`
`Quaternion`	`subtract(double arg)`
`Quaternion`	`subtract(Quaternion arg)`
`void`	`supplyTo(Mutate2D.Receiver<Double> receiver)`
`BigDecimal`	`toBigDecimal()`
`MatrixStore<ComplexNumber>`	`toComplexMatrix()`
`MatrixStore<Double>`	`toMultiplicationMatrix()`
`MatrixStore<Double>`	`toMultiplicationVector()`
`MatrixStore<Double>`	`toRotationMatrix()`
`String`	`toString()`
`String`	`toString(NumberContext context)`
`void`	`transform(PhysicalStore<Double> matrix)`
`double[]`	`unit()`
`static Quaternion`	`valueOf(double value)`
`static Quaternion`	`valueOf(Number number)`
`PhysicalStore<Double>`	`vector()`
`Quaternion.Versor`	`versor()`

Methods inherited from class java.lang.Number
byteValue, shortValue

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

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

Methods inherited from interface org.ojalgo.access.AccessScalar
byteValue, getNumber, shortValue

Methods inherited from interface org.ojalgo.access.Access2D
asCollectable2D, asPrimitive2D, columns, elements, equals, newPrimitiveColumnCollectable, newPrimitiveRowCollectable, rows, toRawCopy2D, toString, wrap, wrap, wrapAccess2D, wrapAccess2D

Methods inherited from interface org.ojalgo.access.Access1D
asCollectable1D, asPrimitive1D, axpy, dot, equals, hashCode, iterator, nonzeros, stream, supplyTo, toRawCopy1D, wrap, wrap, wrap, wrapAccess1D, wrapAccess1D, wrapAccess1D

Methods inherited from interface java.lang.Iterable
forEach, spliterator

Methods inherited from interface org.ojalgo.access.Access2D.Collectable
collect

Methods inherited from interface org.ojalgo.access.Structure2D
column, column, column, column, column, index, index, isEmpty, isFat, isScalar, isSquare, isTall, isVector, loopAll, loopColumn, loopColumn, loopDiagonal, loopMatching, loopRow, loopRow, mapperOf, row, row, row, row, row

Methods inherited from interface org.ojalgo.access.Structure1D
loopAll, loopMatching, loopRange, mapper

- 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
```
  - NEG
```
public static final Quaternion NEG
```
  - ONE
```
public static final Quaternion ONE
```
  - ZERO
```
public static final Quaternion ZERO
```
  - i
```
public final double i
```
  - j
```
public final double j
```
  - k
```
public final double k
```
- Constructor Detail
  - Quaternion
```
public Quaternion()
```
- 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.Versor makeRotation(Quaternion.RotationAxis axis,
                                             double angle)
```
  - 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(double value)
```
  - valueOf
```
public static Quaternion valueOf(Number number)
```
  - add
```
public Quaternion add(double arg)
```
    Specified by:
    
    add in interface ScalarOperation.Addition<Scalar<Quaternion>,Quaternion>
    
    Returns:
    
    this + scalarAddend.
  - add
```
public Quaternion add(Quaternion arg)
```
    Specified by:
    
    add in interface ScalarOperation.Addition<Scalar<Quaternion>,Quaternion>
    
    Returns:
    
    this + scalarAddend.
  - angle
```
public double angle()
```
  - compareTo
```
public int compareTo(Quaternion reference)
```
    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 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
    
    Returns:
    
    The total number of elements in this structure.
  - countColumns
```
public long countColumns()
```
    Specified by:
    
    countColumns in interface Structure2D
    
    Returns:
    
    The number of columns
  - countRows
```
public long countRows()
```
    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>
    
    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>
    
    Returns:
    
    this / scalarDivisor.
    
    See Also:
    
    ScalarOperation.Division.divide(java.lang.Number)
  - doubleValue
```
public double doubleValue()
```
    Specified by:
    
    doubleValue in interface AccessScalar<Quaternion>
    
    Specified by:
    
    doubleValue in class Number
    
    See Also:
    
    Number.doubleValue()
  - doubleValue
```
public double doubleValue(long index)
```
    Specified by:
    
    doubleValue in interface Access1D<Double>
    
    Specified by:
    
    doubleValue in interface Access2D<Double>
  - doubleValue
```
public double doubleValue(long row,
                          long 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 AccessScalar<Quaternion>
    
    Specified by:
    
    floatValue in class Number
    
    See Also:
    
    Number.floatValue()
  - 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>
  - 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".
  - getVectorLength
```
public double getVectorLength()
```
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class Object
  - intValue
```
public int intValue()
```
    Specified by:
    
    intValue in interface AccessScalar<Quaternion>
    
    Specified by:
    
    intValue in class Number
    
    See Also:
    
    Number.intValue()
  - invert
```
public Quaternion invert()
```
    Description copied from interface: Group.Multiplicative
    
    The multiplicative inverse.
    
    Specified by:
    
    invert in interface Group.Multiplicative<Scalar<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.
  - longValue
```
public long longValue()
```
    Specified by:
    
    longValue in interface AccessScalar<Quaternion>
    
    Specified by:
    
    longValue in class Number
    
    See Also:
    
    Number.longValue()
  - multiply
```
public Quaternion multiply(double arg)
```
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<Scalar<Quaternion>,Quaternion>
    
    Returns:
    
    this * scalarMultiplicand.
  - multiply
```
public Quaternion multiply(Quaternion arg)
```
    Specified by:
    
    multiply in interface ScalarOperation.Multiplication<Scalar<Quaternion>,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>>
    
    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
  - scalar
```
public double scalar()
```
  - signum
```
public Quaternion.Versor signum()
```
    Description copied from interface: NormedVectorSpace
    
    this == this.signum().multiply(this.norm())
    
    Specified by:
    
    signum in interface NormedVectorSpace<Scalar<Quaternion>,Quaternion>
    
    Returns:
    
    A unit "vector"
  - subtract
```
public Quaternion subtract(double arg)
```
    Specified by:
    
    subtract in interface ScalarOperation.Subtraction<Scalar<Quaternion>,Quaternion>
    
    Returns:
    
    this - scalarSubtrahend.
  - subtract
```
public Quaternion subtract(Quaternion arg)
```
    Specified by:
    
    subtract in interface ScalarOperation.Subtraction<Scalar<Quaternion>,Quaternion>
    
    Returns:
    
    this - scalarSubtrahend.
  - supplyTo
```
public void supplyTo(Mutate2D.Receiver<Double> receiver)
```
    Specified by:
    
    supplyTo in interface Access2D.Collectable<Double,Mutate2D.Receiver<Double>>
  - 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 void transform(PhysicalStore<Double> matrix)
```
    Specified by:
    
    transform in interface TransformationMatrix<Double,PhysicalStore<Double>>
  - unit
```
public double[] unit()
```
  - vector
```
public PhysicalStore<Double> vector()
```
  - versor
```
public Quaternion.Versor versor()
```

Class Quaternion

Nested Class Summary

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.access.Access2D

Nested classes/interfaces inherited from interface org.ojalgo.matrix.transformation.TransformationMatrix

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

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

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Methods inherited from interface org.ojalgo.scalar.Scalar

Methods inherited from interface org.ojalgo.access.AccessScalar

Methods inherited from interface org.ojalgo.access.Access2D

Methods inherited from interface org.ojalgo.access.Access1D

Methods inherited from interface java.lang.Iterable

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

Methods inherited from interface org.ojalgo.access.Structure2D

Methods inherited from interface org.ojalgo.access.Structure1D

Field Detail

FACTORY

I

IJK

INFINITY

J

K

NEG

ONE

ZERO

i

j

k

Constructor Detail

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

getDeterminant

getPureVersor

getVectorLength

hashCode

intValue

invert

isAbsolute

isPure

isReal

isSmall

longValue

multiply

multiply