org.ojalgo.matrix.decomposition

Interface LU<N extends Number>

All Superinterfaces:

DeterminantTask<N>, InverterTask<N>, LDU<N>, MatrixDecomposition<N>, MatrixDecomposition.Determinant<N>, MatrixDecomposition.Ordered<N>, MatrixDecomposition.RankRevealing<N>, MatrixDecomposition.Solver<N>, MatrixTask<N>, SolverTask<N>

public interface LU<N extends Number>
extends LDU<N>

LU: [A] = [L][U]

Decomposes [this] into [L] and [U] (with pivot order information in an int[]) where:

• [L] is a unit lower (left) triangular matrix. It has the same number of rows as [this], and ones on the diagonal.
• [U] is an upper (right) triangular matrix. It has the same number of columns as [this].
• [this] = [L][U] (with reordered rows according to the pivot order)

Note: The number of columns in [L] and the number of rows in [U] is not specified by this interface.

The LU decomposition always exists - the compute method should always succeed - even for non-square and/or singular matrices. The primary use of the LU decomposition is in the solution of systems of simultaneous linear equations. That will, however, only work for square non-singular matrices.

Author:

apete

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static interface	LU.Factory<N extends Number>

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

MatrixDecomposition.Determinant<N extends Number>, MatrixDecomposition.EconomySize<N extends Number>, MatrixDecomposition.Hermitian<N extends Number>, MatrixDecomposition.Ordered<N extends Number>, MatrixDecomposition.RankRevealing<N extends Number>, MatrixDecomposition.Solver<N extends Number>, MatrixDecomposition.Values<N extends Number>

Field Summary

Fields

Modifier and Type	Field and Description
static LU.Factory<BigDecimal>	BIG
static LU.Factory<ComplexNumber>	COMPLEX
static LU.Factory<Double>	PRIMITIVE
static LU.Factory<Quaternion>	QUATERNION
static LU.Factory<RationalNumber>	RATIONAL

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

TYPICAL

Method Summary

Modifier and Type	Method and Description
boolean	computeWithoutPivoting(ElementsSupplier<N> matrix) The normal MatrixDecomposition.decompose(Access2D.Collectable) method must handle cases where pivoting is required.
static <N extends Number> boolean	equals(MatrixStore<N> matrix, LU<N> decomposition, NumberContext context)
MatrixStore<N>	getL()
int[]	getPivotOrder() This can be used to create a [P] matrix..
int	getRank() The best (and most expensive) way to get the effective numerical rank is by calculating a SingularValue decomposition and then find the number of nonnegligible singular values.
MatrixStore<N>	getU() http://en.wikipedia.org/wiki/Row_echelon_form This is the same as [D][U].
static <N extends Number> LU<N>	make(Access2D<N> typical)
default MatrixStore<N>	reconstruct()
static <N extends Number> MatrixStore<N>	reconstruct(LU<N> decomposition)

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

isOrdered

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

compute, getInverse, getInverse, getSolution, getSolution, isSolvable

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

preallocate, preallocate, solve, solve

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

invert, invert, preallocate, preallocate

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

getDeterminant

Methods inherited from interface org.ojalgo.matrix.task.DeterminantTask

calculateDeterminant

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

isFullRank

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

decompose, isComputed, reset

Field Detail

BIG

static final LU.Factory<BigDecimal> BIG

COMPLEX

static final LU.Factory<ComplexNumber> COMPLEX

PRIMITIVE

static final LU.Factory<Double> PRIMITIVE

QUATERNION

static final LU.Factory<Quaternion> QUATERNION

RATIONAL

static final LU.Factory<RationalNumber> RATIONAL

Method Detail

make

static <N extends Number> LU<N> make(Access2D<N> typical)

equals

static <N extends Number> boolean equals(MatrixStore<N> matrix,
                                         LU<N> decomposition,
                                         NumberContext context)

reconstruct

static <N extends Number> MatrixStore<N> reconstruct(LU<N> decomposition)

computeWithoutPivoting

boolean computeWithoutPivoting(ElementsSupplier<N> matrix)

The normal MatrixDecomposition.decompose(Access2D.Collectable) method must handle cases where pivoting is required. If you know that pivoting is not needed you may call this method instead - it may be faster. Note that the algorithm implementation may still pivot. Pivoting is optional not forbidden (or required).

getL

MatrixStore<N> getL()

getPivotOrder

int[] getPivotOrder()

This can be used to create a [P] matrix..

getRank

int getRank()

Description copied from interface: MatrixDecomposition.RankRevealing

The best (and most expensive) way to get the effective numerical rank is by calculating a SingularValue decomposition and then find the number of nonnegligible singular values.

Specified by:

getRank in interface MatrixDecomposition.RankRevealing<N extends Number>

Returns:

The effective numerical rank (best estimate)

getU

MatrixStore<N> getU()

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.

See Also:

getPivotOrder(), getL()

reconstruct

default MatrixStore<N> reconstruct()

Specified by:

reconstruct in interface MatrixDecomposition<N extends Number>