Uses of Interface
org.ojalgo.structure.Structure2D

Packages that use Structure2D

Package	Description
org.ojalgo
org.ojalgo.ann
org.ojalgo.array
org.ojalgo.data
org.ojalgo.data.image
org.ojalgo.matrix
org.ojalgo.matrix.decomposition
org.ojalgo.matrix.store
org.ojalgo.matrix.task
org.ojalgo.matrix.transformation
org.ojalgo.optimisation.convex
org.ojalgo.optimisation.linear
org.ojalgo.scalar
org.ojalgo.structure
org.ojalgo.tensor

Uses of Structure2D in org.ojalgo

Methods in org.ojalgo with parameters of type Structure2D

Modifier and Type	Method	Description
static void	ProgrammingError.throwIfNotEqualRowDimensions(Structure2D mtrx1, Structure1D mtrx2)
static void	ProgrammingError.throwIfNotSquare(Structure2D mtrx)

Uses of Structure2D in org.ojalgo.ann

Methods in org.ojalgo.ann that return Structure2D

Modifier and Type	Method	Description
(package private) Structure2D	CalculationLayer.getStructure()
Structure2D[]	ArtificialNeuralNetwork.structure()
Structure2D[]	NetworkTrainer.structure()
(package private) Structure2D[]	WrappedANN.structure()

Uses of Structure2D in org.ojalgo.array

Classes in org.ojalgo.array that implement Structure2D

Modifier and Type	Class	Description
final class	Array2D<N extends Comparable<N>>	Array2D

Uses of Structure2D in org.ojalgo.data

Classes in org.ojalgo.data that implement Structure2D

Modifier and Type	Class	Description
final class	DataBatch	A reusable data batch.

Uses of Structure2D in org.ojalgo.data.image

Classes in org.ojalgo.data.image that implement Structure2D

Modifier and Type	Class	Description
class	ImageData	Treats an image as a matrix.
(package private) static final class	ImageData.SingleChannel

Methods in org.ojalgo.data.image with parameters of type Structure2D

Modifier and Type	Method	Description
static ImageData	ImageData.newColour(Structure2D shape)
static ImageData	ImageData.newGreyScale(Structure2D shape)

Uses of Structure2D in org.ojalgo.matrix

Subinterfaces of Structure2D in org.ojalgo.matrix

Modifier and Type	Interface	Description
interface	Matrix2D<N extends Comparable<N>, M extends Matrix2D<N,M>>	Definition of what's common to BasicMatrix and MatrixStore.

Classes in org.ojalgo.matrix that implement Structure2D

Modifier and Type	Class	Description
class	BasicMatrix<N extends Comparable<N>, M extends BasicMatrix<N,M>>	A base class for, easy to use, immutable (thread safe) matrices with a rich feature set.
(package private) class	DenseMutator2D<N extends Comparable<N>, M extends BasicMatrix<N,M>>
final class	MatrixC128	A matrix (linear algebra) with Complex NumberSet.C elements, implemented using dual 64-bit double values.
static final class	MatrixC128.DenseReceiver
static final class	MatrixC128.SparseReceiver
final class	MatrixH256	A matrix (linear algebra) with Quaternion NumberSet.H elements, implemented using four 64-bit double values.
static final class	MatrixH256.DenseReceiver
static final class	MatrixH256.SparseReceiver
final class	MatrixQ128	A matrix (linear algebra) with Rational NumberSet.Q elements, implemented using dual 64-bit long values.
static final class	MatrixQ128.DenseReceiver
static final class	MatrixQ128.SparseReceiver
final class	MatrixR032	A matrix (linear algebra) with Real NumberSet.R elements, approximated by 32-bit float.
static final class	MatrixR032.DenseReceiver
static final class	MatrixR032.SparseReceiver
final class	MatrixR064	A matrix (linear algebra) with Real NumberSet.R elements, approximated by 64-bit double.
static final class	MatrixR064.DenseReceiver
static final class	MatrixR064.SparseReceiver
final class	MatrixR128	A matrix (linear algebra) with Real NumberSet.R elements, approximated by 128-bit floating-point values (implemented using dual 64-bit double).
static final class	MatrixR128.DenseReceiver
static final class	MatrixR128.SparseReceiver
(package private) class	SparseMutator2D<N extends Comparable<N>, M extends BasicMatrix<N,M>>

Methods in org.ojalgo.matrix with parameters of type Structure2D

Modifier and Type	Method	Description
M	MatrixFactory.makeEye(Structure2D shape)
(package private) abstract Cholesky<N>	BasicMatrix.newCholesky(Structure2D typical)
(package private) Cholesky<ComplexNumber>	MatrixC128.newCholesky(Structure2D typical)
(package private) Cholesky<Quaternion>	MatrixH256.newCholesky(Structure2D typical)
(package private) Cholesky<RationalNumber>	MatrixQ128.newCholesky(Structure2D typical)
(package private) Cholesky<Double>	MatrixR032.newCholesky(Structure2D typical)
(package private) Cholesky<Double>	MatrixR064.newCholesky(Structure2D typical)
(package private) Cholesky<Quadruple>	MatrixR128.newCholesky(Structure2D typical)
(package private) abstract DeterminantTask<N>	BasicMatrix.newDeterminantTask(Structure2D template)
(package private) DeterminantTask<ComplexNumber>	MatrixC128.newDeterminantTask(Structure2D template)
(package private) DeterminantTask<Quaternion>	MatrixH256.newDeterminantTask(Structure2D template)
(package private) DeterminantTask<RationalNumber>	MatrixQ128.newDeterminantTask(Structure2D template)
(package private) DeterminantTask<Double>	MatrixR032.newDeterminantTask(Structure2D template)
(package private) DeterminantTask<Double>	MatrixR064.newDeterminantTask(Structure2D template)
(package private) DeterminantTask<Quadruple>	MatrixR128.newDeterminantTask(Structure2D template)
(package private) abstract Eigenvalue<N>	BasicMatrix.newEigenvalue(Structure2D typical)
(package private) Eigenvalue<ComplexNumber>	MatrixC128.newEigenvalue(Structure2D typical)
(package private) Eigenvalue<Quaternion>	MatrixH256.newEigenvalue(Structure2D typical)
(package private) Eigenvalue<RationalNumber>	MatrixQ128.newEigenvalue(Structure2D typical)
(package private) Eigenvalue<Double>	MatrixR032.newEigenvalue(Structure2D typical)
(package private) Eigenvalue<Double>	MatrixR064.newEigenvalue(Structure2D typical)
(package private) Eigenvalue<Quadruple>	MatrixR128.newEigenvalue(Structure2D typical)
(package private) abstract InverterTask<N>	BasicMatrix.newInverterTask(Structure2D template)
(package private) InverterTask<ComplexNumber>	MatrixC128.newInverterTask(Structure2D base)
(package private) InverterTask<Quaternion>	MatrixH256.newInverterTask(Structure2D template)
(package private) InverterTask<RationalNumber>	MatrixQ128.newInverterTask(Structure2D template)
(package private) InverterTask<Double>	MatrixR032.newInverterTask(Structure2D base)
(package private) InverterTask<Double>	MatrixR064.newInverterTask(Structure2D base)
(package private) InverterTask<Quadruple>	MatrixR128.newInverterTask(Structure2D template)
(package private) abstract LDL<N>	BasicMatrix.newLDL(Structure2D typical)
(package private) LDL<ComplexNumber>	MatrixC128.newLDL(Structure2D typical)
(package private) LDL<Quaternion>	MatrixH256.newLDL(Structure2D typical)
(package private) LDL<RationalNumber>	MatrixQ128.newLDL(Structure2D typical)
(package private) LDL<Double>	MatrixR032.newLDL(Structure2D typical)
(package private) LDL<Double>	MatrixR064.newLDL(Structure2D typical)
(package private) LDL<Quadruple>	MatrixR128.newLDL(Structure2D typical)
(package private) final LDU<N>	BasicMatrix.newLDU(Structure2D typical)
(package private) abstract LU<N>	BasicMatrix.newLU(Structure2D typical)
(package private) LU<ComplexNumber>	MatrixC128.newLU(Structure2D typical)
(package private) LU<Quaternion>	MatrixH256.newLU(Structure2D typical)
(package private) LU<RationalNumber>	MatrixQ128.newLU(Structure2D typical)
(package private) LU<Double>	MatrixR032.newLU(Structure2D typical)
(package private) LU<Double>	MatrixR064.newLU(Structure2D typical)
(package private) LU<Quadruple>	MatrixR128.newLU(Structure2D typical)
(package private) abstract QR<N>	BasicMatrix.newQR(Structure2D typical)
(package private) QR<ComplexNumber>	MatrixC128.newQR(Structure2D typical)
(package private) QR<Quaternion>	MatrixH256.newQR(Structure2D typical)
(package private) QR<RationalNumber>	MatrixQ128.newQR(Structure2D typical)
(package private) QR<Double>	MatrixR032.newQR(Structure2D typical)
(package private) QR<Double>	MatrixR064.newQR(Structure2D typical)
(package private) QR<Quadruple>	MatrixR128.newQR(Structure2D typical)
(package private) abstract SingularValue<N>	BasicMatrix.newSingularValue(Structure2D typical)
(package private) SingularValue<ComplexNumber>	MatrixC128.newSingularValue(Structure2D typical)
(package private) SingularValue<Quaternion>	MatrixH256.newSingularValue(Structure2D typical)
(package private) SingularValue<RationalNumber>	MatrixQ128.newSingularValue(Structure2D typical)
(package private) SingularValue<Double>	MatrixR032.newSingularValue(Structure2D typical)
(package private) SingularValue<Double>	MatrixR064.newSingularValue(Structure2D typical)
(package private) SingularValue<Quadruple>	MatrixR128.newSingularValue(Structure2D typical)
(package private) abstract SolverTask<N>	BasicMatrix.newSolverTask(Structure2D templateBody, Structure2D templateRHS)
(package private) SolverTask<ComplexNumber>	MatrixC128.newSolverTask(Structure2D templateBody, Structure2D templateRHS)
(package private) SolverTask<Quaternion>	MatrixH256.newSolverTask(Structure2D templateBody, Structure2D templateRHS)
(package private) SolverTask<RationalNumber>	MatrixQ128.newSolverTask(Structure2D templateBody, Structure2D templateRHS)
(package private) SolverTask<Double>	MatrixR032.newSolverTask(Structure2D templateBody, Structure2D templateRHS)
(package private) SolverTask<Double>	MatrixR064.newSolverTask(Structure2D templateBody, Structure2D templateRHS)
(package private) SolverTask<Quadruple>	MatrixR128.newSolverTask(Structure2D templateBody, Structure2D templateRHS)

Uses of Structure2D in org.ojalgo.matrix.decomposition

Subinterfaces of Structure2D in org.ojalgo.matrix.decomposition

Modifier and Type	Interface	Description
interface	Bidiagonal<N extends Comparable<N>>	A general matrix [A] can be factorized by similarity transformations into the form [A]=[LQ][D][RQ] -1 where: [A] (m-by-n) is any, real or complex, matrix [D] (r-by-r) or (m-by-n) is, upper or lower, bidiagonal [LQ] (m-by-r) or (m-by-m) is orthogonal [RQ] (n-by-r) or (n-by-n) is orthogonal r = min(m,n)
interface	Cholesky<N extends Comparable<N>>	Cholesky: [A] = [L][L]H (or [R]H[R])
interface	DecompositionStore<N extends Comparable<N>>	Only classes that will act as a delegate to a MatrixDecomposition implementation from this package should implement this interface.
interface	Eigenvalue<N extends Comparable<N>>	[A] = [V][D][V]-1 ([A][V] = [V][D]) [A] = any square matrix. [V] = contains the eigenvectors as columns. [D] = a diagonal matrix with the eigenvalues on the diagonal (possibly in blocks).
static interface	Eigenvalue.Generalised<N extends Comparable<N>>
static interface	Eigenvalue.Spectral<N extends Comparable<N>>	“Spectral decomposition” refers specifically to the orthogonal/unitary eigen-decomposition of a normal matrix (most commonly Hermitian / symmetric).
interface	Hessenberg<N extends Comparable<N>>	Hessenberg: [A] = [Q][H][Q]T A general square matrix [A] can be decomposed by orthogonal similarity transformations into the form [A]=[Q][H][Q]T where [H] is upper (or lower) hessenberg matrix [Q] is orthogonal/unitary
interface	LDL<N extends Comparable<N>>	LDL: [A] = [L][D][L]H (or [R]H[D][R])
interface	LDU<N extends Comparable<N>>	LDU: [A] = [L][D][U] ( [PL][L][D][U][PU] )
interface	LU<N extends Comparable<N>>	LU: [A] = [L][U]
interface	MatrixDecomposition<N extends Comparable<N>>	Notation used to describe the various matrix decompositions: [A] could be any matrix.
static interface	MatrixDecomposition.Determinant<N extends Comparable<N>>
static interface	MatrixDecomposition.EconomySize<N extends Comparable<N>>	Several matrix decompositions can be expressed "economy sized" - some rows or columns of the decomposed matrix parts are not needed for the most releveant use cases, and can therefore be left out.
static interface	MatrixDecomposition.Hermitian<N extends Comparable<N>>	Some matrix decompositions are only available with hermitian (symmetric) matrices or different decomposition algorithms could be used depending on if the matrix is hemitian or not.
static interface	MatrixDecomposition.Ordered<N extends Comparable<N>>
static interface	MatrixDecomposition.Pivoting<N extends Comparable<N>>	The pivot or pivot element is the element of a matrix, or an array, which is selected first by an algorithm (e.g.
static interface	MatrixDecomposition.RankRevealing<N extends Comparable<N>>	A rank-revealing matrix decomposition of a matrix [A] is a decomposition that is, or can be transformed to be, on the form [A]=[X][D][Y]T where: [X] and [Y] are square and well conditioned. [D] is diagonal with nonnegative and non-increasing values on the diagonal.
static interface	MatrixDecomposition.Solver<N extends Comparable<N>>
static interface	MatrixDecomposition.Updatable<N extends Comparable<N>>
static interface	MatrixDecomposition.Values<N extends Comparable<N>>	Eigenvalue and Singular Value decompositions can calculate the "values" only.
interface	QR<N extends Comparable<N>>	QR: [A] = [Q][R] Decomposes [this] into [Q] and [R] where: [Q] is an orthogonal matrix (orthonormal columns).
interface	SingularValue<N extends Comparable<N>>	Singular Value: [A] = [U][S][V]T Decomposes [this] into [U], [S] and [V] where: [U] is an orthogonal matrix.
interface	Tridiagonal<N extends Comparable<N>>	Tridiagonal: [A] = [Q][D][Q]H Any square symmetric (hermitian) matrix [A] can be factorized by similarity transformations into the form, [A]=[Q][D][Q]-1 where [Q] is an orthogonal (unitary) matrix and [D] is a real symmetric tridiagonal matrix.

Classes in org.ojalgo.matrix.decomposition that implement Structure2D

Modifier and Type	Class	Description
(package private) class	AbstractDecomposition<N extends Comparable<N>, M extends PhysicalStore<N>>
(package private) class	DeferredTridiagonal<N extends Comparable<N>>
(package private) static final class	DeferredTridiagonal.C128
(package private) static final class	DeferredTridiagonal.H256
(package private) static final class	DeferredTridiagonal.Q128
(package private) static final class	DeferredTridiagonal.R064
(package private) static final class	DeferredTridiagonal.R128
(package private) class	DenseBidiagonal<N extends Comparable<N>>
(package private) static final class	DenseBidiagonal.C128
(package private) static final class	DenseBidiagonal.H256
(package private) static final class	DenseBidiagonal.Q128
(package private) static final class	DenseBidiagonal.R064
(package private) static final class	DenseBidiagonal.R128
(package private) class	DenseCholesky<N extends Comparable<N>>
(package private) static final class	DenseCholesky.C128
(package private) static final class	DenseCholesky.H256
(package private) static final class	DenseCholesky.Q128
(package private) static final class	DenseCholesky.R064
(package private) static final class	DenseCholesky.R128
(package private) class	DenseEigenvalue<N extends Comparable<N>>
(package private) class	DenseHessenberg<N extends Comparable<N>>
(package private) static final class	DenseHessenberg.C128
(package private) static final class	DenseHessenberg.H256
(package private) static final class	DenseHessenberg.Q128
(package private) static final class	DenseHessenberg.R064
(package private) static final class	DenseHessenberg.R128
(package private) class	DenseLDL<N extends Comparable<N>>
(package private) static final class	DenseLDL.C128
(package private) static final class	DenseLDL.H256
(package private) static final class	DenseLDL.Q128
(package private) static final class	DenseLDL.R064
(package private) static final class	DenseLDL.R128
(package private) class	DenseLU<N extends Comparable<N>>
(package private) static final class	DenseLU.C128
(package private) static final class	DenseLU.H256
(package private) static final class	DenseLU.Q128
(package private) static final class	DenseLU.R064
(package private) static final class	DenseLU.R128
(package private) class	DenseQR<N extends Comparable<N>>
(package private) static final class	DenseQR.C128
(package private) static final class	DenseQR.H256
(package private) static final class	DenseQR.Q128
(package private) static final class	DenseQR.R064
(package private) static final class	DenseQR.R128
(package private) class	DenseSingularValue<N extends Comparable<N>>
(package private) static final class	DenseSingularValue.C128
(package private) static final class	DenseSingularValue.H256
(package private) static final class	DenseSingularValue.Q128
(package private) static final class	DenseSingularValue.R064
(package private) static final class	DenseSingularValue.R128
(package private) class	DenseTridiagonal<N extends Comparable<N>>
(package private) class	DynamicEvD<N extends Comparable<N>>
(package private) static final class	DynamicEvD.R064
(package private) class	GeneralEvD<N extends Comparable<N>>
(package private) static final class	GeneralEvD.R064	Eigenvalues and eigenvectors of a real matrix.
(package private) final class	GeneralisedEvD<N extends Comparable<N>>
(package private) class	HermitianEvD<N extends Comparable<N>>	Eigenvalues and eigenvectors of a real matrix.
(package private) static final class	HermitianEvD.C128
(package private) static final class	HermitianEvD.H256
(package private) static final class	HermitianEvD.Q128
(package private) static final class	HermitianEvD.R064
(package private) static final class	HermitianEvD.R128
(package private) class	InPlaceDecomposition<N extends Comparable<N>>
(package private) final class	RawCholesky
(package private) class	RawDecomposition	In many ways similar to InPlaceDecomposition but this class is hardwired to work with double[][] data.
(package private) class	RawEigenvalue	Eigenvalues and eigenvectors of a real matrix.
(package private) static final class	RawEigenvalue.Dynamic
(package private) static final class	RawEigenvalue.General
(package private) static final class	RawEigenvalue.Symmetric
(package private) final class	RawLU
(package private) final class	RawQR	For an m-by-n matrix A with m >= n, the QR decomposition is an m-by-n orthogonal matrix Q and an n-by-n upper triangular matrix R so that A = Q*R.
(package private) final class	RawSingularValue	Singular Value Decomposition.
(package private) class	SimultaneousTridiagonal	Computes Q while decomposing.
(package private) final class	SparseLU	A sparse, primitive double based, LU decomposition with support for incremental Forrest-Tomlin updates.
(package private) static final class	SparseLU.PermutationEta
final class	SparseQDLDL	Quasi-Definite LDL (QDLDL) sparse decomposition.

Fields in org.ojalgo.matrix.decomposition declared as Structure2D

Modifier and Type	Field	Description
private final Structure2D	DenseSingularValue.myInputStructure
static final Structure2D	MatrixDecomposition.TYPICAL

Methods in org.ojalgo.matrix.decomposition with parameters of type Structure2D

Modifier and Type	Method	Description
default Bidiagonal<N>	Bidiagonal.Factory.make(Structure2D typical)
Bidiagonal<N>	Bidiagonal.Factory.make(Structure2D typical, boolean fullSize)
default Eigenvalue<N>	Eigenvalue.Factory.make(Structure2D typical)
Eigenvalue<N>	Eigenvalue.Factory.make(Structure2D typical, boolean hermitian)
LDL<N>	LDL.ModifiedFactory.make(Structure2D typical)
D	MatrixDecomposition.Factory.make(Structure2D typical)	Will create a new decomposition instance suitable for matrices of the specified size.
default QR<N>	QR.Factory.make(Structure2D typical)
QR<N>	QR.Factory.make(Structure2D typical, boolean fullSize)
default SingularValue<N>	SingularValue.Factory.make(Structure2D typical)
SingularValue<N>	SingularValue.Factory.make(Structure2D typical, boolean fullSize)
default Eigenvalue.Generalised<N>	Eigenvalue.Factory.makeGeneralised(Structure2D typical)	Deprecated. v56 Use Eigenvalue.Factory.makeGeneralised(Structure2D, Eigenvalue.Generalisation) instead, then it's more clear what you're actually doing.
Eigenvalue.Generalised<N>	Eigenvalue.Factory.makeGeneralised(Structure2D typical, Eigenvalue.Generalisation type)	"Generalised" does NOT refer to general (as in not symmetric/hermitian) matrices, but to generalised eigenvalue problems.
(package private) final M	AbstractDecomposition.makeZero(Structure2D shape)
(package private) double[][]	RawDecomposition.reset(Structure2D template, boolean transpose)
(package private) void	SparseLU.reset(Structure2D matrix)

Uses of Structure2D in org.ojalgo.matrix.store

Subinterfaces of Structure2D in org.ojalgo.matrix.store

Modifier and Type	Interface	Description
interface	ElementsSupplier<N extends Comparable<N>>	An ElementsSupplier is not necessarily (or not yet) a matrix, but something from which the elements of a matrix can be derived.
interface	MatrixStore<N extends Comparable<N>>	A MatrixStore is a two dimensional store of numbers/scalars.
interface	PhysicalStore<N extends Comparable<N>>	PhysicalStore:s, as opposed to MatrixStore:s, are mutable.
interface	SparseStructure2D	Additional methods for sparse matrix implementations that store only non-zero elements.
interface	TransformableRegion<N extends Comparable<N>>	A transformable 2D (sub)region.

Classes in org.ojalgo.matrix.store that implement Structure2D

Modifier and Type	Class	Description
(package private) final class	AboveBelowStore<N extends Comparable<N>>	A merger of two MatrixStore instances by placing one store below the other.
(package private) class	AbstractStore<N extends Comparable<N>>
(package private) final class	ColumnsStore<N extends Comparable<N>>	A selection (re-ordering) of columns.
final class	ColumnsSupplier<N extends Comparable<N>>	Sparse columns – columns can be added and removed.
static final class	ColumnsSupplier.SingleView<N extends Comparable<N>>
(package private) class	ComposingStore<N extends Comparable<N>>
(package private) class	CompressedSparseR064
(package private) static class	CompressedSparseR064.Builder<I extends CompressedSparseR064>
(package private) final class	ConjugatedStore<N extends Comparable<N>>	ConjugatedStore
final class	DiagonalStore<N extends Comparable<N>, D extends Access1D<?>>
(package private) class	FactoryStore<N extends Comparable<N>>
final class	GenericStore<N extends Scalar<N>>	A generic implementation of PhysicalStore.
(package private) final class	IdentityStore<N extends Comparable<N>>	IdentityStore
(package private) final class	LeftRightStore<N extends Comparable<N>>	A merger of two MatrixStore instances by placing one store to the right of the other.
(package private) final class	LimitStore<N extends Comparable<N>>
(package private) class	LogicalStore<N extends Comparable<N>>	Logical stores are (intended to be) immutable.
(package private) final class	LowerHessenbergStore<N extends Comparable<N>>	A Hessenberg matrix is one that is "almost" triangular.
(package private) final class	LowerSymmetricStore<N extends Comparable<N>>
(package private) final class	LowerTriangularStore<N extends Comparable<N>>
(package private) class	MatrixPipeline<N extends Comparable<N>>	Intermediate step in a matrix pipeline – a chain of operations to be executed when the elements are extracted.
(package private) static final class	MatrixPipeline.BinaryOperatorLeft<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.BinaryOperatorRight<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.ColumnsModifier<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.ColumnsReducer<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.Multiplication<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.RowsModifier<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.RowsReducer<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.Transformer<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.Transpose<N extends Comparable<N>>
(package private) static final class	MatrixPipeline.UnaryOperator<N extends Comparable<N>>
(package private) final class	OffsetStore<N extends Comparable<N>>
final class	R032Store	A invalid reference float implementation of PhysicalStore.
final class	R064CSC	A compressed sparse column (CSC) matrix store implementation for double precision values.
static final class	R064CSC.Builder	A builder for constructing R064CSR instances.
final class	R064CSR	A compressed sparse row (CSR) matrix store implementation for double precision values.
static final class	R064CSR.Builder	A builder for constructing CSR matrix stores.
final class	R064Store	A invalid reference double implementation of PhysicalStore.
final class	RawStore	Uses double[][] internally.
(package private) final class	RepeatedColumnsStore<N extends Comparable<N>>
(package private) final class	RepeatedRowsStore<N extends Comparable<N>>
(package private) final class	RowsStore<N extends Comparable<N>>	A selection (re-ordering) of rows.
final class	RowsSupplier<N extends Comparable<N>>	Sparse rows – rows can be added and removed.
static final class	RowsSupplier.SingleView<N extends Comparable<N>>
(package private) class	SelectingStore<N extends Comparable<N>>	Selects (rearranges) existing rows and/or columns.
(package private) class	ShadingStore<N extends Comparable<N>>	Does not change the matrix size/shape, but applies some structure to the elements.
(package private) final class	SingleStore<N extends Comparable<N>>
final class	SparseStore<N extends Comparable<N>>	A sparse matrix (this implementation) is not thread safe.
static final class	SparseStore.Builder<N extends Comparable<N>>	May be a preferable way to build a sparse matrix if: You don't know the number of nonzero elements in advance.
(package private) class	Subregion2D<N extends Comparable<N>>
(package private) static final class	Subregion2D.ColumnsRegion<N extends Comparable<N>>
(package private) static final class	Subregion2D.LimitRegion<N extends Comparable<N>>
(package private) static final class	Subregion2D.OffsetRegion<N extends Comparable<N>>
(package private) static final class	Subregion2D.RowsRegion<N extends Comparable<N>>
(package private) static final class	Subregion2D.SynchronizedRegion<N extends Comparable<N>>
(package private) static final class	Subregion2D.TransposedRegion<N extends Comparable<N>>
(package private) static final class	Subregion2D.WrapperRegion<N extends Comparable<N>>
(package private) final class	SuperimposedStore<N extends Comparable<N>>	SuperimposedStore
(package private) class	TransjugatedStore<N extends Comparable<N>>
(package private) final class	TransposedStore<N extends Comparable<N>>
(package private) final class	UnaryOperatoStore<N extends Comparable<N>>
(package private) final class	UpperHessenbergStore<N extends Comparable<N>>	A Hessenberg matrix is one that is "almost" triangular.
(package private) final class	UpperSymmetricStore<N extends Comparable<N>>
(package private) final class	UpperTriangularStore<N extends Comparable<N>>
(package private) final class	WrapperStore<N extends Comparable<N>>
(package private) final class	ZeroStore<N extends Comparable<N>>	ZeroStore

Methods in org.ojalgo.matrix.store with parameters of type Structure2D

Modifier and Type	Method	Description
boolean	R032Store.isAcceptable(Structure2D supplier)
boolean	Subregion2D.SynchronizedRegion.isAcceptable(Structure2D supplier)
default I	PhysicalStore.Factory.makeEye(Structure2D shape)
default SparseStore<N>	PhysicalStore.Factory.makeSparse(Structure2D shape)
default MatrixStore<N>	PhysicalStore.Factory.makeZero(Structure2D shape)

Uses of Structure2D in org.ojalgo.matrix.task

Methods in org.ojalgo.matrix.task with parameters of type Structure2D

Modifier and Type	Method	Description
abstract DeterminantTask<N>	DeterminantTask.Factory.make(Structure2D template, boolean symmetric, boolean positiveDefinite)
abstract InverterTask<N>	InverterTask.Factory.make(Structure2D template, boolean symmetric, boolean positiveDefinite)
abstract SolverTask<N>	SolverTask.Factory.make(Structure2D templateBody, Structure2D templateRHS, boolean symmetric, boolean positiveDefinite)
default PhysicalStore<N>	InverterTask.preallocate(Structure2D template)	Will create a PhysicalStore instance suitable for use with InverterTask.invert(Access2D, PhysicalStore).
default PhysicalStore<N>	SolverTask.preallocate(Structure2D templateBody, Structure2D templateRHS)	Will create a PhysicalStore instance suitable for use with SolverTask.solve(Access2D, Access2D, PhysicalStore).

Uses of Structure2D in org.ojalgo.matrix.transformation

Subinterfaces of Structure2D in org.ojalgo.matrix.transformation

Modifier and Type	Interface	Description
interface	InvertibleFactor<N extends Comparable<N>>	A chainable and reversible in-place (equation system) solver.

Classes in org.ojalgo.matrix.transformation that implement Structure2D

Modifier and Type	Class	Description
static final class	InvertibleFactor.IdentityFactor<N extends Comparable<N>>

Uses of Structure2D in org.ojalgo.optimisation.convex

Fields in org.ojalgo.optimisation.convex with type parameters of type Structure2D

Modifier and Type	Field	Description
private Function<Structure2D, MatrixDecomposition.Solver<Double>>	ConvexSolver.Configuration.mySolverGeneral
private Function<Structure2D, MatrixDecomposition.Solver<Double>>	ConvexSolver.Configuration.mySolverSPD

Methods in org.ojalgo.optimisation.convex with parameters of type Structure2D

Modifier and Type	Method	Description
MatrixDecomposition.Solver<Double>	ConvexSolver.Configuration.newSolverGeneral(Structure2D structure)
MatrixDecomposition.Solver<Double>	ConvexSolver.Configuration.newSolverSPD(Structure2D structure)

Method parameters in org.ojalgo.optimisation.convex with type arguments of type Structure2D

Modifier and Type	Method	Description
ConvexSolver.Configuration	ConvexSolver.Configuration.solverGeneral(Function<Structure2D, MatrixDecomposition.Solver<Double>> factory)	This matrix decomposition should be able to "invert" the full KKT systsem body matrix (which is symmetric) and/or its Schur complement with regards to the [Q] matrix (of quadratic terms).
ConvexSolver.Configuration	ConvexSolver.Configuration.solverSPD(Function<Structure2D, MatrixDecomposition.Solver<Double>> factory)	The [Q] matrix (of quadratic terms) is supposed to be symmetric positive definite (or at least semidefinite), but in reality there are usually many deficiencies.

Uses of Structure2D in org.ojalgo.optimisation.linear

Subinterfaces of Structure2D in org.ojalgo.optimisation.linear

Modifier and Type	Interface	Description
(package private) interface	BasisRepresentation

Classes in org.ojalgo.optimisation.linear that implement Structure2D

Modifier and Type	Class	Description
(package private) final class	DecomposedInverse	Maintains an LU decomposition of the basis matrix for efficient solving of linear systems in the revised simplex method.
(package private) final class	DenseTableau
(package private) final class	ProductFormInverse
(package private) static final class	ProductFormInverse.ElementaryFactor
(package private) class	SimplexTableau
(package private) final class	SparseTableau

Uses of Structure2D in org.ojalgo.scalar

Classes in org.ojalgo.scalar that implement Structure2D

Modifier and Type	Class	Description
final class	ComplexNumber	ComplexNumber is an immutable complex number class.
final class	Quaternion

Uses of Structure2D in org.ojalgo.structure

Classes in org.ojalgo.structure with type parameters of type Structure2D

Modifier and Type	Interface	Description
interface	Factory2D<I extends Structure2D>
static interface	Factory2D.Builder<I extends Structure2D>
static interface	Factory2D.MayBeSparse<I extends Structure2D, DENSE extends Factory2D.Builder<I>, SPARSE extends Factory2D.Builder<I>>	For when the structures can be either dense or sparse.
static interface	Factory2D.TwoStep<I extends Structure2D, B extends Factory2D.Builder<I>>
static interface	Structure2D.Logical<S extends Structure2D, B extends Structure2D.Logical<S,B>>
static interface	StructureAnyD.ReducibleTo2D<R extends Structure2D>

Subinterfaces of Structure2D in org.ojalgo.structure

Modifier and Type	Interface	Description
interface	Access2D<N extends Comparable<N>>	2-dimensional accessor methods
static interface	Access2D.Aggregatable<N extends Comparable<N>>
static interface	Access2D.Collectable<N extends Comparable<N>, R extends Mutate2D>
static interface	Access2D.Sliceable<N extends Comparable<N>>
static interface	Access2D.Visitable<N extends Comparable<N>>
static interface	Factory2D.Builder<I extends Structure2D>
interface	Mutate2D	2-dimensional mutator methods
static interface	Mutate2D.Exchangeable	A few operations with no 1D or AnyD counterpart.
static interface	Mutate2D.Fillable<N extends Comparable<N>>
static interface	Mutate2D.Mixable<N extends Comparable<N>>
static interface	Mutate2D.Modifiable<N extends Comparable<N>>
static interface	Mutate2D.ModifiableReceiver<N extends Comparable<N>>	Apart from extending Mutate2D.Receiver this interface extends Mutate2D.Modifiable and Mutate2D.Exchangeable which both imply access to existing elements as well as Access2D that dictates explicit access.
static interface	Mutate2D.Receiver<N extends Comparable<N>>
interface	Operate2D<N extends Comparable<N>, P extends Operate2D<N,P>>	To be implemented by classes that are not directly mutable themselves, but that can operate on the elements of some internal/future 2D data structure – similar to streams in some sense.
static interface	Structure2D.Logical<S extends Structure2D, B extends Structure2D.Logical<S,B>>
static interface	Structure2D.ReducibleTo1D<R extends Structure1D>
static interface	Structure2D.Reshapable

Classes in org.ojalgo.structure that implement Structure2D

Modifier and Type	Class	Description
static final class	Access2D.SelectionView<N extends Comparable<N>>
static final class	AccessAnyD.MatrixView<N extends Comparable<N>>
class	Primitive2D
(package private) static final class	Primitive2D.Simple
(package private) static final class	Primitive2D.Wrapper

Fields in org.ojalgo.structure declared as Structure2D

Modifier and Type	Field	Description
private final Structure2D	Primitive2D.Wrapper.myDelegate

Methods in org.ojalgo.structure that return Structure2D

Modifier and Type	Method	Description
Structure2D	Structure2D.Reshapable.reshape(long rows, long columns)

Methods in org.ojalgo.structure with parameters of type Structure2D

Modifier and Type	Method	Description
B	Structure2D.Logical.above(S... above)
B	Structure2D.Logical.below(S... below)
B	Structure2D.Logical.diagonally(S... diagonally)
default boolean	Mutate2D.Receiver.isAcceptable(Structure2D supplier)
B	Structure2D.Logical.left(S... left)
default I	Factory2D.make(Structure2D shape)
default I	Factory2D.TwoStep.make(Structure2D shape)
static <R,C> Structure2D.RowColumnMapper<R,C>	Structure2D.mapperOf(Structure2D structure, Structure1D.IndexMapper<R> rowMappwer, Structure1D.IndexMapper<C> columnMappwer)
B	Structure2D.Logical.right(S... right)
static Primitive2D	Primitive2D.wrap(Structure2D delegate)

Constructors in org.ojalgo.structure with parameters of type Structure2D

Modifier	Constructor	Description
protected	RowColumnMapper(Structure2D structure, Structure1D.IndexMapper<R> rowMapper, Structure1D.IndexMapper<C> columnMapper)
(package private)	Wrapper(Structure2D delegate)

Uses of Structure2D in org.ojalgo.tensor

Classes in org.ojalgo.tensor that implement Structure2D

Modifier and Type	Class	Description
final class	MatrixTensor<N extends Comparable<N>>