Class RawEigenvalue.Symmetric

java.lang.Object

org.ojalgo.matrix.decomposition.AbstractDecomposition<Double, R064Store>

org.ojalgo.matrix.decomposition.RawDecomposition

org.ojalgo.matrix.decomposition.RawEigenvalue

org.ojalgo.matrix.decomposition.RawEigenvalue.Symmetric

All Implemented Interfaces:

Eigenvalue<Double>, Eigenvalue.Spectral<Double>, MatrixDecomposition<Double>, MatrixDecomposition.Determinant<Double>, MatrixDecomposition.EconomySize<Double>, MatrixDecomposition.Hermitian<Double>, MatrixDecomposition.Ordered<Double>, MatrixDecomposition.RankRevealing<Double>, MatrixDecomposition.Solver<Double>, MatrixDecomposition.Values<Double>, SingularValue<Double>, Provider2D, Provider2D.Condition, Provider2D.Determinant<Double>, Provider2D.Eigenpairs, Provider2D.Inverse<Optional<MatrixStore<Double>>>, Provider2D.Rank, Provider2D.Solution<Optional<MatrixStore<Double>>>, DeterminantTask<Double>, InverterTask<Double>, MatrixTask<Double>, SolverTask<Double>, InvertibleFactor<Double>, Structure1D, Structure2D

Enclosing class:

RawEigenvalue

static final class RawEigenvalue.Symmetric
extends RawEigenvalue
implements Eigenvalue.Spectral<Double>

Nested Class Summary

Nested classes/interfaces inherited from class RawEigenvalue

RawEigenvalue.Dynamic, RawEigenvalue.General, RawEigenvalue.Symmetric

Nested classes/interfaces inherited from interface Eigenvalue

Eigenvalue.Eigenpair, Eigenvalue.Factory<N>, Eigenvalue.Generalisation, Eigenvalue.Generalised<N>, Eigenvalue.Spectral<N>

Nested classes/interfaces inherited from interface InvertibleFactor

InvertibleFactor.IdentityFactor<N>

Nested classes/interfaces inherited from interface MatrixDecomposition

MatrixDecomposition.Determinant<N>, MatrixDecomposition.EconomySize<N>, MatrixDecomposition.Factory<D>, MatrixDecomposition.Hermitian<N>, MatrixDecomposition.Ordered<N>, MatrixDecomposition.Pivoting<N>, MatrixDecomposition.RankRevealing<N>, MatrixDecomposition.Solver<N>, MatrixDecomposition.Updatable<N>, MatrixDecomposition.Values<N>

Nested classes/interfaces inherited from interface Provider2D

Provider2D.Condition, Provider2D.Determinant<N>, Provider2D.Eigenpairs, Provider2D.Hermitian, Provider2D.Inverse<M>, Provider2D.Rank, Provider2D.Solution<M>, Provider2D.Symmetric, Provider2D.Trace<N>

Nested classes/interfaces inherited from interface SingularValue

SingularValue.Factory<N>

Nested classes/interfaces inherited from interface Structure1D

Structure1D.BasicMapper<T>, Structure1D.IndexMapper<T>, Structure1D.IntIndex, 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 MatrixStore<Double>	myInverse
private MatrixStore<Double>	myS
private MatrixStore<Double>	myU

Fields inherited from interface Eigenvalue

C128, DESCENDING_NORM, H256, Q128, R064, R128

Fields inherited from interface MatrixDecomposition

TYPICAL

Fields inherited from interface SingularValue

C128, H256, Q128, R064, R128

Constructor Summary

Constructors

Constructor	Description
Symmetric()

Method Summary

Modifier and Type	Method	Description
void	btran(double[] arg)
void	btran(PhysicalStore<Double> arg)	Backwards-transformation
int	countSignificant(double threshold)
protected boolean	doDecompose(double[][] data, boolean valuesOnly)
void	ftran(double[] arg)
void	ftran(PhysicalStore<Double> arg)	Forward-transformation
double	getCondition()	The condition number.
MatrixStore<Double>	getCovariance()
double	getFrobeniusNorm()	Sometimes also called the Schatten 2-norm or Hilbert-Schmidt norm.
MatrixStore<Double>	getInverse()	The output must be a "right inverse" and a "generalised inverse".
MatrixStore<Double>	getInverse(PhysicalStore<Double> preallocated)	Implementing this method is optional.
double	getKyFanNorm(int k)	Ky Fan k-norm.
double	getOperatorNorm()
double	getRankThreshold()
MatrixStore<Double>	getS()
Array1D<Double>	getSingularValues()
MatrixStore<Double>	getSolution(Access2D.Collectable<Double, ? super PhysicalStore<Double>> rhs, PhysicalStore<Double> preallocated)	Implementing this method is optional.
double	getTraceNorm()
MatrixStore<Double>	getU()	If [A] is m-by-n and its rank is r, then: The first r columns of [U] span the column space, range or image of [A]. The last m-r columns of [U] span the left nullspace or cokernel of [A]. Calculating the QR decomposition of [A] is a faster alternative.
MatrixStore<Double>	invert(Access2D<?> original, PhysicalStore<Double> preallocated)	Exactly how (if at all) a specific implementation makes use of preallocated is not specified by this interface.
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()	Please note that producing a pseudoinverse and/or a least squares solution is ok! The return value, of this method, is not an indication of if the decomposed matrix is square, has full rank, is postive definite or whatever.
boolean	isSPD()	A symmetric (Hermitian) matrix is positive definite if all its eigenvalues are positive.
protected MatrixStore<Double>	makeD(double[] d, double[] e)
PhysicalStore<Double>	preallocate(int nbEquations, int nbVariables, int nbSolutions)
MatrixStore<Double>	reconstruct()
void	reset()	Delete computed results, and resets attributes to default values
MatrixStore<Double>	solve(Access2D<?> body, Access2D<?> rhs, PhysicalStore<Double> preallocated)	Exactly how (if at all) a specific implementation makes use of preallocated is not specified by this interface.

Methods inherited from class RawEigenvalue

calculateDeterminant, checkSolvability, computeValuesOnly, decompose, doGeneral, doSymmetric, getD, getDeterminant, getEigenvalues, getEigenvalues, getImaginaryParts, getRealParts, getTrace, getV, isValuesOnly

Methods inherited from class RawDecomposition

checkSymmetry, getColDim, getInternalData, getInternalStore, getRowDim, make, newRawStore, reset, wrap

Methods inherited from class AbstractDecomposition

aggregator, applyPivotOrder, applyReverseOrder, collect, computed, copyColumn, copyRow, function, getDimensionalEpsilon, isAspectRatioNormal, isComputed, makeArray, makeDiagonal, makeEye, makeHouseholder, makeIdentity, makeRotation, makeRotation, makeZero, makeZero, scalar, wrap

Methods inherited from class Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface DeterminantTask

calculateDeterminant

Methods inherited from interface Eigenvalue

getD, getEigenpair, getEigenpairs, getEigenvalues, getEigenvalues, getEigenvectors, getTrace, getV

Methods inherited from interface InverterTask

invert, preallocate

Methods inherited from interface MatrixDecomposition

decompose, isComputed

Methods inherited from interface MatrixDecomposition.Determinant

getDeterminant, toDeterminantProvider

Methods inherited from interface MatrixDecomposition.Hermitian

checkAndDecompose

Methods inherited from interface MatrixDecomposition.RankRevealing

getRank, isFullRank

Methods inherited from interface MatrixDecomposition.Solver

compute, getSolution, invert, preallocate, solve, toInverseProvider, toSolutionProvider

Methods inherited from interface MatrixDecomposition.Values

computeValuesOnly

Methods inherited from interface SingularValue

getD, getSingularValues, getV, reconstruct

Methods inherited from interface SolverTask

preallocate, solve

Methods inherited from interface Structure2D

count, countColumns, countRows, firstInColumn, firstInRow, getColDim, getMaxDim, getMinDim, getRowDim, isEmpty, isFat, isScalar, isSquare, isTall, isVector, limitOfColumn, limitOfRow, size

Field Details

myInverse

private transient MatrixStore<Double> myInverse

myS

private transient MatrixStore<Double> myS

myU

private transient MatrixStore<Double> myU

Constructor Details

Symmetric

Symmetric()

Method Details

btran

public void btran(double[] arg)

Specified by:

btran in interface InvertibleFactor<Double>

See Also:

• InvertibleFactor.IdentityFactor.btran(PhysicalStore)

btran

public void btran(PhysicalStore<Double> arg)

Description copied from interface: InvertibleFactor

Backwards-transformation

Solve [x]^T[A] = [b]^T (equivalent to [A]^T[x] = [b]) by transforming [b] into [x] in-place.

Specified by:

btran in interface InvertibleFactor<Double>

Parameters:

arg - [b] transformed into [x]

countSignificant

public int countSignificant(double threshold)

Specified by:

countSignificant in interface MatrixDecomposition.RankRevealing<Double>

Parameters:

threshold - Significance limit

Returns:

The number of elements in the diagonal matrix that are greater than the threshold

ftran

public void ftran(double[] arg)

Specified by:

ftran in interface InvertibleFactor<Double>

See Also:

• InvertibleFactor.IdentityFactor.ftran(PhysicalStore)

ftran

public void ftran(PhysicalStore<Double> arg)

Description copied from interface: InvertibleFactor

Forward-transformation

Solve [A][x] = [b] by transforming [b] into [x] in-place.

Specified by:

ftran in interface InvertibleFactor<Double>

Specified by:

ftran in interface SingularValue<Double>

Parameters:

arg - [b] transformed into [x]

getCondition

public double getCondition()

Description copied from interface: SingularValue

The condition number.

Specified by:

getCondition in interface Provider2D.Condition

Specified by:

getCondition in interface SingularValue<Double>

Returns:

The largest singular value divided by the smallest singular value.

getCovariance

public MatrixStore<Double> getCovariance()

Specified by:

getCovariance in interface SingularValue<Double>

Returns:

[[A]^T[A]]^-1 Where [A] is the original matrix.

getFrobeniusNorm

public double getFrobeniusNorm()

Description copied from interface: SingularValue

Sometimes also called the Schatten 2-norm or Hilbert-Schmidt norm.

Specified by:

getFrobeniusNorm in interface SingularValue<Double>

Returns:

The square root of the sum of squares of the singular values.

getInverse

public MatrixStore<Double> getInverse()

Description copied from interface: MatrixDecomposition.Solver

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

Specified by:

getInverse in interface MatrixDecomposition.Solver<Double>

getInverse

public MatrixStore<Double> getInverse(PhysicalStore<Double> preallocated)

Description copied from interface: MatrixDecomposition.Solver

Implementing 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 MatrixDecomposition.Solver.getInverse().

Specified by:

getInverse in interface MatrixDecomposition.Solver<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. Use MatrixDecomposition.Solver.preallocate(int, int) or InverterTask.preallocate(Structure2D) to get a suitable instance.

Returns:

The inverse, this is where you get the solution

getKyFanNorm

public double getKyFanNorm(int k)

Description copied from interface: SingularValue

Ky Fan k-norm.

The first Ky Fan k-norm is the operator norm (the largest singular value), and the last is called the trace norm (the sum of all singular values).

Specified by:

getKyFanNorm in interface SingularValue<Double>

Parameters:

k - The number of singular values to add up.

Returns:

The sum of the k largest singular values.

getOperatorNorm

public double getOperatorNorm()

Specified by:

getOperatorNorm in interface SingularValue<Double>

Returns:

2-norm

getRankThreshold

public double getRankThreshold()

Specified by:

getRankThreshold in interface MatrixDecomposition.RankRevealing<Double>

getS

public MatrixStore<Double> getS()

Specified by:

getS in interface SingularValue<Double>

Returns:

The diagonal matrix of singular values.

getSingularValues

public Array1D<Double> getSingularValues()

Specified by:

getSingularValues in interface SingularValue<Double>

Returns:

The singular values ordered in descending order.

getSolution

public MatrixStore<Double> getSolution(Access2D.Collectable<Double, ? super PhysicalStore<Double>> rhs,
 PhysicalStore<Double> preallocated)

Description copied from interface: MatrixDecomposition.Solver

Implementing 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 MatrixDecomposition.Solver.getSolution(Collectable).

Specified by:

getSolution in interface MatrixDecomposition.Solver<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. Use SolverTask.preallocate(int, int, int) or SolverTask.preallocate(Structure2D, Structure2D) to get a suitable instance.

Returns:

The solution

getTraceNorm

public double getTraceNorm()

Specified by:

getTraceNorm in interface SingularValue<Double>

getU

public MatrixStore<Double> getU()

Description copied from interface: SingularValue

If [A] is m-by-n and its rank is r, then:

• The first r columns of [U] span the column space, range or image of [A].
• The last m-r columns of [U] span the left nullspace or cokernel of [A].

Calculating the QR decomposition of [A] is a faster alternative.

Specified by:

getU in interface SingularValue<Double>

invert

public MatrixStore<Double> invert(Access2D<?> original,
 PhysicalStore<Double> preallocated)
                           throws RecoverableCondition

Description copied from interface: InverterTask

Exactly how (if at all) 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 InverterTask.invert(Access2D).

Use InverterTask.preallocate(Structure2D) to obtain a suitbale preallocated.

Specified by:

invert in interface InverterTask<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

Throws:

RecoverableCondition - TODO

isFullSize

public boolean isFullSize()

Specified by:

isFullSize in interface MatrixDecomposition.EconomySize<Double>

Returns:

True if it will generate 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>

Specified by:

isOrdered in interface MatrixDecomposition.Ordered<Double>

Returns:

true if they are ordered

isSolvable

public boolean isSolvable()

Description copied from interface: MatrixDecomposition.Solver

Please note that producing a pseudoinverse and/or a least squares solution is ok! The return value, of this method, is not an indication of if the decomposed matrix is square, has full rank, is postive definite or whatever. It's that in combination with the specific decomposition algorithm's capabilities.

Specified by:

isSolvable in interface MatrixDecomposition.Solver<Double>

Overrides:

isSolvable in class AbstractDecomposition<Double, R064Store>

Returns:

true if this matrix decomposition is in a state to be able to deliver an inverse or an equation system solution (with some degree of numerical stability).

isSPD

public boolean isSPD()

Description copied from interface: Eigenvalue.Spectral

A symmetric (Hermitian) matrix is positive definite if all its eigenvalues are positive.

Specified by:

isSPD in interface Eigenvalue.Spectral<Double>

preallocate

public PhysicalStore<Double> preallocate(int nbEquations,
 int nbVariables,
 int nbSolutions)

Specified by:

preallocate in interface SolverTask<Double>

reconstruct

public MatrixStore<Double> reconstruct()

Specified by:

reconstruct in interface Eigenvalue<Double>

Specified by:

reconstruct in interface Eigenvalue.Spectral<Double>

Specified by:

reconstruct in interface MatrixDecomposition<Double>

Specified by:

reconstruct in interface SingularValue<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>

Overrides:

reset in class RawEigenvalue

solve

public MatrixStore<Double> solve(Access2D<?> body,
 Access2D<?> rhs,
 PhysicalStore<Double> preallocated)
                          throws RecoverableCondition

Description copied from interface: SolverTask

Exactly how (if at all) 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 SolverTask.solve(Access2D, Access2D).

Use SolverTask.preallocate(Structure2D, Structure2D) to obtain a suitbale preallocated.

Specified by:

solve in interface SolverTask<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/ /correct solution.

Returns:

The solution

Throws:

RecoverableCondition

doDecompose

protected boolean doDecompose(double[][] data,
 boolean valuesOnly)

Specified by:

doDecompose in class RawEigenvalue

makeD

protected MatrixStore<Double> makeD(double[] d,
 double[] e)

Overrides:

makeD in class RawEigenvalue