org.ojalgo.matrix.decomposition
Interface DecompositionStore<N extends Number>

All Superinterfaces:

Access1D<N>, Access2D<N>, MatrixStore<N>, PhysicalStore<N>

All Known Implementing Classes:

BigDenseStore, ComplexDenseStore, PrimitiveDenseStore

public interface DecompositionStore<N extends Number>
extends PhysicalStore<N>

Only classes that will act as a delegate to a MatrixDecomposition implementation from this package should implement this interface. The interface specifications are entirely dictated by the classes in this package.

Do not use it for anything else!

Author:

apete

Nested Class Summary

static class	DecompositionStore.ExchangeColumnsCaller<N extends Number>
static class	DecompositionStore.HouseholderReference<N extends Number>
static class	DecompositionStore.NegateColumnCaller<N extends Number>
static class	DecompositionStore.RotateRightCaller<N extends Number>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.PhysicalStore

PhysicalStore.Factory<N extends Number,I extends PhysicalStore<N>>

Nested classes/interfaces inherited from interface org.ojalgo.matrix.store.MatrixStore

MatrixStore.Builder<N extends Number>

Method Summary

void	applyCholesky(int iterationPoint, ArrayAccess<N> multipliers)
void	applyLU(int iterationPoint, ArrayAccess<N> multipliers)
Array2D<N>	asArray2D()
Array1D<ComplexNumber>	computeInPlaceSchur(PhysicalStore<N> aTransformationCollector, boolean eigenvalue)
void	divideAndCopyColumn(int aRow, int aCol, ArrayAccess<N> aDestination)
double	doubleValue(int anInd)
double	doubleValue(int aRow, int aCol) Extracts one element of this matrix as a double.
boolean	generateApplyAndCopyHouseholderColumn(int aRow, int aCol, Householder<N> aDestination)
boolean	generateApplyAndCopyHouseholderRow(int aRow, int aCol, Householder<N> aDestination)
N	get(int anInd)
N	get(int aRow, int aCol)
int	getColDim() The size of this structure in the column-direction/dimension
int	getIndexOfLargestInColumn(int aRow, int aCol)
int	getRowDim() The size of this structure in the row-direction/dimension
void	negateColumn(int aCol)
void	rotateRight(int aLow, int aHigh, double aCos, double aSin)
void	setToIdentity(int aCol)
int	size()
void	substituteBackwards(Access2D<N> aBody, boolean transposed) Will solve the equation system [A][X]=[B] where: [aBody][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution). [A] is upper/right triangular
void	substituteForwards(Access2D<N> aBody, boolean onesOnDiagonal, boolean zerosAboveDiagonal) Will solve the equation system [A][X]=[B] where: [aBody][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution). [A] is lower/left triangular
void	transformSymmetric(Householder<N> aTransf)
void	tred2(ArrayAccess<N> mainDiagonal, ArrayAccess<N> offDiagonal, boolean yesvecs)

Methods inherited from interface org.ojalgo.matrix.store.PhysicalStore

asList, caxpy, exchangeColumns, exchangeRows, fillAll, fillByMultiplying, fillColumn, fillDiagonal, fillMatching, fillMatching, fillMatching, fillMatching, fillRow, maxpy, modifyAll, modifyColumn, modifyDiagonal, modifyOne, modifyRow, raxpy, set, set, transformLeft, transformLeft, transformRight, transformRight

Methods inherited from interface org.ojalgo.matrix.store.MatrixStore

aggregateAll, builder, conjugate, copy, equals, getFactory, getMinDim, isAbsolute, isLowerLeftShaded, isPositive, isReal, isUpperRightShaded, isZero, multiplyLeft, multiplyRight, toScalar, transpose, visitAll, visitColumn, visitDiagonal, visitRow

Methods inherited from interface java.lang.Iterable

iterator

Method Detail

applyCholesky

void applyCholesky(int iterationPoint,
                   ArrayAccess<N> multipliers)

applyLU

void applyLU(int iterationPoint,
             ArrayAccess<N> multipliers)

asArray2D

Array2D<N> asArray2D()

computeInPlaceSchur

Array1D<ComplexNumber> computeInPlaceSchur(PhysicalStore<N> aTransformationCollector,
                                           boolean eigenvalue)

divideAndCopyColumn

void divideAndCopyColumn(int aRow,
                         int aCol,
                         ArrayAccess<N> aDestination)

generateApplyAndCopyHouseholderColumn

boolean generateApplyAndCopyHouseholderColumn(int aRow,
                                              int aCol,
                                              Householder<N> aDestination)

generateApplyAndCopyHouseholderRow

boolean generateApplyAndCopyHouseholderRow(int aRow,
                                           int aCol,
                                           Householder<N> aDestination)

getIndexOfLargestInColumn

int getIndexOfLargestInColumn(int aRow,
                              int aCol)

negateColumn

void negateColumn(int aCol)

rotateRight

void rotateRight(int aLow,
                 int aHigh,
                 double aCos,
                 double aSin)

setToIdentity

void setToIdentity(int aCol)

substituteBackwards

void substituteBackwards(Access2D<N> aBody,
                         boolean transposed)

Will solve the equation system [A][X]=[B] where:

• [aBody][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution).
• [A] is upper/right triangular

Parameters:

aBody - The equation system body parameters [A]

transposed - true if the upper/right part of aBody is actually stored in the lower/left part of the matrix.

substituteForwards

void substituteForwards(Access2D<N> aBody,
                        boolean onesOnDiagonal,
                        boolean zerosAboveDiagonal)

Will solve the equation system [A][X]=[B] where:

• [aBody][this]=[this] is [A][X]=[B] ("this" is the right hand side, and it will be overwritten with the solution).
• [A] is lower/left triangular

Parameters:

aBody - The equation system body parameters [A]

onesOnDiagonal - true if aBody as ones on the diagonal

transformSymmetric

void transformSymmetric(Householder<N> aTransf)

tred2

void tred2(ArrayAccess<N> mainDiagonal,
           ArrayAccess<N> offDiagonal,
           boolean yesvecs)

doubleValue

double doubleValue(int aRow,
                   int aCol)

Extracts one element of this matrix as a double.

Parameters:

aRow - A row index.

aCol - A column index.

Returns:

One matrix element

get

N get(int aRow,
      int aCol)

getColDim

int getColDim()

The size of this structure in the column-direction/dimension

Returns:

The number of columns

getRowDim

int getRowDim()

The size of this structure in the row-direction/dimension

Returns:

The number of rows

size

int size()

Returns:

The total number of elements contained in this structure

doubleValue

double doubleValue(int anInd)

get

N get(int anInd)