org.ojalgo.matrix.jama

Class JamaEigenvalue

java.lang.Object

org.ojalgo.matrix.jama.JamaEigenvalue

All Implemented Interfaces:

Eigenvalue<Double>, MatrixDecomposition<Double>, DecompositionTask<Double>, DeterminantTask<Double>, InverterTask<Double>, SolverTask<Double>

Direct Known Subclasses:

JamaEigenvalue.General, JamaEigenvalue.Nonsymmetric, JamaEigenvalue.Symmetric

public abstract class JamaEigenvalue
extends Object
implements Eigenvalue<Double>

This class adapts JAMA's EigenvalueDecomposition to ojAlgo's Eigenvalue interface.

Author:

apete

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	JamaEigenvalue.General
static class	JamaEigenvalue.Nonsymmetric
static class	JamaEigenvalue.Symmetric

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.task.InverterTask

InverterTask.Factory<N extends Number>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.task.SolverTask

SolverTask.Factory<N extends Number>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.decomposition.task.DeterminantTask

DeterminantTask.Factory<N extends Number>

Field Summary

Fields inherited from interface org.ojalgo.matrix.decomposition.task.InverterTask

BIG, COMPLEX, PRIMITIVE

Fields inherited from interface org.ojalgo.matrix.decomposition.task.SolverTask

BIG, COMPLEX, PRIMITIVE

Fields inherited from interface org.ojalgo.matrix.decomposition.task.DeterminantTask

BIG, COMPLEX, PRIMITIVE

Method Summary

Modifier and Type	Method and Description
Double	calculateDeterminant(Access2D<Double> matrix)
boolean	compute(Access2D<?> aStore)
boolean	compute(Access2D<?> matrix, boolean eigenvaluesOnly)
boolean	equals(MatrixDecomposition<Double> other, NumberContext context)
boolean	equals(MatrixStore<Double> aStore, NumberContext context)
JamaMatrix	getD() The only requirements on [D] are that it should contain the eigenvalues and that [A][V] = [V][D].
Double	getDeterminant() A matrix' determinant is the product of its eigenvalues.
Array1D<ComplexNumber>	getEigenvalues() Even for real matrices the eigenvalues are potentially complex numbers.
JamaMatrix	getInverse() The output must be a "right inverse" and a "generalised inverse".
MatrixStore<Double>	getInverse(DecompositionStore<Double> preallocated) Makes no use of preallocated at all.
ComplexNumber	getTrace() A matrix' trace is the sum of the diagonal elements.
JamaMatrix	getV() The columns of [V] represent the eigenvectors of [A] in the sense that [A][V] = [V][D].
MatrixStore<Double>	invert(MatrixStore<Double> original) The output must be a "right inverse" and a "generalised inverse".
MatrixStore<Double>	invert(MatrixStore<Double> original, DecompositionStore<Double> preallocated) Implementiong this method is optional.
boolean	isAspectRatioNormal()
boolean	isComputed()
boolean	isFullSize()
boolean	isHermitian() If [A] is hermitian then [V][D][V]-1 becomes [Q][D][Q]H...
boolean	isOrdered() The eigenvalues in D (and the eigenvectors in V) are not necessarily ordered.
boolean	isSolvable()
DecompositionStore<Double>	preallocate(Access2D<Double> template) Implementiong this method is optional.
DecompositionStore<Double>	preallocate(Access2D<Double> templateBody, Access2D<Double> templateRHS) Implementiong this method is optional.
MatrixStore<Double>	reconstruct()
void	reset() Delete computed results, and resets attributes to default values
JamaMatrix	solve(Access2D<Double> rhs) [A][X]=[B] or [this][return]=[aRHS]
MatrixStore<Double>	solve(Access2D<Double> body, Access2D<Double> rhs) [A][X]=[B] or [this][return]=[aRHS]
MatrixStore<Double>	solve(Access2D<Double> body, Access2D<Double> rhs, DecompositionStore<Double> preallocated) Implementiong this method is optional.
JamaMatrix	solve(Access2D<Double> rhs, DecompositionStore<Double> preallocated) Makes no use of preallocated at all.
String	toString()

Methods inherited from class java.lang.Object

equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface org.ojalgo.matrix.decomposition.MatrixDecomposition

compute, equals, getInverse, preallocate, solve

Methods inherited from interface org.ojalgo.matrix.decomposition.task.InverterTask

invert, invert, preallocate

Methods inherited from interface org.ojalgo.matrix.decomposition.task.SolverTask

solve, solve

Method Detail

calculateDeterminant

public Double calculateDeterminant(Access2D<Double> matrix)

Specified by:

calculateDeterminant in interface DeterminantTask<Double>

compute

public boolean compute(Access2D<?> matrix,
                       boolean eigenvaluesOnly)

Specified by:

compute in interface Eigenvalue<Double>

Parameters:

matrix - A matrix to decompose

eigenvaluesOnly - No need to calculate eigenvectors

Returns:

true/false if the computation succeeded or not

equals

public boolean equals(MatrixStore<Double> aStore,
                      NumberContext context)

Specified by:

equals in interface MatrixDecomposition<Double>

getD

public JamaMatrix getD()

Description copied from interface: Eigenvalue

The only requirements on [D] are that it should contain the eigenvalues and that [A][V] = [V][D]. The ordering of the eigenvalues is not specified.

• If [A] is real and symmetric then [D] is (purely) diagonal with real eigenvalues.
• If [A] is real but not symmetric then [D] is block-diagonal with real eigenvalues in 1-by-1 blocks and complex eigenvalues in 2-by-2 blocks.
• If [A] is complex then [D] is (purely) diagonal with complex eigenvalues.

Specified by:

getD in interface Eigenvalue<Double>

Returns:

The (block) diagonal eigenvalue matrix.

getDeterminant

public Double getDeterminant()

Description copied from interface: Eigenvalue

A matrix' determinant is the product of its eigenvalues.

Specified by:

getDeterminant in interface Eigenvalue<Double>

Returns:

The matrix' determinant

getEigenvalues

public Array1D<ComplexNumber> getEigenvalues()

Description copied from interface: Eigenvalue

Even for real matrices the eigenvalues are potentially complex numbers. Typically they need to be expressed as complex numbers when [A] is not symmetric.

The eigenvalues in this array should be ordered in descending order - largest (modulus) first.

Specified by:

getEigenvalues in interface Eigenvalue<Double>

Returns:

The eigenvalues in an ordered array.

getInverse

public JamaMatrix getInverse()

Description copied from interface: MatrixDecomposition

The output must be a "right inverse" and a "generalised inverse".

Specified by:

getInverse in interface MatrixDecomposition<Double>

See Also:

BasicMatrix.invert()

getTrace

public ComplexNumber getTrace()

Description copied from interface: Eigenvalue

A matrix' trace is the sum of the diagonal elements. It is also the sum of the eigenvalues. This method should return the sum of the eigenvalues.

Specified by:

getTrace in interface Eigenvalue<Double>

Returns:

The matrix' trace

getV

public JamaMatrix getV()

Description copied from interface: Eigenvalue

The columns of [V] represent the eigenvectors of [A] in the sense that [A][V] = [V][D].

Specified by:

getV in interface Eigenvalue<Double>

Returns:

The eigenvector matrix.

isAspectRatioNormal

public boolean isAspectRatioNormal()

isComputed

public boolean isComputed()

Specified by:

isComputed in interface MatrixDecomposition<Double>

Returns:

true if computation has been attemped; false if not.

See Also:

MatrixDecomposition.compute(Access2D), MatrixDecomposition.isSolvable()

isFullSize

public boolean isFullSize()

Specified by:

isFullSize in interface MatrixDecomposition<Double>

Returns:

True if the implementation generates a full sized decomposition.

isHermitian

public boolean isHermitian()

Description copied from interface: Eigenvalue

If [A] is hermitian then [V][D][V]^-1 becomes [Q][D][Q]^H...

Specified by:

isHermitian in interface Eigenvalue<Double>

isOrdered

public boolean isOrdered()

Description copied from interface: Eigenvalue

The eigenvalues in D (and the eigenvectors in V) are not necessarily ordered. This is a property of the algorithm/implementation, not the data.

Specified by:

isOrdered in interface Eigenvalue<Double>

Returns:

true if they are ordered

isSolvable

public boolean isSolvable()

Specified by:

isSolvable in interface MatrixDecomposition<Double>

Returns:

true if it is ok to call MatrixDecomposition.solve(Access2D) (computation was successful); false if not

See Also:

MatrixDecomposition.solve(Access2D), MatrixDecomposition.isComputed()

reconstruct

public MatrixStore<Double> reconstruct()

Specified by:

reconstruct in interface MatrixDecomposition<Double>

reset

public void reset()

Description copied from interface: MatrixDecomposition

Delete computed results, and resets attributes to default values

Specified by:

reset in interface MatrixDecomposition<Double>

solve

public JamaMatrix solve(Access2D<Double> rhs)

Description copied from interface: MatrixDecomposition

[A][X]=[B] or [this][return]=[aRHS]

Specified by:

solve in interface MatrixDecomposition<Double>

toString

public String toString()

Overrides:

toString in class Object

compute

public final boolean compute(Access2D<?> aStore)

Specified by:

compute in interface MatrixDecomposition<Double>

Parameters:

aStore - A matrix to decompose

Returns:

true if the computation suceeded; false if not

equals

public final boolean equals(MatrixDecomposition<Double> other,
                            NumberContext context)

Specified by:

equals in interface MatrixDecomposition<Double>

getInverse

public final MatrixStore<Double> getInverse(DecompositionStore<Double> preallocated)

Makes no use of preallocated at all. Simply delegates to getInverse().

Specified by:

getInverse in interface MatrixDecomposition<Double>

Parameters:

preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/final/correct solution.

Returns:

The inverse

See Also:

MatrixDecomposition.getInverse(org.ojalgo.matrix.decomposition.DecompositionStore)

invert

public final MatrixStore<Double> invert(MatrixStore<Double> original)

Description copied from interface: InverterTask

The output must be a "right inverse" and a "generalised inverse".

Specified by:

invert in interface InverterTask<Double>

See Also:

BasicMatrix.invert()

invert

public final MatrixStore<Double> invert(MatrixStore<Double> original,
                                        DecompositionStore<Double> preallocated)

Description copied from interface: InverterTask

Implementiong this method is optional.

Exactly how a specific implementation makes use of preallocated is not specified by this interface. It must be documented for each implementation.

Should produce the same results as calling #getInverse().

Specified by:

invert in interface InverterTask<Double>

preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/final/correct solution.

Returns:

The inverse

preallocate

public final DecompositionStore<Double> preallocate(Access2D<Double> template)

Description copied from interface: InverterTask

Implementiong this method is optional.

Will create a DecompositionStore instance suitable for use with #solve(Access2D, DecompositionStore). When solving an equation system [A][X]=[B] ([mxn][nxb]=[mxb]) the preallocated memory/matrix will typically be either mxb or nxb (if A is square then there is no doubt).

Specified by:

preallocate in interface InverterTask<Double>

Returns:

preallocate

public final DecompositionStore<Double> preallocate(Access2D<Double> templateBody,
                                                    Access2D<Double> templateRHS)

Description copied from interface: MatrixDecomposition

Implementiong this method is optional.

Will create a DecompositionStore instance suitable for use with MatrixDecomposition.solve(Access2D, DecompositionStore). When solving an equation system [A][X]=[B] ([mxn][nxb]=[mxb]) the preallocated memory/matrix will typically be either mxb or nxb (if A is square then there is no doubt).

Specified by:

preallocate in interface MatrixDecomposition<Double>

Specified by:

preallocate in interface SolverTask<Double>

Returns:

solve

public final MatrixStore<Double> solve(Access2D<Double> body,
                                       Access2D<Double> rhs)

Description copied from interface: SolverTask

[A][X]=[B] or [this][return]=[aRHS]

Specified by:

solve in interface SolverTask<Double>

solve

public final MatrixStore<Double> solve(Access2D<Double> body,
                                       Access2D<Double> rhs,
                                       DecompositionStore<Double> preallocated)

Description copied from interface: SolverTask

Implementiong this method is optional.

Exactly how a specific implementation makes use of preallocated is not specified by this interface. It must be documented for each implementation.

Should produce the same results as calling #solve(Access2D).

Specified by:

solve in interface SolverTask<Double>

rhs - The Right Hand Side, wont be modfied

preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/final/correct solution.

Returns:

The solution

solve

public final JamaMatrix solve(Access2D<Double> rhs,
                              DecompositionStore<Double> preallocated)

Makes no use of preallocated at all. Simply delegates to solve(Access2D).

Specified by:

solve in interface MatrixDecomposition<Double>

Parameters:

rhs - The Right Hand Side, wont be modfied

preallocated - Preallocated memory for the results, possibly some intermediate results. You must assume this is modified, but you cannot assume it will contain the full/final/correct solution.

Returns:

The solution

See Also:

MatrixDecomposition.solve(Access2D, org.ojalgo.matrix.decomposition.DecompositionStore)