Class RawCholesky

java.lang.Object

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

org.ojalgo.matrix.decomposition.RawDecomposition

org.ojalgo.matrix.decomposition.RawCholesky

All Implemented Interfaces:

Cholesky<Double>, LDU<Double>, MatrixDecomposition<Double>, MatrixDecomposition.Determinant<Double>, MatrixDecomposition.Hermitian<Double>, MatrixDecomposition.Ordered<Double>, MatrixDecomposition.RankRevealing<Double>, MatrixDecomposition.Solver<Double>, Provider2D, Provider2D.Determinant<Double>, Provider2D.Inverse<Optional<MatrixStore<Double>>>, Provider2D.Rank, Provider2D.Solution<Optional<MatrixStore<Double>>>, DeterminantTask<Double>, InverterTask<Double>, MatrixTask<Double>, SolverTask<Double>, InvertibleFactor<Double>, Structure1D, Structure2D

final class RawCholesky
extends RawDecomposition
implements Cholesky<Double>

Nested Class Summary

Nested classes/interfaces inherited from interface Cholesky

Cholesky.Factory<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 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 double	myMaxDiag
private double	myMinDiag
private boolean	mySPD

Fields inherited from interface Cholesky

C128, H256, Q128, R064, R128

Fields inherited from interface MatrixDecomposition

TYPICAL

Constructor Summary

Constructors

Constructor	Description
RawCholesky()	Not recommended to use this constructor directly.

Method Summary

Modifier and Type	Method	Description
void	btran(double[] arg)
void	btran(PhysicalStore<Double> arg)	Backwards-transformation
Double	calculateDeterminant(Access2D<?> matrix)
boolean	checkAndDecompose(MatrixStore<Double> matrix)	Absolutely must check if the matrix is hermitian or not.
protected boolean	checkSolvability()
int	countSignificant(double threshold)
boolean	decompose(Access2D.Collectable<Double, ? super TransformableRegion<Double>> matrix)
private boolean	doDecompose(double[][] data, Access2D<?> input)
private MatrixStore<Double>	doGetInverse(PhysicalStore<Double> preallocated)
private MatrixStore<Double>	doSolve(PhysicalStore<Double> preallocated)
void	ftran(double[] arg)
void	ftran(PhysicalStore<Double> arg)	Forward-transformation
Double	getDeterminant()	A matrix' determinant is the product of its eigenvalues.
MatrixStore<Double>	getInverse(PhysicalStore<Double> preallocated)	Implementing this method is optional.
MatrixStore<Double>	getL()	Must implement either Cholesky.getL() or Cholesky.getR().
double	getRankThreshold()
MatrixStore<Double>	getSolution(Access2D.Collectable<Double, ? super PhysicalStore<Double>> rhs, PhysicalStore<Double> preallocated)	Implementing this method is optional.
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	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()	To use the Cholesky decomposition rather than the LU decomposition the matrix must be symmetric and positive definite.
PhysicalStore<Double>	preallocate(int nbEquations, int nbVariables, int nbSolutions)
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 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, reset, scalar, wrap

Methods inherited from class Object

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

Methods inherited from interface Cholesky

getR, reconstruct

Methods inherited from interface InverterTask

invert, preallocate

Methods inherited from interface LDU

isOrdered

Methods inherited from interface MatrixDecomposition

isComputed, reset

Methods inherited from interface MatrixDecomposition.Determinant

toDeterminantProvider

Methods inherited from interface MatrixDecomposition.RankRevealing

getRank, isFullRank

Methods inherited from interface MatrixDecomposition.Solver

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

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

myMaxDiag

private double myMaxDiag

myMinDiag

private double myMinDiag

mySPD

private boolean mySPD

Constructor Details

RawCholesky

RawCholesky()

Not recommended to use this constructor directly. Consider using the static factory method

invalid reference

org.ojalgo.matrix.decomposition.Cholesky#make(Access2D)

instead.

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]

calculateDeterminant

public Double calculateDeterminant(Access2D<?> matrix)

Specified by:

calculateDeterminant in interface DeterminantTask<Double>

checkAndDecompose

public boolean checkAndDecompose(MatrixStore<Double> matrix)

Description copied from interface: MatrixDecomposition.Hermitian

Absolutely must check if the matrix is hermitian or not. Then, depending on the result different paths can be chosen - compute or not / choose different algorithms...

Specified by:

checkAndDecompose in interface MatrixDecomposition.Hermitian<Double>

Parameters:

matrix - A matrix to check and then (maybe) decompose

Returns:

true if the hermitian check passed and decomposition succeeded; false if not

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

decompose

public boolean decompose(Access2D.Collectable<Double, ? super TransformableRegion<Double>> matrix)

Specified by:

decompose in interface MatrixDecomposition<Double>

Parameters:

matrix - A matrix to decompose

Returns:

true if decomposition suceeded; false if not

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>

Parameters:

arg - [b] transformed into [x]

getDeterminant

public Double getDeterminant()

Description copied from interface: MatrixDecomposition.Determinant

A matrix' determinant is the product of its eigenvalues.

Specified by:

getDeterminant in interface MatrixDecomposition.Determinant<Double>

Specified by:

getDeterminant in interface Provider2D.Determinant<Double>

Returns:

The matrix' determinant

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

getL

public MatrixStore<Double> getL()

Description copied from interface: Cholesky

Must implement either Cholesky.getL() or Cholesky.getR().

Specified by:

getL in interface Cholesky<Double>

getRankThreshold

public double getRankThreshold()

Specified by:

getRankThreshold in interface MatrixDecomposition.RankRevealing<Double>

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

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

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: Cholesky

To use the Cholesky decomposition rather than the LU decomposition the matrix must be symmetric and positive definite. It is recommended that the decomposition algorithm checks for this during calculation. Possibly the matrix could be assumed to be symmetric (to improve performance) but tests should be made to assure the matrix is positive definite.

Specified by:

isSPD in interface Cholesky<Double>

Returns:

true if the tests did not fail.

preallocate

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

Specified by:

preallocate in interface SolverTask<Double>

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

private boolean doDecompose(double[][] data,
 Access2D<?> input)

doGetInverse

private MatrixStore<Double> doGetInverse(PhysicalStore<Double> preallocated)

doSolve

private MatrixStore<Double> doSolve(PhysicalStore<Double> preallocated)

checkSolvability

protected boolean checkSolvability()

Overrides:

checkSolvability in class AbstractDecomposition<Double, R064Store>