Uses of Interface
org.episteme.core.mathematics.linearalgebra.Matrix

Packages that use Matrix

Package	Description
org.episteme.benchmarks.benchmark.benchmarks
org.episteme.client.client.mathematics.linearalgebra.backends
org.episteme.core.io.interop
org.episteme.core.mathematics.algebra.algebras
org.episteme.core.mathematics.algebra.categories
org.episteme.core.mathematics.algebra.groups
org.episteme.core.mathematics.analysis
org.episteme.core.mathematics.analysis.fem
org.episteme.core.mathematics.analysis.transform
org.episteme.core.mathematics.linearalgebra
org.episteme.core.mathematics.linearalgebra.algorithms
org.episteme.core.mathematics.linearalgebra.backends
org.episteme.core.mathematics.linearalgebra.matrices
org.episteme.core.mathematics.linearalgebra.matrices.solvers
org.episteme.core.mathematics.linearalgebra.matrices.solvers.sparse
org.episteme.core.mathematics.linearalgebra.matrices.storage
org.episteme.core.mathematics.linearalgebra.providers
org.episteme.core.mathematics.linearalgebra.vectors
org.episteme.core.mathematics.ml
org.episteme.core.mathematics.sets
org.episteme.core.mathematics.util
org.episteme.nativ.mathematics.linearalgebra.backends
org.episteme.nativ.mathematics.linearalgebra.matrices
org.episteme.nativ.mathematics.linearalgebra.matrices.storage
org.episteme.natural.biology.ecology
org.episteme.natural.chemistry.computational.quantum
org.episteme.natural.engineering.robotics
org.episteme.natural.physics.classical.mechanics
org.episteme.natural.physics.classical.mechanics.collision
org.episteme.natural.physics.quantum.backends
org.episteme.natural.technical.backend.quantum
org.episteme.social.economics.models
org.episteme.social.geography	Provides classes for social geography, human settlements, and mapping.

Uses of Matrix in org.episteme.benchmarks.benchmark.benchmarks

Methods in org.episteme.benchmarks.benchmark.benchmarks that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	DistributedMatrixBenchmark.standardMultiply()

Uses of Matrix in org.episteme.client.client.mathematics.linearalgebra.backends

Methods in org.episteme.client.client.mathematics.linearalgebra.backends that return Matrix

Modifier and Type	Method	Description
Matrix<E>	GRPCLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	GRPCLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	GRPCLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	GRPCLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	GRPCLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	GRPCLinearAlgebraBackend.transpose(Matrix<E> a)

Methods in org.episteme.client.client.mathematics.linearalgebra.backends with parameters of type Matrix

Modifier and Type	Method	Description
Matrix<E>	GRPCLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Vector<E>	GRPCLinearAlgebraBackend.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
CholeskyResult<E>	GRPCLinearAlgebraBackend.cholesky(Matrix<E> a)
Vector<E>	GRPCLinearAlgebraBackend.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
E	GRPCLinearAlgebraBackend.determinant(Matrix<E> a)
EigenResult<E>	GRPCLinearAlgebraBackend.eigen(Matrix<E> a)
Vector<E>	GRPCLinearAlgebraBackend.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restart)
Matrix<E>	GRPCLinearAlgebraBackend.inverse(Matrix<E> a)
LUResult<E>	GRPCLinearAlgebraBackend.lu(Matrix<E> a)
Matrix<E>	GRPCLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	GRPCLinearAlgebraBackend.multiply(Matrix<E> m, Vector<E> v)
QRResult<E>	GRPCLinearAlgebraBackend.qr(Matrix<E> a)
Matrix<E>	GRPCLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Vector<E>	GRPCLinearAlgebraBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	GRPCLinearAlgebraBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Matrix<E>	GRPCLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
SVDResult<E>	GRPCLinearAlgebraBackend.svd(Matrix<E> a)
E	GRPCLinearAlgebraBackend.trace(Matrix<E> a)
Matrix<E>	GRPCLinearAlgebraBackend.transpose(Matrix<E> a)

Uses of Matrix in org.episteme.core.io.interop

Methods in org.episteme.core.io.interop with parameters of type Matrix

Modifier and Type	Method	Description
static ByteBuffer	ArrowAdapter.toArrowBuffer(Matrix<Real> matrix)	Converts a Matrix to an Arrow-compatible ByteBuffer (Float64 array).

Uses of Matrix in org.episteme.core.mathematics.algebra.algebras

Classes in org.episteme.core.mathematics.algebra.algebras that implement interfaces with type arguments of type Matrix

Modifier and Type	Class	Description
class	MatrixLieAlgebra<E>	A concrete Lie Algebra where elements are square matrices and the bracket is the commutator [A, B] = AB - BA.

Methods in org.episteme.core.mathematics.algebra.algebras that return Matrix

Modifier and Type	Method	Description
Matrix<E>	MatrixLieAlgebra.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	MatrixLieAlgebra.inverse(Matrix<E> element)
Matrix<E>	MatrixLieAlgebra.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	MatrixLieAlgebra.negate(Matrix<E> element)
Matrix<E>	MatrixLieAlgebra.one()
Matrix<E>	MatrixLieAlgebra.operate(Matrix<E> left, Matrix<E> right)
Matrix<E>	MatrixLieAlgebra.scale(E scalar, Matrix<E> element)
Matrix<E>	MatrixLieAlgebra.zero()

Methods in org.episteme.core.mathematics.algebra.algebras with parameters of type Matrix

Modifier and Type	Method	Description
Matrix<E>	MatrixLieAlgebra.add(Matrix<E> a, Matrix<E> b)
boolean	MatrixLieAlgebra.contains(Matrix<E> element)
Matrix<E>	MatrixLieAlgebra.inverse(Matrix<E> element)
Matrix<E>	MatrixLieAlgebra.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	MatrixLieAlgebra.negate(Matrix<E> element)
Matrix<E>	MatrixLieAlgebra.operate(Matrix<E> left, Matrix<E> right)
Matrix<E>	MatrixLieAlgebra.scale(E scalar, Matrix<E> element)

Uses of Matrix in org.episteme.core.mathematics.algebra.categories

Classes in org.episteme.core.mathematics.algebra.categories that implement interfaces with type arguments of type Matrix

Modifier and Type	Class	Description
class	HilbertSpacesCategory	Represents the Category of Hilbert Spaces (Hilb).

Methods in org.episteme.core.mathematics.algebra.categories that return Matrix

Modifier and Type	Method	Description
Matrix<?>	HilbertSpacesCategory.compose(Matrix<?> f, Matrix<?> g)
Matrix<?>	HilbertSpacesCategory.identity(HilbertSpace<?,?> object)

Methods in org.episteme.core.mathematics.algebra.categories that return types with arguments of type Matrix

Modifier and Type	Method	Description
Set<Matrix<?>>	HilbertSpacesCategory.hom(HilbertSpace<?,?> source, HilbertSpace<?,?> target)

Methods in org.episteme.core.mathematics.algebra.categories with parameters of type Matrix

Modifier and Type	Method	Description
HilbertSpace<?,?>	HilbertSpacesCategory.codomain(Matrix<?> morphism)
Matrix<?>	HilbertSpacesCategory.compose(Matrix<?> f, Matrix<?> g)
HilbertSpace<?,?>	HilbertSpacesCategory.domain(Matrix<?> morphism)

Uses of Matrix in org.episteme.core.mathematics.algebra.groups

Classes in org.episteme.core.mathematics.algebra.groups that implement interfaces with type arguments of type Matrix

Modifier and Type	Class	Description
class	LieGroup	A Lie group is a group that is also a differentiable manifold.
class	SO3_1Group	The group of all linear transformations of Minkowski space that preserve the spacetime interval ds²=-c²dt²+dx²+dy²+dz².
class	SU2Group	The group of 2x2 unitary matrices with determinant 1.
class	SU3Group	The group of 3x3 unitary matrices with determinant 1.

Methods in org.episteme.core.mathematics.algebra.groups that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	SO3_1Group.boostX(double beta)	Creates a boost matrix in the x-direction.
Matrix<Complex>	LieGroup.getElement(Vector<Real> v)	Generates a group element near the identity using the exponential map approximation.
Matrix<Complex>	LieGroup.identity()
Matrix<Real>	SO3_1Group.identity()
Matrix<Complex>	SU2Group.identity()
Matrix<Complex>	SU3Group.identity()
Matrix<Complex>	LieGroup.inverse(Matrix<Complex> element)
Matrix<Real>	SO3_1Group.inverse(Matrix<Real> element)
Matrix<Complex>	SU2Group.inverse(Matrix<Complex> element)
Matrix<Complex>	SU3Group.inverse(Matrix<Complex> element)
Matrix<Complex>	LieGroup.operate(Matrix<Complex> a, Matrix<Complex> b)
Matrix<Real>	SO3_1Group.operate(Matrix<Real> left, Matrix<Real> right)
Matrix<Complex>	SU2Group.operate(Matrix<Complex> left, Matrix<Complex> right)
Matrix<Complex>	SU3Group.operate(Matrix<Complex> left, Matrix<Complex> right)

Methods in org.episteme.core.mathematics.algebra.groups with parameters of type Matrix

Modifier and Type	Method	Description
boolean	LieGroup.contains(Matrix<Complex> element)
boolean	SO3_1Group.contains(Matrix<Real> element)
boolean	SU2Group.contains(Matrix<Complex> element)
boolean	SU3Group.contains(Matrix<Complex> element)
Matrix<Complex>	LieGroup.inverse(Matrix<Complex> element)
Matrix<Real>	SO3_1Group.inverse(Matrix<Real> element)
Matrix<Complex>	SU2Group.inverse(Matrix<Complex> element)
Matrix<Complex>	SU3Group.inverse(Matrix<Complex> element)
Matrix<Complex>	LieGroup.operate(Matrix<Complex> a, Matrix<Complex> b)
Matrix<Real>	SO3_1Group.operate(Matrix<Real> left, Matrix<Real> right)
Matrix<Complex>	SU2Group.operate(Matrix<Complex> left, Matrix<Complex> right)
Matrix<Complex>	SU3Group.operate(Matrix<Complex> left, Matrix<Complex> right)

Constructors in org.episteme.core.mathematics.algebra.groups with parameters of type Matrix

Modifier	Constructor	Description
	LieGroup(Matrix<Complex>... generators)	Constructs a Lie Group from a set of generators.

Uses of Matrix in org.episteme.core.mathematics.analysis

Methods in org.episteme.core.mathematics.analysis that return Matrix

Modifier and Type	Method	Description
default Matrix<F>	VectorFunction.jacobian(Vector<F> point)	Calculates the Jacobian matrix at the given point.

Uses of Matrix in org.episteme.core.mathematics.analysis.fem

Methods in org.episteme.core.mathematics.analysis.fem that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	Element.computeJacobian(Vector<Real> localCoords)	Computes the Jacobian matrix at the given local coordinates.
Matrix<Real>	LinearElement1D.computeJacobian(Vector<Real> localCoords)
Matrix<Real>	TetrahedralElement3D.computeJacobian(Vector<Real> localCoords)
Matrix<Real>	TriangularElement2D.computeJacobian(Vector<Real> localCoords)

Uses of Matrix in org.episteme.core.mathematics.analysis.transform

Methods in org.episteme.core.mathematics.analysis.transform that return Matrix

Modifier and Type	Method	Description
Matrix<Complex>	DiscreteFourierTransform.jacobian(Vector<Complex> point)

Uses of Matrix in org.episteme.core.mathematics.linearalgebra

Subinterfaces with type arguments of type Matrix in org.episteme.core.mathematics.linearalgebra

Modifier and Type	Interface	Description
interface	Matrix<E>	Represents a matrix of scalar elements.
interface	Matrix<E>	Represents a matrix of scalar elements.

Methods in org.episteme.core.mathematics.linearalgebra that return Matrix

Modifier and Type	Method	Description
default Matrix<E>	LinearAlgebraProvider.acos(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.acosh(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	Matrix.add(Matrix<E> other)	Returns the sum of this matrix and another.
default Matrix<E>	Matrix.add(Matrix<E> a, Matrix<E> b)
default Matrix<E>	LinearAlgebraProvider.asin(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.asinh(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.atan(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.atanh(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.cbrt(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.conjugateTranspose(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.cos(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.cosh(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.exp(Matrix<E> a)	Computes the matrix exponential e^A.
default Matrix<E>	SparseLinearAlgebraProvider.fromDense(Matrix<E> a)	Converts a dense matrix to its sparse representation.
Matrix<E>	Matrix.getSubMatrix(int rowStart, int rowEnd, int colStart, int colEnd)	Returns a submatrix of this matrix.
default Matrix<E>	Matrix.identity()
static <E> Matrix<E>	Matrix.identity(int size, Ring<E> ring)	Creates an identity matrix.
default Matrix<E>	LinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	Matrix.inverse()	Returns the multiplicative inverse of this matrix.
default Matrix<E>	Matrix.inverse(Matrix<E> element)
default Matrix<E>	LinearAlgebraProvider.log(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.log10(Matrix<E> a)
default Matrix<E>	Matrix.map(Function<E,E> mapper)	Applies a mapping function to each element of this matrix.
default Matrix<E>	LinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	Matrix.multiply(Matrix<E> other)	Returns the product of this matrix and another.
default Matrix<E>	Matrix.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	Matrix.negate()	Returns the negation of this matrix (-this).
static <E> Matrix<E>	Matrix.of(E[][] data, Ring<E> ring)	Creates a matrix from a 2D array.
static <E> Matrix<E>	Matrix.of(List<List<E>> data, Ring<E> ring)	Creates a matrix from a 2D list.
default Matrix<E>	Matrix.operate(Matrix<E> left, Matrix<E> right)
default Matrix<E>	LinearAlgebraProvider.pow(Matrix<E> a, E exponent)
default Matrix<E>	LinearAlgebraProvider.scale(E scalar, Matrix<E> a)
default Matrix<E>	Matrix.scale(E scalar)	Convenience scalar multiplication (scalar × this).
Matrix<E>	Matrix.scale(E scalar, Matrix<E> element)
default Matrix<E>	LinearAlgebraProvider.sin(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.sinh(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.sqrt(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
default Matrix<E>	Matrix.subtract(Matrix<E> other)	Returns the difference of this matrix and another.
default Matrix<E>	LinearAlgebraProvider.tan(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.tanh(Matrix<E> a)
default Matrix<E>	SparseLinearAlgebraProvider.toDense(Matrix<E> a)	Converts a sparse matrix to its dense representation.
default Matrix<E>	Vector.toMatrix()	Converts this vector to a column matrix (Nx1).
default Matrix<E>	LinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	Matrix.transpose()	Returns the transpose of this matrix.
static <E> Matrix<E>	Matrix.triangular(List<List<E>> data, Ring<E> ring)	Creates a triangular matrix from a 2D list.
static <E> Matrix<E>	Matrix.tridiagonal(List<List<E>> data, Ring<E> ring)	Creates a tridiagonal matrix from a 2D list.
Matrix<E>	Matrix.zero()	Returns the zero matrix of the same dimensions.
static <E> Matrix<E>	Matrix.zeros(int rows, int cols, Ring<E> ring)	Creates a matrix of zeros.

Methods in org.episteme.core.mathematics.linearalgebra with parameters of type Matrix

Modifier and Type	Method	Description
default Matrix<E>	LinearAlgebraProvider.acos(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.acosh(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	Matrix.add(Matrix<E> other)	Returns the sum of this matrix and another.
default Matrix<E>	Matrix.add(Matrix<E> a, Matrix<E> b)
default Matrix<E>	LinearAlgebraProvider.asin(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.asinh(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.atan(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.atanh(Matrix<E> a)
static <E> Vector<E>	Decomposition.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)	Solves Ax = b using BiCGSTAB.
default Vector<E>	SparseLinearAlgebraProvider.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)	Solves Ax = b using BiCGSTAB (BiConjugate Gradient Stabilized) method.
default Matrix<E>	LinearAlgebraProvider.cbrt(Matrix<E> a)
static <E> CholeskyResult<E>	Decomposition.cholesky(Matrix<E> matrix)	Computes the Cholesky decomposition of the specified matrix.
default CholeskyResult<E>	LinearAlgebraProvider.cholesky(Matrix<E> a)	Computes the Cholesky decomposition of the specified matrix.
default E	LinearAlgebraProvider.conditionNumber(Matrix<E> a)	Returns the condition number of the matrix (L2 norm).
default E	SparseLinearAlgebraProvider.conditionNumber(Matrix<E> a)
static <E> Vector<E>	Decomposition.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)	Solves Ax = b using Conjugate Gradient.
default Vector<E>	SparseLinearAlgebraProvider.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)	Solves Ax = b using Conjugate Gradient method.
default Matrix<E>	LinearAlgebraProvider.conjugateTranspose(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.cos(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.cosh(Matrix<E> a)
default E	LinearAlgebraProvider.determinant(Matrix<E> a)
static <E> EigenResult<E>	Decomposition.eigen(Matrix<E> matrix)	Computes the eigenvalue decomposition of the specified matrix.
default EigenResult<E>	LinearAlgebraProvider.eigen(Matrix<E> a)	Computes the eigenvalue decomposition of the specified matrix.
default Matrix<E>	LinearAlgebraProvider.exp(Matrix<E> a)	Computes the matrix exponential e^A.
default Matrix<E>	SparseLinearAlgebraProvider.fromDense(Matrix<E> a)	Converts a dense matrix to its sparse representation.
static <E> Vector<E>	Decomposition.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts)	Solves Ax = b using GMRES.
default Vector<E>	SparseLinearAlgebraProvider.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts)	Solves Ax = b using GMRES (Generalized Minimal Residual) method.
default Matrix<E>	LinearAlgebraProvider.inverse(Matrix<E> a)
default Matrix<E>	Matrix.inverse(Matrix<E> element)
default Matrix<E>	LinearAlgebraProvider.log(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.log10(Matrix<E> a)
static <E> LUResult<E>	Decomposition.lu(Matrix<E> matrix)	Computes the LU decomposition of the specified matrix.
default LUResult<E>	LinearAlgebraProvider.lu(Matrix<E> a)	Computes the LU decomposition of the specified matrix.
default Matrix<E>	LinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
default Vector<E>	LinearAlgebraProvider.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	Matrix.multiply(Matrix<E> other)	Returns the product of this matrix and another.
default Matrix<E>	Matrix.multiply(Matrix<E> a, Matrix<E> b)
default Matrix<E>	Matrix.operate(Matrix<E> left, Matrix<E> right)
default Matrix<E>	LinearAlgebraProvider.pow(Matrix<E> a, E exponent)
static <E> QRResult<E>	Decomposition.qr(Matrix<E> matrix)	Computes the QR decomposition of the specified matrix.
default QRResult<E>	LinearAlgebraProvider.qr(Matrix<E> a)	Computes the QR decomposition of the specified matrix.
default int	LinearAlgebraProvider.rank(Matrix<E> a)	Returns the rank of the matrix.
default int	SparseLinearAlgebraProvider.rank(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	Matrix.scale(E scalar, Matrix<E> element)
default Matrix<E>	LinearAlgebraProvider.sin(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.sinh(Matrix<E> a)
static <E> Vector<E>	Decomposition.solve(Matrix<E> a, Vector<E> b)	Solves Ax = b using the most appropriate decomposition.
default Vector<E>	LinearAlgebraProvider.solve(Matrix<E> a, Vector<E> b)
default Vector<E>	LinearAlgebraProvider.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)	Solves the triangular system Ax = b.
default Matrix<E>	LinearAlgebraProvider.sqrt(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
default Matrix<E>	Matrix.subtract(Matrix<E> other)	Returns the difference of this matrix and another.
static <E> SVDResult<E>	Decomposition.svd(Matrix<E> matrix)	Computes the Singular Value Decomposition (SVD) of the specified matrix.
default SVDResult<E>	LinearAlgebraProvider.svd(Matrix<E> a)	Computes the Singular Value Decomposition (SVD) of the specified matrix.
default Matrix<E>	LinearAlgebraProvider.tan(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.tanh(Matrix<E> a)
default Matrix<E>	SparseLinearAlgebraProvider.toDense(Matrix<E> a)	Converts a sparse matrix to its dense representation.
default E	LinearAlgebraProvider.trace(Matrix<E> a)
default Matrix<E>	LinearAlgebraProvider.transpose(Matrix<E> a)

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.algorithms

Methods in org.episteme.core.mathematics.linearalgebra.algorithms that return Matrix

Modifier and Type	Method	Description
static <E> Matrix<E>	MatrixMultiplicationPlanner.multiply(Matrix<E> A, Matrix<E> B)
static <E> Matrix<E>	RealCARMAAlgorithm.multiply(Matrix<E> A, Matrix<E> B, LinearAlgebraProvider<E> leafProvider)
static <E> Matrix<E>	RealStrassenAlgorithm.multiply(Matrix<E> A, Matrix<E> B, LinearAlgebraProvider<E> leafProvider)

Methods in org.episteme.core.mathematics.linearalgebra.algorithms with parameters of type Matrix

Modifier and Type	Method	Description
static void	DistributedCannonAlgorithm.multiply(Matrix<Real> A, Matrix<Real> B, Matrix<Real> C, DistributedContext ctx)	Multiplies two matrices distributed across a 2D processor grid.
static <E> Matrix<E>	MatrixMultiplicationPlanner.multiply(Matrix<E> A, Matrix<E> B)
static <E> Matrix<E>	RealCARMAAlgorithm.multiply(Matrix<E> A, Matrix<E> B, LinearAlgebraProvider<E> leafProvider)
static <E> Matrix<E>	RealStrassenAlgorithm.multiply(Matrix<E> A, Matrix<E> B, LinearAlgebraProvider<E> leafProvider)

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.backends

Methods in org.episteme.core.mathematics.linearalgebra.backends that return Matrix

Modifier and Type	Method	Description
Matrix<E>	ColtBackend.acos(Matrix<E> a)
Matrix<E>	EJMLBackend.acos(Matrix<E> a)
Matrix<E>	JBlasBackend.acos(Matrix<E> a)
Matrix<E>	ColtBackend.acosh(Matrix<E> a)
Matrix<E>	EJMLBackend.acosh(Matrix<E> a)
Matrix<E>	JBlasBackend.acosh(Matrix<E> a)
Matrix<E>	ColtBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	CommonsMathBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	EJMLBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	EpistemeLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	JBlasBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	ColtBackend.asin(Matrix<E> a)
Matrix<E>	EJMLBackend.asin(Matrix<E> a)
Matrix<E>	JBlasBackend.asin(Matrix<E> a)
Matrix<E>	ColtBackend.asinh(Matrix<E> a)
Matrix<E>	EJMLBackend.asinh(Matrix<E> a)
Matrix<E>	JBlasBackend.asinh(Matrix<E> a)
Matrix<E>	ColtBackend.atan(Matrix<E> a)
Matrix<E>	EJMLBackend.atan(Matrix<E> a)
Matrix<E>	JBlasBackend.atan(Matrix<E> a)
Matrix<E>	ColtBackend.atanh(Matrix<E> a)
Matrix<E>	EJMLBackend.atanh(Matrix<E> a)
Matrix<E>	JBlasBackend.atanh(Matrix<E> a)
Matrix<E>	ColtBackend.cbrt(Matrix<E> a)
Matrix<E>	EJMLBackend.cbrt(Matrix<E> a)
Matrix<E>	JBlasBackend.cbrt(Matrix<E> a)
Matrix<E>	ColtBackend.cos(Matrix<E> a)
Matrix<E>	EJMLBackend.cos(Matrix<E> a)
Matrix<E>	JBlasBackend.cos(Matrix<E> a)
Matrix<E>	ColtBackend.cosh(Matrix<E> a)
Matrix<E>	EJMLBackend.cosh(Matrix<E> a)
Matrix<E>	JBlasBackend.cosh(Matrix<E> a)
Matrix<E>	ColtBackend.exp(Matrix<E> a)
Matrix<E>	EJMLBackend.exp(Matrix<E> a)
Matrix<E>	JBlasBackend.exp(Matrix<E> a)
Matrix<E>	ColtBackend.inverse(Matrix<E> a)
Matrix<E>	CommonsMathBackend.inverse(Matrix<E> a)
Matrix<E>	EJMLBackend.inverse(Matrix<E> a)
Matrix<E>	EpistemeLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	JBlasBackend.inverse(Matrix<E> a)
Matrix<E>	ColtBackend.log(Matrix<E> a)
Matrix<E>	EJMLBackend.log(Matrix<E> a)
Matrix<E>	JBlasBackend.log(Matrix<E> a)
Matrix<E>	ColtBackend.log10(Matrix<E> a)
Matrix<E>	EJMLBackend.log10(Matrix<E> a)
Matrix<E>	JBlasBackend.log10(Matrix<E> a)
Matrix<E>	ColtBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	CommonsMathBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	EJMLBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	EpistemeLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	JBlasBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	ColtBackend.pow(Matrix<E> a, E exponent)
Matrix<E>	EJMLBackend.pow(Matrix<E> a, E exponent)
Matrix<E>	JBlasBackend.pow(Matrix<E> a, E exponent)
Matrix<E>	ColtBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	CommonsMathBackend.scale(E s, Matrix<E> a)
Matrix<E>	EJMLBackend.scale(E s, Matrix<E> a)
Matrix<E>	EpistemeLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	JBlasBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	ColtBackend.sin(Matrix<E> a)
Matrix<E>	EJMLBackend.sin(Matrix<E> a)
Matrix<E>	JBlasBackend.sin(Matrix<E> a)
Matrix<E>	ColtBackend.sinh(Matrix<E> a)
Matrix<E>	EJMLBackend.sinh(Matrix<E> a)
Matrix<E>	JBlasBackend.sinh(Matrix<E> a)
Matrix<E>	ColtBackend.sqrt(Matrix<E> a)
Matrix<E>	EJMLBackend.sqrt(Matrix<E> a)
Matrix<E>	JBlasBackend.sqrt(Matrix<E> a)
Matrix<E>	ColtBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	CommonsMathBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	EJMLBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	EpistemeLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	JBlasBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	ColtBackend.tan(Matrix<E> a)
Matrix<E>	EJMLBackend.tan(Matrix<E> a)
Matrix<E>	JBlasBackend.tan(Matrix<E> a)
Matrix<E>	ColtBackend.tanh(Matrix<E> a)
Matrix<E>	EJMLBackend.tanh(Matrix<E> a)
Matrix<E>	JBlasBackend.tanh(Matrix<E> a)
Matrix<E>	ColtBackend.transpose(Matrix<E> a)
Matrix<E>	CommonsMathBackend.transpose(Matrix<E> a)
Matrix<E>	EJMLBackend.transpose(Matrix<E> a)
Matrix<E>	EpistemeLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	JBlasBackend.transpose(Matrix<E> a)

Methods in org.episteme.core.mathematics.linearalgebra.backends with parameters of type Matrix

Modifier and Type	Method	Description
Matrix<E>	ColtBackend.acos(Matrix<E> a)
Matrix<E>	EJMLBackend.acos(Matrix<E> a)
Matrix<E>	JBlasBackend.acos(Matrix<E> a)
Matrix<E>	ColtBackend.acosh(Matrix<E> a)
Matrix<E>	EJMLBackend.acosh(Matrix<E> a)
Matrix<E>	JBlasBackend.acosh(Matrix<E> a)
Matrix<E>	ColtBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	CommonsMathBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	EJMLBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	EpistemeLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	JBlasBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	ColtBackend.asin(Matrix<E> a)
Matrix<E>	EJMLBackend.asin(Matrix<E> a)
Matrix<E>	JBlasBackend.asin(Matrix<E> a)
Matrix<E>	ColtBackend.asinh(Matrix<E> a)
Matrix<E>	EJMLBackend.asinh(Matrix<E> a)
Matrix<E>	JBlasBackend.asinh(Matrix<E> a)
Matrix<E>	ColtBackend.atan(Matrix<E> a)
Matrix<E>	EJMLBackend.atan(Matrix<E> a)
Matrix<E>	JBlasBackend.atan(Matrix<E> a)
Matrix<E>	ColtBackend.atanh(Matrix<E> a)
Matrix<E>	EJMLBackend.atanh(Matrix<E> a)
Matrix<E>	JBlasBackend.atanh(Matrix<E> a)
Vector<E>	EpistemeLinearAlgebraBackend.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Matrix<E>	ColtBackend.cbrt(Matrix<E> a)
Matrix<E>	EJMLBackend.cbrt(Matrix<E> a)
Matrix<E>	JBlasBackend.cbrt(Matrix<E> a)
CholeskyResult<E>	ColtBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	CommonsMathBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	EJMLBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	EpistemeLinearAlgebraBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	JBlasBackend.cholesky(Matrix<E> a)
Vector<E>	EpistemeLinearAlgebraBackend.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Matrix<E>	ColtBackend.cos(Matrix<E> a)
Matrix<E>	EJMLBackend.cos(Matrix<E> a)
Matrix<E>	JBlasBackend.cos(Matrix<E> a)
Matrix<E>	ColtBackend.cosh(Matrix<E> a)
Matrix<E>	EJMLBackend.cosh(Matrix<E> a)
Matrix<E>	JBlasBackend.cosh(Matrix<E> a)
E	ColtBackend.determinant(Matrix<E> a)
E	CommonsMathBackend.determinant(Matrix<E> a)
E	EJMLBackend.determinant(Matrix<E> a)
E	EpistemeLinearAlgebraBackend.determinant(Matrix<E> a)
E	JBlasBackend.determinant(Matrix<E> a)
EigenResult<E>	ColtBackend.eigen(Matrix<E> a)
EigenResult<E>	CommonsMathBackend.eigen(Matrix<E> a)
EigenResult<E>	EJMLBackend.eigen(Matrix<E> a)
EigenResult<E>	EpistemeLinearAlgebraBackend.eigen(Matrix<E> a)
EigenResult<E>	JBlasBackend.eigen(Matrix<E> a)
Matrix<E>	ColtBackend.exp(Matrix<E> a)
Matrix<E>	EJMLBackend.exp(Matrix<E> a)
Matrix<E>	JBlasBackend.exp(Matrix<E> a)
Vector<E>	EpistemeLinearAlgebraBackend.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts)
Matrix<E>	ColtBackend.inverse(Matrix<E> a)
Matrix<E>	CommonsMathBackend.inverse(Matrix<E> a)
Matrix<E>	EJMLBackend.inverse(Matrix<E> a)
Matrix<E>	EpistemeLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	JBlasBackend.inverse(Matrix<E> a)
Matrix<E>	ColtBackend.log(Matrix<E> a)
Matrix<E>	EJMLBackend.log(Matrix<E> a)
Matrix<E>	JBlasBackend.log(Matrix<E> a)
Matrix<E>	ColtBackend.log10(Matrix<E> a)
Matrix<E>	EJMLBackend.log10(Matrix<E> a)
Matrix<E>	JBlasBackend.log10(Matrix<E> a)
LUResult<E>	ColtBackend.lu(Matrix<E> a)
LUResult<E>	CommonsMathBackend.lu(Matrix<E> a)
LUResult<E>	EJMLBackend.lu(Matrix<E> a)
LUResult<E>	EpistemeLinearAlgebraBackend.lu(Matrix<E> a)
LUResult<E>	JBlasBackend.lu(Matrix<E> a)
Matrix<E>	ColtBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	ColtBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	CommonsMathBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	CommonsMathBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	EJMLBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	EJMLBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	EpistemeLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	EpistemeLinearAlgebraBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	JBlasBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	JBlasBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	ColtBackend.pow(Matrix<E> a, E exponent)
Matrix<E>	EJMLBackend.pow(Matrix<E> a, E exponent)
Matrix<E>	JBlasBackend.pow(Matrix<E> a, E exponent)
QRResult<E>	ColtBackend.qr(Matrix<E> a)
QRResult<E>	CommonsMathBackend.qr(Matrix<E> a)
QRResult<E>	EJMLBackend.qr(Matrix<E> a)
QRResult<E>	EpistemeLinearAlgebraBackend.qr(Matrix<E> a)
QRResult<E>	JBlasBackend.qr(Matrix<E> a)
Matrix<E>	ColtBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	CommonsMathBackend.scale(E s, Matrix<E> a)
Matrix<E>	EJMLBackend.scale(E s, Matrix<E> a)
Matrix<E>	EpistemeLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	JBlasBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	ColtBackend.sin(Matrix<E> a)
Matrix<E>	EJMLBackend.sin(Matrix<E> a)
Matrix<E>	JBlasBackend.sin(Matrix<E> a)
Matrix<E>	ColtBackend.sinh(Matrix<E> a)
Matrix<E>	EJMLBackend.sinh(Matrix<E> a)
Matrix<E>	JBlasBackend.sinh(Matrix<E> a)
Vector<E>	ColtBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	CommonsMathBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	EJMLBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	EpistemeLinearAlgebraBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	JBlasBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	EJMLBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	EpistemeLinearAlgebraBackend.solveTriangular(Matrix<E> a, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	JBlasBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Matrix<E>	ColtBackend.sqrt(Matrix<E> a)
Matrix<E>	EJMLBackend.sqrt(Matrix<E> a)
Matrix<E>	JBlasBackend.sqrt(Matrix<E> a)
Matrix<E>	ColtBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	CommonsMathBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	EJMLBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	EpistemeLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	JBlasBackend.subtract(Matrix<E> a, Matrix<E> b)
SVDResult<E>	ColtBackend.svd(Matrix<E> a)
SVDResult<E>	CommonsMathBackend.svd(Matrix<E> a)
SVDResult<E>	EJMLBackend.svd(Matrix<E> a)
SVDResult<E>	EpistemeLinearAlgebraBackend.svd(Matrix<E> a)
SVDResult<E>	JBlasBackend.svd(Matrix<E> a)
Matrix<E>	ColtBackend.tan(Matrix<E> a)
Matrix<E>	EJMLBackend.tan(Matrix<E> a)
Matrix<E>	JBlasBackend.tan(Matrix<E> a)
Matrix<E>	ColtBackend.tanh(Matrix<E> a)
Matrix<E>	EJMLBackend.tanh(Matrix<E> a)
Matrix<E>	JBlasBackend.tanh(Matrix<E> a)
E	ColtBackend.trace(Matrix<E> a)
E	CommonsMathBackend.trace(Matrix<E> a)
E	EJMLBackend.trace(Matrix<E> a)
E	EpistemeLinearAlgebraBackend.trace(Matrix<E> a)
E	JBlasBackend.trace(Matrix<E> a)
Matrix<E>	ColtBackend.transpose(Matrix<E> a)
Matrix<E>	CommonsMathBackend.transpose(Matrix<E> a)
Matrix<E>	EJMLBackend.transpose(Matrix<E> a)
Matrix<E>	EpistemeLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	JBlasBackend.transpose(Matrix<E> a)

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.matrices

Classes in org.episteme.core.mathematics.linearalgebra.matrices that implement Matrix

Modifier and Type	Class	Description
class	DenseMatrix<E>	A dense matrix implementation.
class	GenericMatrix<E>	A generic matrix implementation with smart storage and provider selection.
class	MMapMatrix	Memory-Mapped Matrix implementation for Out-of-Core processing.
class	RealDoubleMatrix	A specialized Matrix implementation for Doubles with SIMD and Native optimization.
class	SIMDRealDoubleMatrix	SIMD-accelerated Matrix implementation using JDK Vector API.
class	SIMDRealFloatMatrix	SIMD-accelerated Matrix implementation using JDK Vector API for Float (Single) precision.
class	SparseMatrix<E>	A sparse matrix implementation.
class	TiledMatrix<E>	A matrix decomposed into smaller tiles (blocks).

Methods in org.episteme.core.mathematics.linearalgebra.matrices that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	SIMDRealDoubleMatrix.abs()
Matrix<Real>	SIMDRealFloatMatrix.abs()
Matrix<Real>	SIMDRealDoubleMatrix.acos()
Matrix<Real>	SIMDRealFloatMatrix.acos()
Matrix<Real>	SIMDRealDoubleMatrix.acosh()
Matrix<Real>	SIMDRealFloatMatrix.acosh()
Matrix<E>	GenericMatrix.add(Matrix<E> other)
Matrix<Real>	MMapMatrix.add(Matrix<Real> other)
Matrix<Real>	RealDoubleMatrix.add(Matrix<Real> other)
Matrix<Real>	SIMDRealDoubleMatrix.add(Matrix<Real> other)
Matrix<Real>	SIMDRealFloatMatrix.add(Matrix<Real> other)
Matrix<Real>	SIMDRealDoubleMatrix.asin()
Matrix<Real>	SIMDRealFloatMatrix.asin()
Matrix<Real>	SIMDRealDoubleMatrix.asinh()
Matrix<Real>	SIMDRealFloatMatrix.asinh()
Matrix<Real>	SIMDRealDoubleMatrix.atan()
Matrix<Real>	SIMDRealFloatMatrix.atan()
Matrix<Real>	SIMDRealDoubleMatrix.atanh()
Matrix<Real>	SIMDRealFloatMatrix.atanh()
Matrix<Real>	SIMDRealDoubleMatrix.cbrt()
Matrix<Real>	SIMDRealFloatMatrix.cbrt()
Matrix<Real>	SIMDRealDoubleMatrix.cos()
Matrix<Real>	SIMDRealFloatMatrix.cos()
Matrix<Real>	SIMDRealDoubleMatrix.cosh()
Matrix<Real>	SIMDRealFloatMatrix.cosh()
Matrix<Real>	SIMDRealDoubleMatrix.exp()
Matrix<Real>	SIMDRealFloatMatrix.exp()
Matrix<E>	GenericMatrix.getSubMatrix(int rowStart, int rowEnd, int colStart, int colEnd)
Matrix<Real>	MMapMatrix.getSubMatrix(int rs, int re, int cs, int ce)
Matrix<Real>	SIMDRealDoubleMatrix.getSubMatrix(int rs, int re, int cs, int ce)
Matrix<E>	TiledMatrix.getTile(int i, int j)
Matrix<E>	GenericMatrix.inverse()
Matrix<Real>	MMapMatrix.inverse()
Matrix<Real>	SIMDRealDoubleMatrix.inverse()
Matrix<Real>	SIMDRealDoubleMatrix.log()
Matrix<Real>	SIMDRealFloatMatrix.log()
Matrix<Real>	SIMDRealDoubleMatrix.log10()
Matrix<Real>	SIMDRealFloatMatrix.log10()
static <E> Matrix<E>	DistributedMatrixMultiply.multiply(TiledMatrix<E> A, TiledMatrix<E> B)	Multiplies two matrices using a tiled algorithm distributed across the current context.
Matrix<E>	GenericMatrix.multiply(Matrix<E> other)
Matrix<Real>	MMapMatrix.multiply(Matrix<Real> other)
Matrix<Real>	RealDoubleMatrix.multiply(Matrix<Real> other)
Matrix<Real>	SIMDRealDoubleMatrix.multiply(Matrix<Real> other)
Matrix<Real>	SIMDRealFloatMatrix.multiply(Matrix<Real> other)
Matrix<E>	GenericMatrix.negate()
Matrix<Real>	MMapMatrix.negate()
Matrix<Real>	SIMDRealDoubleMatrix.negate()
Matrix<Real>	SIMDRealFloatMatrix.negate()
static <E> Matrix<E>	DenseMatrix.of(E[][] data, Ring<E> ring)	Creates a DenseMatrix with automatic storage optimization.
static <E> Matrix<E>	DenseMatrix.of(List<List<E>> rows, Ring<E> ring)	Creates a DenseMatrix with automatic storage optimization.
Matrix<E>	GenericMatrix.one()
Matrix<Real>	MMapMatrix.one()
Matrix<Real>	SIMDRealDoubleMatrix.one()
Matrix<Real>	SIMDRealFloatMatrix.one()
Matrix<Real>	SIMDRealDoubleMatrix.powScalar(double exponent)
Matrix<Real>	SIMDRealFloatMatrix.powScalar(float exponent)
Matrix<E>	GenericMatrix.scale(E scalar, Matrix<E> element)
Matrix<Real>	MMapMatrix.scale(Real scalar, Matrix<Real> element)
Matrix<Real>	SIMDRealDoubleMatrix.scale(double scalar)
Matrix<Real>	SIMDRealDoubleMatrix.scale(Real scalar, Matrix<Real> element)
Matrix<Real>	SIMDRealFloatMatrix.scale(float scalar)
Matrix<Real>	SIMDRealDoubleMatrix.sin()
Matrix<Real>	SIMDRealFloatMatrix.sin()
Matrix<Real>	SIMDRealDoubleMatrix.sinh()
Matrix<Real>	SIMDRealFloatMatrix.sinh()
Matrix<Real>	SIMDRealDoubleMatrix.sqrt()
Matrix<Real>	SIMDRealFloatMatrix.sqrt()
Matrix<Real>	SIMDRealDoubleMatrix.subtract(Matrix<Real> other)
Matrix<Real>	SIMDRealFloatMatrix.subtract(Matrix<Real> other)
Matrix<Real>	SIMDRealDoubleMatrix.tan()
Matrix<Real>	SIMDRealFloatMatrix.tan()
Matrix<Real>	SIMDRealDoubleMatrix.tanh()
Matrix<Real>	SIMDRealFloatMatrix.tanh()
Matrix<E>	GenericMatrix.transpose()
Matrix<Real>	MMapMatrix.transpose()
Matrix<Real>	SIMDRealDoubleMatrix.transpose()
Matrix<Real>	SIMDRealFloatMatrix.transpose()
Matrix<E>	GenericMatrix.zero()
Matrix<Real>	MMapMatrix.zero()
Matrix<Real>	SIMDRealDoubleMatrix.zero()
Matrix<Real>	SIMDRealFloatMatrix.zero()

Methods in org.episteme.core.mathematics.linearalgebra.matrices with parameters of type Matrix

Modifier and Type	Method	Description
Matrix<E>	GenericMatrix.add(Matrix<E> other)
Matrix<Real>	MMapMatrix.add(Matrix<Real> other)
Matrix<Real>	RealDoubleMatrix.add(Matrix<Real> other)
Matrix<Real>	SIMDRealDoubleMatrix.add(Matrix<Real> other)
Matrix<Real>	SIMDRealFloatMatrix.add(Matrix<Real> other)
boolean	GenericMatrix.contains(Matrix<E> element)
boolean	MMapMatrix.contains(Matrix<Real> element)
boolean	SIMDRealDoubleMatrix.contains(Matrix<Real> element)
static SIMDRealDoubleMatrix	SIMDRealDoubleMatrix.from(Matrix<Real> m)
static SIMDRealFloatMatrix	SIMDRealFloatMatrix.from(Matrix<Real> m)
Matrix<E>	GenericMatrix.multiply(Matrix<E> other)
Matrix<Real>	MMapMatrix.multiply(Matrix<Real> other)
Matrix<Real>	RealDoubleMatrix.multiply(Matrix<Real> other)
Matrix<Real>	SIMDRealDoubleMatrix.multiply(Matrix<Real> other)
Matrix<Real>	SIMDRealFloatMatrix.multiply(Matrix<Real> other)
Matrix<E>	GenericMatrix.scale(E scalar, Matrix<E> element)
Matrix<Real>	MMapMatrix.scale(Real scalar, Matrix<Real> element)
Matrix<Real>	SIMDRealDoubleMatrix.scale(Real scalar, Matrix<Real> element)
void	TiledMatrix.setTile(int i, int j, Matrix<E> tile)
Matrix<Real>	SIMDRealDoubleMatrix.subtract(Matrix<Real> other)
Matrix<Real>	SIMDRealFloatMatrix.subtract(Matrix<Real> other)
void	TiledMatrix.updateTile(int i, int j, Matrix<E> delta)	Thread-safe update of a tile (adds delta to current tile).

Constructors in org.episteme.core.mathematics.linearalgebra.matrices with parameters of type Matrix

Modifier	Constructor	Description
	TiledMatrix(Matrix<E> original, int tileRows, int tileCols)	Creates a TiledMatrix from an existing matrix.

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.matrices.solvers

Methods in org.episteme.core.mathematics.linearalgebra.matrices.solvers that return Matrix

Modifier and Type	Method	Description
Matrix<E>	EigenResult.getEigenvectors()
Matrix<E>	CholeskyResult.getL()
Matrix<E>	LUResult.getL()
Matrix<E>	LUResult.getOriginalA()	Reconstructs the original matrix A (un-permuted).
Matrix<E>	QRResult.getQ()
Matrix<E>	QRResult.getR()
Matrix<E>	LUResult.getU()
Matrix<E>	SVDResult.getU()
Matrix<E>	EigenResult.getV()
Matrix<E>	SVDResult.getV()
static <E> Matrix<E>	GenericLU.inverse(Matrix<E> a, Field<E> field, LinearAlgebraProvider<E> provider)
Matrix<E>	CholeskyResult.L()	Returns the value of the L record component.
Matrix<E>	LUResult.L()	Returns the value of the L record component.
Matrix<E>	QRResult.Q()	Returns the value of the Q record component.
Matrix<E>	QRResult.R()	Returns the value of the R record component.
Matrix<E>	LUResult.reconstruct()	Reconstructs the matrix A (as permuted by P).
Matrix<E>	LUResult.U()	Returns the value of the U record component.
Matrix<E>	SVDResult.U()	Returns the value of the U record component.
Matrix<E>	EigenResult.V()	Returns the value of the V record component.
Matrix<E>	SVDResult.V()	Returns the value of the V record component.

Methods in org.episteme.core.mathematics.linearalgebra.matrices.solvers with parameters of type Matrix

Modifier and Type	Method	Description
static CholeskyResult<Real>	CholeskyDecomposition.decompose(Matrix<Real> matrix)	Computes Cholesky decomposition using the best available LinearAlgebraProvider.
static EigenResult<Real>	EigenDecomposition.decompose(Matrix<Real> matrix)	Computes Eigenvalue decomposition using the best available LinearAlgebraProvider.
static <E> CholeskyResult<E>	GenericCholesky.decompose(Matrix<E> matrix, Field<E> field, LinearAlgebraProvider<E> provider)
static <E> EigenResult<E>	GenericEigen.decompose(Matrix<E> matrix, Field<E> field, LinearAlgebraProvider<E> provider)
static <E> LUResult<E>	GenericLU.decompose(Matrix<E> matrix, Field<E> field, LinearAlgebraProvider<E> provider)
static <E> QRResult<E>	GenericQR.decompose(Matrix<E> matrix, Field<E> field, LinearAlgebraProvider<E> provider)
static <E> SVDResult<E>	GenericSVD.decompose(Matrix<E> matrix, Field<E> field, LinearAlgebraProvider<E> provider)
static LUResult<Real>	LUDecomposition.decompose(Matrix<Real> matrix)	Computes LU decomposition using the best available LinearAlgebraProvider.
static QRResult<Real>	QRDecomposition.decompose(Matrix<Real> matrix)	Computes QR decomposition using the best available LinearAlgebraProvider.
static SVDResult<Real>	SVDDecomposition.decompose(Matrix<Real> matrix)	Computes SVD decomposition using the best available LinearAlgebraProvider.
static <E> E	GenericLU.determinant(Matrix<E> a, Field<E> field, LinearAlgebraProvider<E> provider)
static <E> Matrix<E>	GenericLU.inverse(Matrix<E> a, Field<E> field, LinearAlgebraProvider<E> provider)
static boolean	MatrixSolver.isSymmetric(Matrix<Real> A)
static MatrixSolver.Strategy	MatrixSolver.recommend(Matrix<Real> A)	Recommends the best solver strategy for the given matrix.
static <E> Vector<E>	GenericLU.solve(Matrix<E> a, Vector<E> b, Field<E> field, LinearAlgebraProvider<E> provider)
static Real[]	MatrixSolver.solve(Matrix<Real> A, Real[] b)	Solves Ax = b with automatic algorithm selection.
static Real[]	MatrixSolver.solve(Matrix<Real> A, Real[] b, MatrixSolver.Strategy strategy)	Solves Ax = b with explicit algorithm selection.

Constructors in org.episteme.core.mathematics.linearalgebra.matrices.solvers with parameters of type Matrix

Modifier	Constructor	Description
	CholeskyResult(Matrix<E> L)	Creates an instance of a CholeskyResult record class.
	EigenResult(Matrix<E> V, Vector<E> D)	Creates an instance of a EigenResult record class.
	LUResult(Matrix<E> L, Matrix<E> U, Vector<E> P)	Creates an instance of a LUResult record class.
	QRResult(Matrix<E> Q, Matrix<E> R)	Creates an instance of a QRResult record class.
	SVDResult(Matrix<E> U, Vector<E> S, Matrix<E> V)	Creates an instance of a SVDResult record class.

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.matrices.solvers.sparse

Methods in org.episteme.core.mathematics.linearalgebra.matrices.solvers.sparse with parameters of type Matrix

Modifier and Type	Method	Description
static <E> Vector<E>	GenericSparseSolvers.bicgstab(SparseLinearAlgebraProvider<E> provider, Matrix<E> A, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, Field<E> f)
static <E> Vector<E>	GenericSparseSolvers.conjugateGradient(SparseLinearAlgebraProvider<E> provider, Matrix<E> A, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, Field<E> f)
static <E> Vector<E>	GenericSparseSolvers.gmres(SparseLinearAlgebraProvider<E> provider, Matrix<E> A, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts, Field<E> f)
static Real[]	BiCGSTAB.solve(Matrix<Real> A, Real[] b, Real[] x0, Real tolerance, int maxIterations)	Solves Ax = b using BiCGSTAB.
static Real[]	ConjugateGradient.solve(Matrix<Real> A, Real[] b, Real[] x0, Real tolerance, int maxIterations)	Solves Ax = b using Conjugate Gradient.
static Real[]	GMRES.solve(Matrix<Real> A, Real[] b, Real[] x0, Real tolerance, int maxIterations, int restarts)	Solves Ax = b using GMRES with restarts.

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.matrices.storage

Methods in org.episteme.core.mathematics.linearalgebra.matrices.storage that return Matrix

Modifier and Type	Method	Description
Matrix<E>	TiledMatrixStorage.getTile(int tileRow, int tileCol)	Gets a tile at the specified position.

Methods in org.episteme.core.mathematics.linearalgebra.matrices.storage with parameters of type Matrix

Modifier and Type	Method	Description
void	TiledMatrixStorage.setTile(int tileRow, int tileCol, Matrix<E> tile)	Sets a tile at the specified position.

Constructors in org.episteme.core.mathematics.linearalgebra.matrices.storage with parameters of type Matrix

Modifier	Constructor	Description
	TiledMatrixStorage(Matrix<E>[][] tiles, int rows, int cols, int tileRows, int tileCols)	Creates a tiled matrix storage.

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.providers

Methods in org.episteme.core.mathematics.linearalgebra.providers that return Matrix

Modifier and Type	Method	Description
Matrix<E>	CARMALinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.acosh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.acosh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	CPUSparseLinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	DistributedLinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	CARMALinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.asinh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.asinh(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.atanh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.atanh(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	CPUDenseLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	CPUSparseLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	DistributedLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	StandardLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	StrassenLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	CARMALinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	CPUDenseLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	CPUSparseLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	DistributedLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	StrassenLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	CARMALinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	StandardLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.sqrt(Matrix<E> a)
static <E> Matrix<E>	CPUDenseLinearAlgebraProvider.standardMultiply(Matrix<E> a, Matrix<E> b, Field<E> field, LinearAlgebraProvider<E> provider)
Matrix<E>	CPUDenseLinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	CPUSparseLinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	DistributedLinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	CARMALinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	StandardLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.transpose(Matrix<E> a)

Methods in org.episteme.core.mathematics.linearalgebra.providers with parameters of type Matrix

Modifier and Type	Method	Description
Matrix<E>	CARMALinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.acos(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.acosh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.acosh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	CPUSparseLinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	DistributedLinearAlgebraProvider.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	CARMALinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.asin(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.asinh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.asinh(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.atan(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.atanh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.atanh(Matrix<E> a)
Vector<E>	CPUSparseLinearAlgebraProvider.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	DistributedLinearAlgebraProvider.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Matrix<E>	CARMALinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.cbrt(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.cbrt(Matrix<E> a)
CholeskyResult<E>	CPUDenseLinearAlgebraProvider.cholesky(Matrix<E> a)
CholeskyResult<E>	CPUSparseLinearAlgebraProvider.cholesky(Matrix<E> a)
CholeskyResult<E>	DistributedLinearAlgebraProvider.cholesky(Matrix<E> a)
Vector<E>	CPUSparseLinearAlgebraProvider.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	DistributedLinearAlgebraProvider.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Matrix<E>	CARMALinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.cos(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.cosh(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.cosh(Matrix<E> a)
E	CPUDenseLinearAlgebraProvider.determinant(Matrix<E> a)
E	CPUSparseLinearAlgebraProvider.determinant(Matrix<E> a)
E	DistributedLinearAlgebraProvider.determinant(Matrix<E> a)
E	StrassenLinearAlgebraProvider.determinant(Matrix<E> a)
EigenResult<E>	CPUDenseLinearAlgebraProvider.eigen(Matrix<E> a)
EigenResult<E>	CPUSparseLinearAlgebraProvider.eigen(Matrix<E> a)
EigenResult<E>	DistributedLinearAlgebraProvider.eigen(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.exp(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.exp(Matrix<E> a)
Vector<E>	CPUSparseLinearAlgebraProvider.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts)
Vector<E>	DistributedLinearAlgebraProvider.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts)
Matrix<E>	CPUDenseLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.inverse(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.log(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.log10(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.log10(Matrix<E> a)
LUResult<E>	CPUDenseLinearAlgebraProvider.lu(Matrix<E> a)
LUResult<E>	CPUSparseLinearAlgebraProvider.lu(Matrix<E> a)
LUResult<E>	DistributedLinearAlgebraProvider.lu(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	CARMALinearAlgebraProvider.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	CPUDenseLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	CPUDenseLinearAlgebraProvider.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	CPUSparseLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	CPUSparseLinearAlgebraProvider.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	DistributedLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	DistributedLinearAlgebraProvider.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	StandardLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	StandardLinearAlgebraProvider.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	StrassenLinearAlgebraProvider.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	StrassenLinearAlgebraProvider.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	CARMALinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	CPUDenseLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	CPUSparseLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	DistributedLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
Matrix<E>	StrassenLinearAlgebraProvider.pow(Matrix<E> a, E exponent)
QRResult<E>	CPUDenseLinearAlgebraProvider.qr(Matrix<E> a)
QRResult<E>	CPUSparseLinearAlgebraProvider.qr(Matrix<E> a)
QRResult<E>	DistributedLinearAlgebraProvider.qr(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	StandardLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.scale(E scalar, Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.sin(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.sinh(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.sinh(Matrix<E> a)
Vector<E>	CPUDenseLinearAlgebraProvider.solve(Matrix<E> a, Vector<E> b)
Vector<E>	CPUSparseLinearAlgebraProvider.solve(Matrix<E> a, Vector<E> b)
Vector<E>	DistributedLinearAlgebraProvider.solve(Matrix<E> a, Vector<E> b)
Vector<E>	StrassenLinearAlgebraProvider.solve(Matrix<E> a, Vector<E> b)
Vector<E>	CPUDenseLinearAlgebraProvider.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	CPUSparseLinearAlgebraProvider.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	DistributedLinearAlgebraProvider.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Matrix<E>	CARMALinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.sqrt(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.sqrt(Matrix<E> a)
static <E> Matrix<E>	CPUDenseLinearAlgebraProvider.standardMultiply(Matrix<E> a, Matrix<E> b, Field<E> field, LinearAlgebraProvider<E> provider)
Matrix<E>	CPUDenseLinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	CPUSparseLinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	DistributedLinearAlgebraProvider.subtract(Matrix<E> a, Matrix<E> b)
SVDResult<E>	CPUDenseLinearAlgebraProvider.svd(Matrix<E> a)
SVDResult<E>	CPUSparseLinearAlgebraProvider.svd(Matrix<E> a)
SVDResult<E>	DistributedLinearAlgebraProvider.svd(Matrix<E> a)
SVDResult<E>	StandardLinearAlgebraProvider.svd(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.tan(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.tanh(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.tanh(Matrix<E> a)
E	CPUDenseLinearAlgebraProvider.trace(Matrix<E> a)
E	CPUSparseLinearAlgebraProvider.trace(Matrix<E> a)
E	DistributedLinearAlgebraProvider.trace(Matrix<E> a)
Matrix<E>	CARMALinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	CPUDenseLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	CPUSparseLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	DistributedLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	StandardLinearAlgebraProvider.transpose(Matrix<E> a)
Matrix<E>	StrassenLinearAlgebraProvider.transpose(Matrix<E> a)

Uses of Matrix in org.episteme.core.mathematics.linearalgebra.vectors

Methods in org.episteme.core.mathematics.linearalgebra.vectors that return Matrix

Modifier and Type	Method	Description
Matrix<E>	GenericVector.toMatrix()

Uses of Matrix in org.episteme.core.mathematics.ml

Methods in org.episteme.core.mathematics.ml that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	PCA.getComponents()

Uses of Matrix in org.episteme.core.mathematics.sets

Classes in org.episteme.core.mathematics.sets that implement interfaces with type arguments of type Matrix

Modifier and Type	Class	Description
final class	SquareMatrices<E>	The structure of n×n square matrices over a field, forming a ring.

Methods in org.episteme.core.mathematics.sets that return Matrix

Modifier and Type	Method	Description
Matrix<E>	SquareMatrices.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	SquareMatrices.inverse(Matrix<E> element)
Matrix<E>	SquareMatrices.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	SquareMatrices.negate(Matrix<E> element)
Matrix<E>	SquareMatrices.one()
Matrix<E>	SquareMatrices.operate(Matrix<E> a, Matrix<E> b)
Matrix<E>	SquareMatrices.zero()

Methods in org.episteme.core.mathematics.sets with parameters of type Matrix

Modifier and Type	Method	Description
Matrix<E>	SquareMatrices.add(Matrix<E> a, Matrix<E> b)
boolean	SquareMatrices.contains(Matrix<E> element)
Matrix<E>	SquareMatrices.inverse(Matrix<E> element)
Matrix<E>	SquareMatrices.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	SquareMatrices.negate(Matrix<E> element)
Matrix<E>	SquareMatrices.operate(Matrix<E> a, Matrix<E> b)

Uses of Matrix in org.episteme.core.mathematics.util

Methods in org.episteme.core.mathematics.util that return Matrix

Modifier and Type	Method	Description
static Matrix<Real>	ArrayConverters.toMatrix(double[][] arr)	Converts a 2D primitive double array to Matrix.

Methods in org.episteme.core.mathematics.util with parameters of type Matrix

Modifier and Type	Method	Description
static double[][]	ArrayConverters.toDoubleMatrix(Matrix<Real> m)	Converts a Matrix to 2D primitive double array.

Uses of Matrix in org.episteme.nativ.mathematics.linearalgebra.backends

Methods in org.episteme.nativ.mathematics.linearalgebra.backends that return Matrix

Modifier and Type	Method	Description
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.acos(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.acos(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.acos(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.acos(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.acos(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.acosh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.acosh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.acosh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.acosh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.acosh(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeFFMBLASBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<Real>	NativeND4JLinearAlgebraBackend.add(Matrix<Real> a, Matrix<Real> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.applyTranscendental(Matrix<E> a, String op, Object... args)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.applyTranscendental(Matrix<E> a, String op, Object... args)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.asin(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.asin(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.asin(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.asin(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.asin(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.asinh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.asinh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.asinh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.asinh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.asinh(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.atan(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.atan(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.atan(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.atan(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.atan(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.atanh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.atanh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.atanh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.atanh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.atanh(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.cbrt(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.cbrt(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.cbrt(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.cbrt(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.cbrt(Matrix<E> a)
Matrix<E>	AbstractNativeFFMBLASBackend.conjugateTranspose(Matrix<E> m)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLSparseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLSparseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.cos(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.cos(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.cos(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.cos(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.cos(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.cosh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.cosh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.cosh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.cosh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.cosh(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.exp(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.exp(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.exp(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.exp(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.exp(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraDoubleBackend.fromDense(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraFloatBackend.fromDense(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	AbstractNativeFFMBLASBackend.inverse(Matrix<E> A)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.inverse(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.inverse(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<Real>	NativeND4JLinearAlgebraBackend.inverse(Matrix<Real> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.inverse(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.inverse(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.log(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.log(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.log(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.log(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.log(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.log10(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.log10(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.log10(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.log10(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.log10(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeFFMBLASBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<Real>	NativeND4JLinearAlgebraBackend.multiply(Matrix<Real> a, Matrix<Real> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.pow(Matrix<E> m, E exponent)
Matrix<E>	AbstractNativeFFMBLASBackend.pow(Matrix<E> m, E exponent)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.pow(Matrix<E> a, E exponent)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.pow(Matrix<E> m, E exponent)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	AbstractNativeFFMBLASBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<Real>	NativeND4JLinearAlgebraBackend.scale(Real scalar, Matrix<Real> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.sin(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.sin(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.sin(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.sin(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.sin(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.sinh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.sinh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.sinh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.sinh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.sinh(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.solve(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.solve(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.sqrt(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.sqrt(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.sqrt(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.sqrt(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.sqrt(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeFFMBLASBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<Real>	NativeND4JLinearAlgebraBackend.subtract(Matrix<Real> a, Matrix<Real> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.tan(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.tan(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.tan(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.tan(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.tan(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.tanh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.tanh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.tanh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.tanh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.tanh(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraDoubleBackend.toDense(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraFloatBackend.toDense(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	AbstractNativeFFMBLASBackend.transpose(Matrix<E> a)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.transpose(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.transpose(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<Real>	NativeND4JLinearAlgebraBackend.transpose(Matrix<Real> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.transpose(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.transpose(Matrix<E> a)

Methods in org.episteme.nativ.mathematics.linearalgebra.backends with parameters of type Matrix

Modifier and Type	Method	Description
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.acos(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.acos(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.acos(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.acos(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.acos(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.acosh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.acosh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.acosh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.acosh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.acosh(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeFFMBLASBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<Real>	NativeND4JLinearAlgebraBackend.add(Matrix<Real> a, Matrix<Real> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.add(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.applyTranscendental(Matrix<E> a, String op, Object... args)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.applyTranscendental(Matrix<E> a, String op, Object... args)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.asin(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.asin(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.asin(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.asin(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.asin(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.asinh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.asinh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.asinh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.asinh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.asinh(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.atan(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.atan(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.atan(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.atan(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.atan(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.atanh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.atanh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.atanh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.atanh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.atanh(Matrix<E> a)
Vector<E>	NativeCUDASparseLinearAlgebraDoubleBackend.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeCUDASparseLinearAlgebraFloatBackend.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeMPFRSparseLinearAlgebraBackend.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeOpenCLSparseLinearAlgebraDoubleBackend.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeOpenCLSparseLinearAlgebraFloatBackend.bicgstab(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.cbrt(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.cbrt(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.cbrt(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.cbrt(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.cbrt(Matrix<E> a)
CholeskyResult<E>	AbstractNativeCPULinearAlgebraBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	AbstractNativeFFMBLASBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	AbstractNativeSIMDLinearAlgebraBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	NativeCUDADenseLinearAlgebraDoubleBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	NativeCUDADenseLinearAlgebraFloatBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	NativeMPFRDenseLinearAlgebraBackend.cholesky(Matrix<E> a)
CholeskyResult<Real>	NativeND4JLinearAlgebraBackend.cholesky(Matrix<Real> a)
CholeskyResult<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.cholesky(Matrix<E> a)
CholeskyResult<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.cholesky(Matrix<E> a)
E	AbstractNativeFFMBLASBackend.conditionNumber(Matrix<E> a)
Vector<E>	NativeCUDASparseLinearAlgebraDoubleBackend.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeCUDASparseLinearAlgebraFloatBackend.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeMPFRSparseLinearAlgebraBackend.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeOpenCLSparseLinearAlgebraDoubleBackend.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Vector<E>	NativeOpenCLSparseLinearAlgebraFloatBackend.conjugateGradient(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations)
Matrix<E>	AbstractNativeFFMBLASBackend.conjugateTranspose(Matrix<E> m)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLSparseLinearAlgebraDoubleBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	NativeOpenCLSparseLinearAlgebraFloatBackend.conjugateTranspose(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.cos(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.cos(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.cos(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.cos(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.cos(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.cosh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.cosh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.cosh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.cosh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.cosh(Matrix<E> a)
E	AbstractNativeCPULinearAlgebraBackend.determinant(Matrix<E> a)
E	AbstractNativeFFMBLASBackend.determinant(Matrix<E> A)
E	AbstractNativeSIMDLinearAlgebraBackend.determinant(Matrix<E> a)
E	NativeCUDADenseLinearAlgebraDoubleBackend.determinant(Matrix<E> a)
E	NativeCUDADenseLinearAlgebraFloatBackend.determinant(Matrix<E> a)
E	NativeMPFRDenseLinearAlgebraBackend.determinant(Matrix<E> a)
E	NativeMPFRSparseLinearAlgebraBackend.determinant(Matrix<E> a)
Real	NativeND4JLinearAlgebraBackend.determinant(Matrix<Real> a)	Determinant via Gaussian elimination on ND4J arrays.
E	NativeOpenCLDenseLinearAlgebraDoubleBackend.determinant(Matrix<E> a)
E	NativeOpenCLDenseLinearAlgebraFloatBackend.determinant(Matrix<E> a)
EigenResult<E>	AbstractNativeCPULinearAlgebraBackend.eigen(Matrix<E> a)
EigenResult<E>	AbstractNativeFFMBLASBackend.eigen(Matrix<E> a)
EigenResult<E>	AbstractNativeSIMDLinearAlgebraBackend.eigen(Matrix<E> a)
EigenResult<E>	NativeCUDADenseLinearAlgebraDoubleBackend.eigen(Matrix<E> a)
EigenResult<E>	NativeCUDADenseLinearAlgebraFloatBackend.eigen(Matrix<E> a)
EigenResult<E>	NativeMPFRDenseLinearAlgebraBackend.eigen(Matrix<E> a)
EigenResult<Real>	NativeND4JLinearAlgebraBackend.eigen(Matrix<Real> a)
EigenResult<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.eigen(Matrix<E> a)
EigenResult<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.eigen(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.exp(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.exp(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.exp(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.exp(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.exp(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraDoubleBackend.fromDense(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraFloatBackend.fromDense(Matrix<E> a)
Vector<E>	NativeMPFRSparseLinearAlgebraBackend.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts)
Vector<E>	NativeOpenCLSparseLinearAlgebraDoubleBackend.gmres(Matrix<E> a, Vector<E> b, Vector<E> x0, E tolerance, int maxIterations, int restarts)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	AbstractNativeFFMBLASBackend.inverse(Matrix<E> A)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.inverse(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.inverse(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.inverse(Matrix<E> a)
Matrix<Real>	NativeND4JLinearAlgebraBackend.inverse(Matrix<Real> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.inverse(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.inverse(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.log(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.log(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.log(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.log(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.log(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.log10(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.log10(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.log10(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.log10(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.log10(Matrix<E> a)
LUResult<E>	AbstractNativeCPULinearAlgebraBackend.lu(Matrix<E> a)
LUResult<E>	AbstractNativeFFMBLASBackend.lu(Matrix<E> a)
LUResult<E>	AbstractNativeSIMDLinearAlgebraBackend.lu(Matrix<E> a)
LUResult<E>	NativeCUDADenseLinearAlgebraDoubleBackend.lu(Matrix<E> a)
LUResult<E>	NativeCUDADenseLinearAlgebraFloatBackend.lu(Matrix<E> a)
LUResult<E>	NativeMPFRDenseLinearAlgebraBackend.lu(Matrix<E> a)
LUResult<Real>	NativeND4JLinearAlgebraBackend.lu(Matrix<Real> a)	LU decomposition via Gaussian elimination on ND4J arrays.
LUResult<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.lu(Matrix<E> a)
LUResult<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.lu(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	AbstractNativeCPULinearAlgebraBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	AbstractNativeFFMBLASBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	AbstractNativeFFMBLASBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	AbstractNativeSIMDLinearAlgebraBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeCUDADenseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeCUDADenseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Vector<E> b)
Vector<E>	NativeCUDASparseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Vector<E> x)
Vector<E>	NativeCUDASparseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Vector<E> x)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeMPFRDenseLinearAlgebraBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeMPFRSparseLinearAlgebraBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<Real>	NativeND4JLinearAlgebraBackend.multiply(Matrix<Real> a, Matrix<Real> b)
Vector<Real>	NativeND4JLinearAlgebraBackend.multiply(Matrix<Real> a, Vector<Real> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Vector<E> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Vector<E> b)
Vector<E>	NativeOpenCLSparseLinearAlgebraDoubleBackend.multiply(Matrix<E> a, Vector<E> x)
Vector<E>	NativeOpenCLSparseLinearAlgebraFloatBackend.multiply(Matrix<E> a, Vector<E> x)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.pow(Matrix<E> m, E exponent)
Matrix<E>	AbstractNativeFFMBLASBackend.pow(Matrix<E> m, E exponent)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.pow(Matrix<E> a, E exponent)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.pow(Matrix<E> m, E exponent)
QRResult<E>	AbstractNativeCPULinearAlgebraBackend.qr(Matrix<E> a)
QRResult<E>	AbstractNativeFFMBLASBackend.qr(Matrix<E> a)
QRResult<E>	AbstractNativeSIMDLinearAlgebraBackend.qr(Matrix<E> a)
QRResult<E>	NativeCUDADenseLinearAlgebraDoubleBackend.qr(Matrix<E> a)
QRResult<E>	NativeCUDADenseLinearAlgebraFloatBackend.qr(Matrix<E> a)
QRResult<E>	NativeMPFRDenseLinearAlgebraBackend.qr(Matrix<E> a)
QRResult<Real>	NativeND4JLinearAlgebraBackend.qr(Matrix<Real> a)	QR decomposition via ND4J's 'qr' custom op.
QRResult<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.qr(Matrix<E> a)
QRResult<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.qr(Matrix<E> a)
int	AbstractNativeFFMBLASBackend.rank(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	AbstractNativeFFMBLASBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.scale(E scalar, Matrix<E> a)
Matrix<Real>	NativeND4JLinearAlgebraBackend.scale(Real scalar, Matrix<Real> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.scale(E scalar, Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.sin(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.sin(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.sin(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.sin(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.sin(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.sinh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.sinh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.sinh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.sinh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.sinh(Matrix<E> a)
Vector<E>	AbstractNativeCPULinearAlgebraBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	AbstractNativeFFMBLASBackend.solve(Matrix<E> A, Vector<E> b)
Vector<E>	AbstractNativeSIMDLinearAlgebraBackend.solve(Matrix<E> a, Vector<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.solve(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeCUDADenseLinearAlgebraDoubleBackend.solve(Matrix<E> a, Vector<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.solve(Matrix<E> a, Matrix<E> b)
Vector<E>	NativeCUDADenseLinearAlgebraFloatBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	NativeCUDASparseLinearAlgebraDoubleBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	NativeCUDASparseLinearAlgebraFloatBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	NativeMPFRDenseLinearAlgebraBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	NativeMPFRSparseLinearAlgebraBackend.solve(Matrix<E> a, Vector<E> b)
Vector<Real>	NativeND4JLinearAlgebraBackend.solve(Matrix<Real> a, Vector<Real> b)	Solve Ax=b via ND4J's LU decomposition.
Vector<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	NativeOpenCLSparseLinearAlgebraDoubleBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	NativeOpenCLSparseLinearAlgebraFloatBackend.solve(Matrix<E> a, Vector<E> b)
Vector<E>	AbstractNativeCPULinearAlgebraBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	AbstractNativeFFMBLASBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	AbstractNativeSIMDLinearAlgebraBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	NativeCUDADenseLinearAlgebraDoubleBackend.solveTriangular(Matrix<E> a, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	NativeCUDADenseLinearAlgebraFloatBackend.solveTriangular(Matrix<E> a, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	NativeMPFRDenseLinearAlgebraBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	NativeMPFRSparseLinearAlgebraBackend.solveTriangular(Matrix<E> A, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<Real>	NativeND4JLinearAlgebraBackend.solveTriangular(Matrix<Real> A, Vector<Real> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.solveTriangular(Matrix<E> a, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Vector<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.solveTriangular(Matrix<E> a, Vector<E> b, boolean upper, boolean transpose, boolean conjugate, boolean unit)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.sqrt(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.sqrt(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.sqrt(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.sqrt(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.sqrt(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeFFMBLASBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<Real>	NativeND4JLinearAlgebraBackend.subtract(Matrix<Real> a, Matrix<Real> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.subtract(Matrix<E> a, Matrix<E> b)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.subtract(Matrix<E> a, Matrix<E> b)
SVDResult<E>	AbstractNativeCPULinearAlgebraBackend.svd(Matrix<E> a)
SVDResult<E>	AbstractNativeFFMBLASBackend.svd(Matrix<E> a)
SVDResult<E>	AbstractNativeSIMDLinearAlgebraBackend.svd(Matrix<E> a)
SVDResult<E>	NativeCUDADenseLinearAlgebraDoubleBackend.svd(Matrix<E> a)
SVDResult<E>	NativeCUDADenseLinearAlgebraFloatBackend.svd(Matrix<E> a)
SVDResult<E>	NativeMPFRDenseLinearAlgebraBackend.svd(Matrix<E> a)
SVDResult<Real>	NativeND4JLinearAlgebraBackend.svd(Matrix<Real> a)	SVD using ND4J's built-in Svd custom op.
SVDResult<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.svd(Matrix<E> a)
SVDResult<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.svd(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.tan(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.tan(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.tan(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.tan(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.tan(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.tanh(Matrix<E> m)
Matrix<E>	AbstractNativeFFMBLASBackend.tanh(Matrix<E> m)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.tanh(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.tanh(Matrix<E> m)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.tanh(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraDoubleBackend.toDense(Matrix<E> a)
Matrix<E>	NativeCUDASparseLinearAlgebraFloatBackend.toDense(Matrix<E> a)
E	AbstractNativeCPULinearAlgebraBackend.trace(Matrix<E> a)
E	AbstractNativeFFMBLASBackend.trace(Matrix<E> a)
E	AbstractNativeSIMDLinearAlgebraBackend.trace(Matrix<E> a)
E	NativeCUDADenseLinearAlgebraDoubleBackend.trace(Matrix<E> a)
E	NativeCUDADenseLinearAlgebraFloatBackend.trace(Matrix<E> a)
E	NativeCUDASparseLinearAlgebraDoubleBackend.trace(Matrix<E> a)
E	NativeCUDASparseLinearAlgebraFloatBackend.trace(Matrix<E> a)
E	NativeMPFRDenseLinearAlgebraBackend.trace(Matrix<E> a)
E	NativeMPFRSparseLinearAlgebraBackend.trace(Matrix<E> a)
Real	NativeND4JLinearAlgebraBackend.trace(Matrix<Real> a)
E	NativeOpenCLDenseLinearAlgebraDoubleBackend.trace(Matrix<E> a)
E	NativeOpenCLDenseLinearAlgebraFloatBackend.trace(Matrix<E> a)
E	NativeOpenCLSparseLinearAlgebraDoubleBackend.trace(Matrix<E> a)
E	NativeOpenCLSparseLinearAlgebraFloatBackend.trace(Matrix<E> a)
Matrix<E>	AbstractNativeCPULinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	AbstractNativeFFMBLASBackend.transpose(Matrix<E> a)
Matrix<E>	AbstractNativeSIMDLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraDoubleBackend.transpose(Matrix<E> a)
Matrix<E>	NativeCUDADenseLinearAlgebraFloatBackend.transpose(Matrix<E> a)
Matrix<E>	NativeMPFRDenseLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<E>	NativeMPFRSparseLinearAlgebraBackend.transpose(Matrix<E> a)
Matrix<Real>	NativeND4JLinearAlgebraBackend.transpose(Matrix<Real> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraDoubleBackend.transpose(Matrix<E> a)
Matrix<E>	NativeOpenCLDenseLinearAlgebraFloatBackend.transpose(Matrix<E> a)

Uses of Matrix in org.episteme.nativ.mathematics.linearalgebra.matrices

Classes in org.episteme.nativ.mathematics.linearalgebra.matrices that implement Matrix

Modifier and Type	Class	Description
class	NativeRealDoubleMatrix	High-performance Real Double Matrix backed by a persistent native MemorySegment.
class	NativeRealFloatMatrix	High-performance Real Float Matrix backed by a persistent native MemorySegment.

Methods in org.episteme.nativ.mathematics.linearalgebra.matrices that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	NativeRealFloatMatrix.copy()

Methods in org.episteme.nativ.mathematics.linearalgebra.matrices with parameters of type Matrix

Modifier and Type	Method	Description
static NativeRealDoubleMatrix	NativeRealDoubleMatrix.copyOf(Matrix<Real> other, Arena arena, LinearAlgebraProvider<Real> provider)
static NativeRealFloatMatrix	NativeRealFloatMatrix.copyOf(Matrix<Real> other, Arena arena)

Uses of Matrix in org.episteme.nativ.mathematics.linearalgebra.matrices.storage

Methods in org.episteme.nativ.mathematics.linearalgebra.matrices.storage that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	NativeHDF5MatrixStorage.loadBlock(int startRow, int startCol, int rowCount, int colCount)	Loads a rectangular block from the HDF5 file.

Uses of Matrix in org.episteme.natural.biology.ecology

Methods in org.episteme.natural.biology.ecology with parameters of type Matrix

Modifier and Type	Method	Description
static boolean	EcoStability.isStable(Matrix<Real> jacobian)	Calculates the stability of an equilibrium point using the eigenvalue of the community matrix.

Uses of Matrix in org.episteme.natural.chemistry.computational.quantum

Fields in org.episteme.natural.chemistry.computational.quantum declared as Matrix

Modifier and Type	Field	Description
protected Matrix<Real>	SCFMethod.densityMatrix
protected Matrix<Real>	SCFMethod.fockMatrix
protected Matrix<Real>	SCFMethod.overlapMatrix

Methods in org.episteme.natural.chemistry.computational.quantum that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	DIISSubspace.extrapolate()	Extrapolates a new Fock matrix using the DIIS equations.
Matrix<Real>	OneElectronIntegrals.getCoreHamiltonian()
Matrix<Real>	SCFMethod.getDensityMatrix()
Matrix<Real>	SCFMethod.getFockMatrix()
Matrix<Real>	OneElectronIntegrals.getOverlap()

Methods in org.episteme.natural.chemistry.computational.quantum with parameters of type Matrix

Modifier and Type	Method	Description
void	DIISSubspace.add(Matrix<Real> F, Matrix<Real> error)	Adds an iteration to the subspace.

Constructors in org.episteme.natural.chemistry.computational.quantum with parameters of type Matrix

Modifier	Constructor	Description
	OneElectronIntegrals(Matrix<Real> coreHamiltonian, Matrix<Real> overlap)

Uses of Matrix in org.episteme.natural.engineering.robotics

Methods in org.episteme.natural.engineering.robotics that return Matrix

Modifier and Type	Method	Description
static Matrix<Real>	Kinematics.dhMatrix(Quantity<Angle> theta, Quantity<Length> d, Quantity<Length> a, Quantity<Angle> alpha)	Denavit-Hartenberg transformation matrix.
static Matrix<Real>	Kinematics.jacobian2Link(Quantity<Length> L1, Quantity<Length> L2, Quantity<Angle> theta1, Quantity<Angle> theta2)	Jacobian for 2-link planar arm (velocity kinematics).

Methods in org.episteme.natural.engineering.robotics with parameters of type Matrix

Modifier and Type	Method	Description
static Vector<Real>	Kinematics.getPosition(Matrix<Real> T)	Extracts position vector from a 4x4 transformation matrix.

Uses of Matrix in org.episteme.natural.physics.classical.mechanics

Methods in org.episteme.natural.physics.classical.mechanics that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	ProjectileMotion.getTrajectory(int numPoints)	Generates trajectory points as a Matrix.

Uses of Matrix in org.episteme.natural.physics.classical.mechanics.collision

Methods in org.episteme.natural.physics.classical.mechanics.collision that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	RigidBody.getInertiaTensor()
Matrix<Real>	RigidBody.getInverseInertiaTensor()

Constructors in org.episteme.natural.physics.classical.mechanics.collision with parameters of type Matrix

Modifier	Constructor	Description
	RigidBody(Vector<Real> position, Real mass, Matrix<Real> inertiaTensor, CollisionShape shape)

Uses of Matrix in org.episteme.natural.physics.quantum.backends

Methods in org.episteme.natural.physics.quantum.backends that return Matrix

Modifier and Type	Method	Description
Matrix<Complex>	AmazonBraketBackend.stateTomography(QuantumBackend.QuantumCircuit c, int s)
Matrix<Complex>	PythonQuantumBackend.stateTomography(QuantumBackend.QuantumCircuit c, int s)
Matrix<Complex>	QiskitBackend.stateTomography(QuantumBackend.QuantumCircuit c, int s)
Matrix<Complex>	Quantum4JBackend.stateTomography(QuantumBackend.QuantumCircuit c, int s)
Matrix<Complex>	StrangeBackend.stateTomography(QuantumBackend.QuantumCircuit c, int s)

Methods in org.episteme.natural.physics.quantum.backends with parameters of type Matrix

Modifier and Type	Method	Description
QuantumBackend.QuantumCircuit	AmazonBraketBackend.matrixToUnitary(Matrix<Complex> m)
QuantumBackend.QuantumCircuit	PythonQuantumBackend.matrixToUnitary(Matrix<Complex> m)
QuantumBackend.QuantumCircuit	QiskitBackend.matrixToUnitary(Matrix<Complex> m)
QuantumBackend.QuantumCircuit	Quantum4JBackend.matrixToUnitary(Matrix<Complex> m)
QuantumBackend.QuantumCircuit	StrangeBackend.matrixToUnitary(Matrix<Complex> m)
QuantumBackend.QuantumResult	AmazonBraketBackend.qaoa(Matrix<Complex> h, int l)
QuantumBackend.QuantumResult	PythonQuantumBackend.qaoa(Matrix<Complex> h, int l)
QuantumBackend.QuantumResult	QiskitBackend.qaoa(Matrix<Complex> h, int l)
QuantumBackend.QuantumResult	Quantum4JBackend.qaoa(Matrix<Complex> h, int l)
QuantumBackend.QuantumResult	StrangeBackend.qaoa(Matrix<Complex> h, int l)
double	AmazonBraketBackend.quantumPhaseEstimation(Matrix<Complex> u, Vector<Complex> e, int p)
double	PythonQuantumBackend.quantumPhaseEstimation(Matrix<Complex> u, Vector<Complex> e, int p)
double	QiskitBackend.quantumPhaseEstimation(Matrix<Complex> u, Vector<Complex> e, int p)
double	Quantum4JBackend.quantumPhaseEstimation(Matrix<Complex> u, Vector<Complex> e, int p)
double	StrangeBackend.quantumPhaseEstimation(Matrix<Complex> u, Vector<Complex> e, int p)
double	AmazonBraketBackend.vqe(Matrix<Complex> h, QuantumBackend.QuantumCircuit a, String o)
double	PythonQuantumBackend.vqe(Matrix<Complex> hamiltonian, QuantumBackend.QuantumCircuit ansatz, String optimizer)
double	QiskitBackend.vqe(Matrix<Complex> h, QuantumBackend.QuantumCircuit a, String o)
double	Quantum4JBackend.vqe(Matrix<Complex> h, QuantumBackend.QuantumCircuit a, String o)
double	StrangeBackend.vqe(Matrix<Complex> h, QuantumBackend.QuantumCircuit a, String o)

Uses of Matrix in org.episteme.natural.technical.backend.quantum

Methods in org.episteme.natural.technical.backend.quantum that return Matrix

Modifier and Type	Method	Description
Matrix<Complex>	QuantumAlgorithmProvider.stateTomography(QuantumBackend.QuantumCircuit circuit, int shots)	Performs quantum state tomography to reconstruct a density matrix.

Methods in org.episteme.natural.technical.backend.quantum with parameters of type Matrix

Modifier and Type	Method	Description
QuantumBackend.QuantumCircuit	QuantumAlgorithmProvider.matrixToUnitary(Matrix<Complex> matrix)	Converts a classical matrix to a quantum unitary operator.
QuantumBackend.QuantumResult	QuantumAlgorithmProvider.qaoa(Matrix<Complex> costHamiltonian, int layers)	Performs Quantum Approximate Optimization Algorithm (QAOA).
double	QuantumAlgorithmProvider.quantumPhaseEstimation(Matrix<Complex> unitary, Vector<Complex> eigenstate, int precision)	Performs Quantum Phase Estimation (QPE).
double	QuantumAlgorithmProvider.vqe(Matrix<Complex> hamiltonian, QuantumBackend.QuantumCircuit ansatz, String optimizer)	Performs Variational Quantum Eigensolver (VQE) to find ground state energy.

Uses of Matrix in org.episteme.social.economics.models

Methods in org.episteme.social.economics.models with parameters of type Matrix

Modifier and Type	Method	Description
static int[]	NashEquilibriumSolver.findPureStrategyNE(Matrix<Real> payoffMatrixA, Matrix<Real> payoffMatrixB)	Finds a pure strategy Nash Equilibrium in a 2-player normal-form game.

Uses of Matrix in org.episteme.social.geography

Methods in org.episteme.social.geography that return Matrix

Modifier and Type	Method	Description
Matrix<Real>	HeightMap.getElevations()

Methods in org.episteme.social.geography with parameters of type Matrix

Modifier and Type	Method	Description
void	HeightMap.setElevations(Matrix<Real> elevations)