org.ojalgo.matrix

Class QuaternionMatrix

java.lang.Object

org.ojalgo.matrix.QuaternionMatrix

All Implemented Interfaces:

Group, Group.Additive<QuaternionMatrix>, NormedVectorSpace<QuaternionMatrix,Quaternion>, Operation, Operation.Addition<QuaternionMatrix>, Operation.Multiplication<QuaternionMatrix>, Operation.Subtraction<QuaternionMatrix>, ScalarOperation, ScalarOperation.Addition<QuaternionMatrix,Quaternion>, ScalarOperation.Division<QuaternionMatrix,Quaternion>, ScalarOperation.Multiplication<QuaternionMatrix,Quaternion>, ScalarOperation.Subtraction<QuaternionMatrix,Quaternion>, VectorSpace<QuaternionMatrix,Quaternion>, Access1D<Quaternion>, Access1D.Aggregatable<Quaternion>, Access1D.Elements, Access2D<Quaternion>, Access2D.Aggregatable<Quaternion>, Access2D.Collectable<Quaternion,PhysicalStore<Quaternion>>, Access2D.Elements, Structure1D, Structure2D, Structure2D.ReducibleTo1D<QuaternionMatrix>, NumberContext.Enforceable<QuaternionMatrix>

public final class QuaternionMatrix
extends Object

QuaternionMatrix

Author:

apete

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	QuaternionMatrix.DenseReceiver
static class	QuaternionMatrix.Factory
static class	QuaternionMatrix.LogicalBuilder
static class	QuaternionMatrix.SparseReceiver

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

Group.Additive<S>, Group.Multiplicative<S>

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.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.structure.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.structure.Structure2D

Structure2D.IntRowColumn, Structure2D.Logical<S extends Structure2D,B extends Structure2D.Logical<S,?>>, 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.structure.Structure1D

Structure1D.BasicMapper<T>, Structure1D.IndexCallback, Structure1D.IndexMapper<T>, Structure1D.IntIndex, Structure1D.LongIndex, Structure1D.LoopCallback

Field Summary

Fields

Modifier and Type	Field and Description
static QuaternionMatrix.Factory	FACTORY

Method Summary

Modifier and Type	Method and Description
M	add(double scalarAddend)
M	add(M addend)
M	add(Number scalarAddend)
N	aggregateColumn(long row, long col, Aggregator aggregator)
N	aggregateDiagonal(long row, long col, Aggregator aggregator)
N	aggregateRange(long first, long limit, Aggregator aggregator)
N	aggregateRow(long row, long col, Aggregator aggregator)
static <M extends org.ojalgo.matrix.BasicMatrix<?,M>> double	calculateFrobeniusNorm(M matrix) The Frobenius norm is the square root of the sum of the squares of each element, or the square root of the sum of the square of the singular values.
static <M extends org.ojalgo.matrix.BasicMatrix<?,M>> double	calculateInfinityNorm(M matrix)
static <M extends org.ojalgo.matrix.BasicMatrix<?,M>> double	calculateOneNorm(M matrix)
M	conjugate() This method will (most likely) be moved to some other interface in the future! Just have to figure out where it fits...
QuaternionMatrix.DenseReceiver	copy()
long	count() count() == countRows() * countColumns()
long	countColumns()
long	countRows()
M	divide(double scalarDivisor)
M	divide(Number scalarDivisor)
double	doubleValue(long index)
double	doubleValue(long i, long j) Extracts one element of this matrix as a double.
M	enforce(NumberContext context)
boolean	equals(Access2D<?> another, NumberContext precision)
boolean	equals(Object other)
void	flushCache() BasicMatrix instances are intended to be immutable.
N	get(long index)
N	get(long aRow, long aColumn)
Scalar<N>	getCondition() Matrix condition (2-norm)
Scalar<N>	getDeterminant()
List<Eigenvalue.Eigenpair>	getEigenpairs()
int	getRank() The rank of a matrix is the (maximum) number of linearly independent rows or columns it contains.
Scalar<N>	getTrace() The sum of the diagonal elements.
int	hashCode()
M	invert() About inverting matrices:
boolean	isAbsolute(long row, long col)
boolean	isFullRank()
boolean	isHermitian()
boolean	isSmall(double comparedTo)
boolean	isSmall(long row, long col, double comparedTo)
boolean	isSymmetric()
QuaternionMatrix.LogicalBuilder	logical()
M	multiply(double scalarMultiplicand)
M	multiply(M multiplicand)
M	multiply(Number scalarMultiplicand)
M	negate() The additive inverse of this.
double	norm() The Frobenius norm is the square root of the sum of the squares of each element, or the square root of the sum of the square of the singular values.
M	reduceColumns(Aggregator aggregator)
M	reduceRows(Aggregator aggregator)
M	signum() this == this.signum().multiply(this.norm())
M	solve(Access2D<?> rhs) This method solves a system of linear equations: [this][X]=[rhs].
M	subtract(double scalarSubtrahend)
M	subtract(M subtrahend)
M	subtract(Number scalarSubtrahend)
void	supplyTo(PhysicalStore<N> receiver)
Scalar<N>	toScalar(long row, long col) Extracts one element of this matrix as a Scalar.
String	toString()
M	transpose() Transposes this matrix.

Methods inherited from class java.lang.Object

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

Methods inherited from interface org.ojalgo.structure.Access2D

asCollectable2D, asPrimitive2D, byteValue, byteValue, columns, elements, equals, floatValue, floatValue, intValue, intValue, longValue, longValue, newPrimitiveColumnCollectable, newPrimitiveRowCollectable, rows, shortValue, shortValue, toRawCopy2D, toString, wrap, wrap

Methods inherited from interface org.ojalgo.structure.Access1D

asCollectable1D, asPrimitive1D, axpy, dot, equals, hashCode, nonzeros, supplyTo, toRawCopy1D, toString, wrap, wrap, wrap

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

isAbsolute, isColumnSmall, isColumnSmall, isRowSmall, isRowSmall, isSmall

Methods inherited from interface org.ojalgo.structure.Access1D.Elements

isAllSmall

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

aggregateColumn, aggregateDiagonal, aggregateRow, reduceColumns, reduceRows

Methods inherited from interface org.ojalgo.structure.Access1D.Aggregatable

aggregateAll

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

collect

Methods inherited from interface org.ojalgo.structure.Structure2D

column, column, column, column, column, count, 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.structure.Structure1D

index, loopAll, loopMatching, loopRange, mapper, size

Field Detail

FACTORY

public static final QuaternionMatrix.Factory FACTORY

Method Detail

copy

public QuaternionMatrix.DenseReceiver copy()

Returns:

A fully mutable matrix builder with the elements initially set to a copy of this matrix.

logical

public QuaternionMatrix.LogicalBuilder logical()

calculateFrobeniusNorm

public static <M extends org.ojalgo.matrix.BasicMatrix<?,M>> double calculateFrobeniusNorm(M matrix)

The Frobenius norm is the square root of the sum of the squares of each element, or the square root of the sum of the square of the singular values.

Returns:

The matrix' Frobenius norm

calculateInfinityNorm

public static <M extends org.ojalgo.matrix.BasicMatrix<?,M>> double calculateInfinityNorm(M matrix)

Returns:

The inf-norm or maximum row sum

calculateOneNorm

public static <M extends org.ojalgo.matrix.BasicMatrix<?,M>> double calculateOneNorm(M matrix)

Returns:

The 1-norm or maximum column sum

add

public M add(double scalarAddend)

Specified by:

add in interface ScalarOperation.Addition<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this + scalarAddend.

add

public M add(M addend)

Specified by:

add in interface Operation.Addition<M extends org.ojalgo.matrix.BasicMatrix<N,M>>

Parameters:

addend - What to add

Returns:

this + addend

add

public M add(Number scalarAddend)

Specified by:

add in interface ScalarOperation.Addition<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this + scalarAddend.

aggregateColumn

public N aggregateColumn(long row,
                         long col,
                         Aggregator aggregator)

Specified by:

aggregateColumn in interface Access2D.Aggregatable<N extends Number>

aggregateDiagonal

public N aggregateDiagonal(long row,
                           long col,
                           Aggregator aggregator)

Specified by:

aggregateDiagonal in interface Access2D.Aggregatable<N extends Number>

aggregateRange

public N aggregateRange(long first,
                        long limit,
                        Aggregator aggregator)

Specified by:

aggregateRange in interface Access1D.Aggregatable<N extends Number>

aggregateRow

public N aggregateRow(long row,
                      long col,
                      Aggregator aggregator)

Specified by:

aggregateRow in interface Access2D.Aggregatable<N extends Number>

conjugate

public M 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<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

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 M divide(double scalarDivisor)

Specified by:

divide in interface ScalarOperation.Division<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this / scalarDivisor.

divide

public M divide(Number scalarDivisor)

Specified by:

divide in interface ScalarOperation.Division<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this / scalarDivisor.

doubleValue

public double doubleValue(long index)

Specified by:

doubleValue in interface Access1D<N extends Number>

Specified by:

doubleValue in interface Access2D<N extends Number>

doubleValue

public double doubleValue(long i,
                          long j)

Description copied from interface: Access2D

Extracts one element of this matrix as a double.

Specified by:

doubleValue in interface Access2D<N extends Number>

Parameters:

i - A row index.

j - A column index.

Returns:

One matrix element

enforce

public M enforce(NumberContext context)

Specified by:

enforce in interface NumberContext.Enforceable<M extends org.ojalgo.matrix.BasicMatrix<N,M>>

equals

public boolean equals(Access2D<?> another,
                      NumberContext precision)

Returns:

true if the frobenius norm of the difference between [this] and [another] is zero within the limits of [precision].

equals

public boolean equals(Object other)

Overrides:

equals in class Object

flushCache

public void flushCache()

BasicMatrix instances are intended to be immutable. If they are it is possible to cache (partial) calculation results. Calling this method should flush any cached calculation results.

get

public N get(long index)

Specified by:

get in interface Access1D<N extends Number>

Specified by:

get in interface Access2D<N extends Number>

get

public N get(long aRow,
             long aColumn)

Specified by:

get in interface Access2D<N extends Number>

getCondition

public Scalar<N> getCondition()

Matrix condition (2-norm)

Returns:

ratio of largest to smallest singular value.

getDeterminant

public Scalar<N> getDeterminant()

Returns:

The matrix' determinant.

getEigenpairs

public List<Eigenvalue.Eigenpair> getEigenpairs()

getRank

public int getRank()

The rank of a matrix is the (maximum) number of linearly independent rows or columns it contains. It is also equal to the number of nonzero singular values of the matrix.

Returns:

The matrix' rank.

See Also:

MatrixDecomposition.RankRevealing

getTrace

public Scalar<N> getTrace()

The sum of the diagonal elements.

Returns:

The matrix' trace.

hashCode

public int hashCode()

Overrides:

hashCode in class Object

invert

public M invert()

About inverting matrices:

• "right inverse": [this][right inverse]=[I]. You may calculate it using solve(Access2D).
• "left inverse": [left inverse][this]=[I]. You may calculate it using solve(Access2D) and transposing.
• "generalised inverse": [this][generalised inverse][this]=[this]. Note that if [this] is singular or non-square, then [generalised inverse] is not unique.
• "pseudoinverse": The generalised inverse (there are typically/possibly many) with the smallest frobenius norm is called the pseudoinverse. You may calculate it using the QR or SingularValue decompositions.
• "inverse":
  • If [left inverse]=[right inverse] then it is also [inverse].
  • If [this] is square and has full rank then the [generalised inverse] is unique, with the [pseudoinverse] given, and equal to [inverse].

Returns:

The "best possible" inverse....

isAbsolute

public boolean isAbsolute(long row,
                          long col)

Specified by:

isAbsolute in interface Access2D.Elements

See Also:

Scalar.isAbsolute()

isFullRank

public boolean isFullRank()

Returns:

true if getRank() == min(countRows(), countColumns())

See Also:

MatrixDecomposition.RankRevealing

isHermitian

public boolean isHermitian()

isSmall

public boolean isSmall(double comparedTo)

Specified by:

isSmall in interface NormedVectorSpace<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Parameters:

comparedTo - What to compare with

Returns:

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

isSmall

public boolean isSmall(long row,
                       long col,
                       double comparedTo)

Specified by:

isSmall in interface Access2D.Elements

See Also:

NormedVectorSpace.isSmall(double)

isSymmetric

public boolean isSymmetric()

multiply

public M multiply(double scalarMultiplicand)

Specified by:

multiply in interface ScalarOperation.Multiplication<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this * scalarMultiplicand.

multiply

public M multiply(M multiplicand)

Specified by:

multiply in interface Operation.Multiplication<M extends org.ojalgo.matrix.BasicMatrix<N,M>>

Parameters:

multiplicand - The multiplicand

Returns:

this * multiplicand.

multiply

public M multiply(Number scalarMultiplicand)

Specified by:

multiply in interface ScalarOperation.Multiplication<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this * multiplicand.

negate

public M negate()

Description copied from interface: Group.Additive

The additive inverse of this.

Specified by:

negate in interface Group.Additive<M extends org.ojalgo.matrix.BasicMatrix<N,M>>

Returns:

-this.

norm

public double norm()

The Frobenius norm is the square root of the sum of the squares of each element, or the square root of the sum of the square of the singular values. This definition fits the requirements of NormedVectorSpace.norm().

Specified by:

norm in interface NormedVectorSpace<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

The matrix' Frobenius norm

reduceColumns

public M reduceColumns(Aggregator aggregator)

Specified by:

reduceColumns in interface Structure2D.ReducibleTo1D<M extends org.ojalgo.matrix.BasicMatrix<N,M>>

reduceRows

public M reduceRows(Aggregator aggregator)

Specified by:

reduceRows in interface Structure2D.ReducibleTo1D<M extends org.ojalgo.matrix.BasicMatrix<N,M>>

signum

public M signum()

Description copied from interface: NormedVectorSpace

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

Specified by:

signum in interface NormedVectorSpace<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

A unit "vector"

solve

public M solve(Access2D<?> rhs)

This method solves a system of linear equations: [this][X]=[rhs]. A combination of columns in [this] should produce a column(s) in [rhs]. It is ok for [rhs] to have more than 1 column.

• If the problem is over-qualified an approximate solution is returned.
• If the problem is under-qualified one possible solution is returned.

Remember that: [X][this]=[rhs] is equivalent to [this]^T[X]^T=[rhs]^T

Parameters:

rhs - The right hand side of the equation.

Returns:

The solution, [X].

subtract

public M subtract(double scalarSubtrahend)

Specified by:

subtract in interface ScalarOperation.Subtraction<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this - scalarSubtrahend.

subtract

public M subtract(M subtrahend)

Specified by:

subtract in interface Operation.Subtraction<M extends org.ojalgo.matrix.BasicMatrix<N,M>>

Parameters:

subtrahend - The subtrahend

Returns:

this - subtrahend.

subtract

public M subtract(Number scalarSubtrahend)

Specified by:

subtract in interface ScalarOperation.Subtraction<M extends org.ojalgo.matrix.BasicMatrix<N,M>,N extends Number>

Returns:

this - scalarSubtrahend.

supplyTo

public void supplyTo(PhysicalStore<N> receiver)

Specified by:

supplyTo in interface Access2D.Collectable<N extends Number,PhysicalStore<N extends Number>>

toScalar

public Scalar<N> toScalar(long row,
                          long col)

Extracts one element of this matrix as a Scalar.

Parameters:

row - A row index.

col - A column index.

Returns:

One matrix element

toString

public final String toString()

Overrides:

toString in class Object

transpose

public M transpose()

Transposes this matrix. For complex matrices conjugate() and transpose() are NOT EQUAL.

Returns:

A matrix that is the transpose of this matrix.

See Also:

BasicMatrix.conjugate()