org.ojalgo.matrix.jama

Class JamaLU

java.lang.Object

org.ojalgo.matrix.jama.JamaLU

All Implemented Interfaces:

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

public final class JamaLU
extends Object
implements LU<Double>

This class adapts JAMA's LUDecomposition to ojAlgo's LU interface.

Author:

apete

Nested Class Summary

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

Constructor Summary

Constructors

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

Method Summary

Modifier and Type	Method and Description
Double	calculateDeterminant(Access2D<Double> matrix)
boolean	compute(Access2D<?> aStore)
boolean	computeWithoutPivoting(MatrixStore<?> matrix) The normal MatrixDecomposition.compute(Access2D) method must handle cases where pivoting is required.
boolean	equals(MatrixDecomposition<Double> other, NumberContext context)
boolean	equals(MatrixStore<Double> aStore, NumberContext context)
Double	getDeterminant()
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.
JamaMatrix	getL()
int[]	getPivotOrder() This can be used to create a [P] matrix using IdentityStore in combination with RowsStore or ColumnsStore.
int	getRank()
int[]	getReducedPivots()
JamaMatrix	getU() http://en.wikipedia.org/wiki/Row_echelon_form This is the same as [D][U].
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	isSolvable()
boolean	isSquareAndNotSingular()
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, 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

Constructor Detail

JamaLU

public JamaLU()

Not recommended to use this constructor directly. Consider using the static factory method LUDecomposition.makeJama() instead.

Method Detail

calculateDeterminant

public Double calculateDeterminant(Access2D<Double> matrix)

Specified by:

calculateDeterminant in interface DeterminantTask<Double>

computeWithoutPivoting

public boolean computeWithoutPivoting(MatrixStore<?> matrix)

Description copied from interface: LU

The normal MatrixDecomposition.compute(Access2D) method must handle cases where pivoting is required. If you know that pivoting is not needed you may call this method instead - it's faster.

Specified by:

computeWithoutPivoting in interface LU<Double>

equals

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

Specified by:

equals in interface MatrixDecomposition<Double>

getDeterminant

public Double getDeterminant()

Specified by:

getDeterminant in interface LU<Double>

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()

getL

public JamaMatrix getL()

Specified by:

getL in interface LU<Double>

getPivotOrder

public int[] getPivotOrder()

Description copied from interface: LU

This can be used to create a [P] matrix using IdentityStore in combination with RowsStore or ColumnsStore.

Specified by:

getPivotOrder in interface LU<Double>

getRank

public int getRank()

Specified by:

getRank in interface LU<Double>

getReducedPivots

public int[] getReducedPivots()

Specified by:

getReducedPivots in interface LU<Double>

getU

public JamaMatrix getU()

Description copied from interface: LU

http://en.wikipedia.org/wiki/Row_echelon_form

This is the same as [D][U]. Together with the pivotOrder and [L] this constitutes an alternative, more compact, way to express the decomposition.

Specified by:

getU in interface LU<Double>

See Also:

LU.getPivotOrder(), LU.getL()

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.

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()

isSquareAndNotSingular

public boolean isSquareAndNotSingular()

Specified by:

isSquareAndNotSingular in interface LU<Double>

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>

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 JamaMatrix solve(Access2D<Double> rhs)

Description copied from interface: MatrixDecomposition

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

Specified by:

solve in interface MatrixDecomposition<Double>

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)