org.ojalgo.matrix.task

Interface SolverTask<N extends Number>

All Superinterfaces:

MatrixTask<N>

All Known Subinterfaces:

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

All Known Implementing Classes:

ConjugateGradientSolver, GaussSeidelSolver, HermitianEvD, JacobiSolver, MutableSolver

public interface SolverTask<N extends Number>
extends MatrixTask<N>

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	SolverTask.Factory<N extends Number>

Field Summary

Fields

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

Method Summary

Modifier and Type	Method and Description
default PhysicalStore<N>	preallocate(int numberOfEquations, int numberOfVariables, int numberOfSolutions)
PhysicalStore<N>	preallocate(Structure2D templateBody, Structure2D templateRHS) Will create a PhysicalStore instance suitable for use with solve(Access2D, Access2D, PhysicalStore).
default MatrixStore<N>	solve(Access2D<?> body, Access2D<?> rhs) [A][X]=[B] or [body][return]=[rhs]
MatrixStore<N>	solve(Access2D<?> body, Access2D<?> rhs, PhysicalStore<N> preallocated) Exactly how (if at all) a specific implementation makes use of preallocated is not specified by this interface.

Field Detail

COMPLEX

static final SolverTask.Factory<ComplexNumber> COMPLEX

PRIMITIVE

static final SolverTask.Factory<Double> PRIMITIVE

QUATERNION

static final SolverTask.Factory<Quaternion> QUATERNION

RATIONAL

static final SolverTask.Factory<RationalNumber> RATIONAL

Method Detail

preallocate

default PhysicalStore<N> preallocate(int numberOfEquations,
                                     int numberOfVariables,
                                     int numberOfSolutions)

preallocate

PhysicalStore<N> preallocate(Structure2D templateBody,
                             Structure2D templateRHS)

Will create a PhysicalStore instance suitable for use with solve(Access2D, Access2D, PhysicalStore). The dimensions of the returned instance is not specified by this interface - it is specified by the behaviour/requirements of each implementation.

When solving an equation system [A][X]=[B] ([mxn][nxb]=[mxb]) the preallocated memory/matrix will typically be either mxb or nxb.

solve

default MatrixStore<N> solve(Access2D<?> body,
                             Access2D<?> rhs)
                      throws RecoverableCondition

[A][X]=[B] or [body][return]=[rhs]

Throws:

RecoverableCondition

solve

MatrixStore<N> solve(Access2D<?> body,
                     Access2D<?> rhs,
                     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 solve(Access2D, Access2D).

Use preallocate(Structure2D, Structure2D) to obtain a suitbale preallocated.

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

Throws:

RecoverableCondition