Interface InverterTask<N extends Comparable<N>>

All Superinterfaces:

MatrixTask<N>

All Known Subinterfaces:

Cholesky<N>, Eigenvalue.Spectral<N>, LDL<N>, LDU<N>, LU<N>, MatrixDecomposition.Solver<N>, QR<N>, SingularValue<N>

All Known Implementing Classes:

AbstractInverter, DenseCholesky, DenseCholesky.C128, DenseCholesky.H256, DenseCholesky.Q128, DenseCholesky.R064, DenseCholesky.R128, DenseLDL, DenseLDL.C128, DenseLDL.H256, DenseLDL.Q128, DenseLDL.R064, DenseLDL.R128, DenseLU, DenseLU.C128, DenseLU.H256, DenseLU.Q128, DenseLU.R064, DenseLU.R128, DenseQR, DenseQR.C128, DenseQR.H256, DenseQR.Q128, DenseQR.R064, DenseQR.R128, DenseSingularValue, DenseSingularValue.C128, DenseSingularValue.H256, DenseSingularValue.Q128, DenseSingularValue.R064, DenseSingularValue.R128, HermitianEvD, HermitianEvD.C128, HermitianEvD.H256, HermitianEvD.Q128, HermitianEvD.R064, HermitianEvD.R128, RawCholesky, RawEigenvalue.Symmetric, RawLU, RawQR, RawSingularValue, SparseLU, SparseQDLDL

public interface InverterTask<N extends Comparable<N>>
extends MatrixTask<N>

Nested Class Summary

Nested Classes

Modifier and Type	Interface	Description
static class	InverterTask.Factory<N extends Comparable<N>>

Field Summary

Fields

Modifier and Type	Field	Description
static final InverterTask.Factory<ComplexNumber>	C128
static final InverterTask.Factory<Quaternion>	H256
static final InverterTask.Factory<RationalNumber>	Q128
static final InverterTask.Factory<Double>	R064
static final InverterTask.Factory<Quadruple>	R128

Method Summary

Modifier and Type	Method	Description
default MatrixStore<N>	invert(Access2D<?> original)	The output must be a "right inverse" and a "generalised inverse".
MatrixStore<N>	invert(Access2D<?> original, PhysicalStore<N> preallocated)	Exactly how (if at all) a specific implementation makes use of preallocated is not specified by this interface.
PhysicalStore<N>	preallocate(int nbRows, int nbCols)
default PhysicalStore<N>	preallocate(Structure2D template)	Will create a PhysicalStore instance suitable for use with invert(Access2D, PhysicalStore).
default Provider2D.Inverse<Optional<MatrixStore<N>>>	toInverseProvider(ElementsSupplier<N> original, Supplier<MatrixStore<N>> alternativeOriginalSupplier)

Field Details

C128

static final InverterTask.Factory<ComplexNumber> C128

R064

static final InverterTask.Factory<Double> R064

R128

static final InverterTask.Factory<Quadruple> R128

H256

static final InverterTask.Factory<Quaternion> H256

Q128

static final InverterTask.Factory<RationalNumber> Q128

Method Details

invert

default MatrixStore<N> invert(Access2D<?> original)
                       throws RecoverableCondition

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

Throws:

RecoverableCondition

invert

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

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 invert(Access2D).

Use preallocate(Structure2D) to obtain a suitbale preallocated.

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

preallocate

PhysicalStore<N> preallocate(int nbRows,
 int nbCols)

preallocate

default PhysicalStore<N> preallocate(Structure2D template)

Will create a PhysicalStore instance suitable for use with invert(Access2D, PhysicalStore).

When inverting a matrix (mxn) the preallocated memory/matrix will typically be nxm (and of course most of the time A is square).

toInverseProvider

default Provider2D.Inverse<Optional<MatrixStore<N>>> toInverseProvider(ElementsSupplier<N> original,
 Supplier<MatrixStore<N>> alternativeOriginalSupplier)