All Classes and Interfaces
Class
Description
A real sparse matrix stored in coordinate list (COO) format.
Base class for all sparse tensors stored in coordinate list (COO) format.
A sparse vector stored in coordinate list (COO) format.
The base class for all dense
Field tensors.The base class for all dense
Ring tensors.The base class for all dense matrices whose elements are members of a
Semiring.The base class for all dense
Semiring tensors.The base class for all dense vectors whose entries are
Semiring elements.The base class of all tensors.
This class contains several low-level methods useful for computing aggregation operations on dense tensors.
This utility class contains several low-level methods useful for computing aggregation operations on dense/sparse tensors.
This utility class contains methods useful for aggregating arrays of
Semiring's.This class provides several utility methods useful for array manipulation and copying.
Base class for solvers which solve a linear system of equations U*x=b or U*X=B where U is an upper
triangular matrix.
A semi-ring element backed by a boolean.
This abstract class specifies methods for computing the Cholesky decomposition of a positive-definite matrix.
A complex dense matrix backed by a
Complex128 array.This utility class provides methods useful for comparing elements of a
Ring.This utility class provides methods useful for comparing elements of a
Semiring.A complex number stored in rectangular form and backed by two 64-bit floating point numbers (one for the real and one for the
imaginary component).
This class provides low level methods for computing operations on complex tensors.
This class contains low-level implementations for operations which check if a complex tensor satisfies some property.
A complex number stored in rectangular form and backed by two 32-bit floating point number (one for the real and one for the
imaginary component).
This class provides low level methods for computing operations on complex tensors.
This class contains low-level implementations for operations which check if a complex tensor satisfies some property.
This solver solves linear systems of equations where the coefficient matrix in an upper triangular complex dense matrix
and the constant vector is a complex dense vector.
An instance of this class allows for the computation of a Cholesky decomposition of a complex Hermitian
positive-definite matrix.
This class contains methods for computing the determinant of a complex dense matrix.
This class contains low-level implementations of setting operations for complex dense tensors.
Solver for solving a well determined system of linear equations in an exact sense using the
LU decomposition.Solver for solving a complex well determined linear tensor equation A*X=B in an exact sense.
This solver solves linear systems of equations where the coefficient matrix in a lower triangular complex dense matrix
and the constant vector/matrix is complex and dense.
Computes the Hessenburg decomposition of a complex dense square matrix.
This class solves a linear system of equations Ax=b in a least-squares sense.
Complex128his class provides methods for computing the LU decomposition of a complex dense matrix.
A lexer for producing the tokens of a complex number represented as a string.
A parser for parsing complex numbers represented as a string.
An exception which is thrown when a string representation of a complex number cannot be parsed.
A ComplexNumberToken is the smallest unit of a string which is being parsed to a complex number.
This interface defines operations that complex-valued matrices should implement.
Instances of this class compute the
QR decomposition of a complex dense matrix.This class computes the Schur decomposition of a complex dense square matrix.
This class contains methods for getting/setting elements and slices from/to a complex sparse matrix.
Instances of this class can be used to compute the singular value decomposition (SVD) of a
complex dense matrix.This class is the base class for complex matrix decompositions which proceed by using unitary transformations
(specifically Householder reflectors) to bring a matrix into an upper triangular/Hessenburg matrix.
Utility class for computing the condition number of a matrix.
Configurations for standard and concurrent operations.
A complex sparse matrix stored in coordinate list (COO) format.
This utility class contains methods for combining or joining sparse COO tensors, matrices, and vectors.
Sparse complex tensor stored in coordinate list (COO) format.
Sparse complex tensor stored in coordinate list (COO) format.
A complex sparse vector stored in coordinate list (COO) format.
A class which can be used to sort the indices, along with data values, in lexicographical order.
Utility class for searching for specific elements within a sparse COO matrix.
This utility class contains methods for checking the equality, or approximately equal, of sparse tensors whose entries are
field elements.This class contains low level methods for computing the matrix multiplication of sparse
Field matrices/vectors.A sparse matrix stored in coordinate list (COO) format.
A real sparse matrix stored in coordinate list (COO) format.
This class contains methods for getting/setting elements and slices from/to a sparse
Field matrix.This class contains implementations for sparse
Field matrix manipulations.This class has low level implementations for operations between two sparse coo
Field matrices.This class contains low level implementations for methods to evaluate certain properties of a sparse coo field matrix.
This utility class contains low level implementations of norms for sparse field coo tensors, matrices and vectors.
Sparse tensor stored in coordinate list (COO) format.
Base class for all sparse tensors stored in coordinate list (COO) format.
Utility class for computing tensor dot products between two COO field tensors.
Utility class for computing operations between two sparse COO tensors whose elements are members of a
Field.A sparse vector stored in coordinate list (COO) format.
A sparse vector stored in coordinate list (COO) format.
This utility class contains methods for computing operations between two sparse coo
Field vectors.A utility class that aids in getting or setting specified elements of a sparse COO tensor, matrix, or vector.
Utility class containing methods for manipulating a sparse COO tensor, matrix, or vector.
A real sparse matrix stored in coordinate list (COO) format.
This interface specifies methods which all sparse COO matrices should implement.
This utility class contains methods useful for computing the matrix multiplication between two sparse COO
Semiring tensors.Utility class for computing various operations on and between sparse COO
Semiring matrices.This class contains low level implementations for methods to evaluate certain properties of a sparse COO
Semiring matrix.This utility class contains methods for computing operations on two
Semiring
tensors.Utility class for computing operations between sparse COO
Semiring vectors.A real sparse tensor stored in coordinate list (COO) format.
Utility class for computing the transpose of a sparse COO tensor or matrix.
A real sparse vector stored in coordinate list (COO) format.
A complex sparse matrix stored in compressed sparse row (CSR) format.
This class contains methods to check equality or approximate equality between two sparse CSR field matrices.
This class contains low-level implementations of sparse-sparse
Field
matrix multiplication where the sparse matrices are in CSR format.A sparse matrix stored in compressed sparse row (CSR) format.
A real sparse matrix stored in compressed sparse row (CSR) format.
This utility class contains methods for manipulating CSR
Field matrices.This class contains low-level implementations for element-wise operations on CSR
Field matrices.This utility class contains methods usefully for determining properties of a sparse CSR
Field matrix.This utility class provides implementations for tensor dot products on two sparse CSR
Field matrices.A real sparse matrix stored in compressed sparse row (CSR) format.
This interface specifies methods which all sparse CSR matrices should implement.
A real sparse matrix stored in compressed sparse row (CSR) format.
A dense complex tensor backed by an array of
Complex128's.A dense complex tensor backed by an array of
Complex128's.A complex dense vector whose entries are
Complex128's.This interface specifies methods which should be implemented in all decompositions.
A factory class for creating decomposers to perform various matrix decompositions.
This utility class provides implementations for the concatenation of dense tensors.
This class provides methods for checking the equality of a dense field tensor with a sparse field tensor.
This utility class provides low level methods for computing the matrix multiplication between
a sparse/dense matrix and dense/sparse matrix/vector.
This class contains several low level methods for computing matrix-matrix multiplications with a transpose for
a complex dense matrix and a complex sparse matrix.
This class contains low level implementations for operations between a dense and a sparse field matrix.
This class contains methods to apply common operations to a dense/sparse field matrix and to a sparse/dense field matrix.
This class provides low level methods for computing operations between dense/sparse and
sparse/dense field vectors.
This class contains low-level implementations of complex-complex sparse-sparse matrix multiplication where the sparse matrices
are in CSR format.
This class contains low-level operations which act on a dense and a sparse CSR field matrix.
This utility class contains methods for computing the determinant of a dense matrix whose entries are elements of a
Field.This class contains low-level implementations of element-wise tensor division between two field tensors.
This class contains low-level implementations of complex element-wise tensor multiplication.
This class provides methods for checking the equality of dense tensors whose elements are members of a
Field.Utility class for computing the Hermitian transpose of a dense
field tensor.Simple enum class containing all possible choices of real dense matrix multiply algorithms.
The base class for all dense
Field matrices.This class contains several low-level methods for computing matrix-matrix multiplications between two
Field matrices.This class contains several low level methods for computing matrix-matrix multiplications with a transpose for two
dense
Field matrices.This class provides low level methods for computing operations on dense field tensors.
This utility class contains methods useful for verifying properties of a
FieldTensor.This class contains low-level implementations of setting operations for dense field tensors.
The base class for all dense
Field tensors.This functional interface specifies a binary operation on two dense
Field tensors.This class contains methods for computing a tensor dot product, i.e.
Utility class for computing the transpose of a dense
field tensor.A dense vector whose entries are
field elements.This class provides low level implementations for vector operations with two dense
Field vectors.This interface defines operations that all dense matrices should implement.
Base class for all real dense tensors which are backed by a primitive double array.
Utility class for computing the hermitian transpose of a dense
Ring tensor or matrix.Utility class for computing operations between two dense
Ring tensors.This utility class contains methods for computing norms of dense
Ring
Vectors.This utility class contains methods for computing operations on dense
Ring
Vectors.Utility class useful for computing element-wise products between two
Semiring
tensors.This utility class provides methods for computing dense matrix multiplication between matrices whose entries are members of a
Semiring.Simple enum class containing all possible choices of real dense matrix multiply algorithms.
This utility class contains methods for computing the dense matrix multiplication between a matrix and the transpose of a matrix.
This class provides low level methods for computing operations on dense semi-ring tensors.
This functional interface specifies a binary operation on two dense
Semiring tensors.This class contains methods for computing a tensor dot product, i.e.
This utility class contains methods for computing operations on dense
Semiring
Vectors.This interface specifies methods which sparse tensors should implement.
This utility class provides methods for computing the transpose of a dense tensor.
This interface specified methods which all dense vectors should implement.
This class provides several methods useful for computing eigenvalues and eigenvectors.
Contains error messages for common errors which may occur.
Solves a well determined system of equations Ax=b in an exact sense by using a LU decomposition.
Solves a well determined system of equations A*X=B in an exact sense where A, X, and B are tensors.
This interface specifies a mathematical field.
This class provides methods for computing the LU decomposition of a dense matrix whose elements are members
of a
Field.A dense matrix whose entries are
Field elements.This utility class contains operations for tensors whose elements are members of a
Field.A dense tensor whose entries are
Field elements.The base class for all tensors whose entries are elements of a
Field.This interface provides default functionality for all tensors whose entries are elements of a
Field.A dense vector whose entries are
field elements.A simple utility class containing useful constants.
This solver solves linear systems of equations where the coefficient matrix in a lower triangular real dense matrix
and the constant vector is a real dense vector.
This class contains methods for computing real or complex Givens' rotation matrices.
Computes the Hessenburg decomposition of a complex dense Hermitian matrix.
This class contains methods for computing real or complex Householder reflectors (also known as elementary reflectors).
This class provides methods for computing the inverse of a matrix.
An exception which is thrown when a linear algebra related error occurs at runtime.
This interface specifies methods which all linear matrix system solvers should implement.
This interface specifies methods which all linear system solvers should implement.
This class solves a linear system of equations Ax=b in a least-squares sense.
This abstract class specifies methods for computing the LU decomposition of a matrix.
Simple enum containing pivoting options for pivoting in LU decomposition.
A real dense matrix backed by a primitive double array.
This interface specifies methods which all matrices should implement.
This interface defines operations that all matrices should implement.
Dispatches matrix multiplication to the appropriate algorithm based on the size of the matrices to be multiplied.
Simple enum class containing all possible choices of matrix multiply algorithms.
Utility class containing static methods for computing norms of matrices.
This interface specifies operations between a matrix and a vector that a matrix should implement.
Data record to store a pair of values (i.e., a 2-tuple).
A permutation matrix is a square matrix containing only zeros and ones such that each row and column have exactly a single
one.
This class contains several methods for determining the positive definiteness of a matrix.
Utility class for formatting arrays as human-readable strings.
Base class for all real tensors which are backed by a primitive double array.
Printing and formating options for tensors, matrices, and vectors.
This class contains static methods usefully for computing projection transformation matrices.
This class contains methods useful for generating arrays filled with random values or randomly shuffling an array.
An instance of this class is used to generate a stream of random complex numbers.
An instance of this class is used for generating streams of pseudorandom dense tensors, matrices, and vectors.
An instance of this class is used for generating streams of pseudorandom sparse tensors, matrices, and vectors.
This solver solves linear systems of equations where the coefficient matrix in an
upper triangular
real dense matrix and the constant vector is a real dense vector or matrix.An instance of this class allows for the computation of a Cholesky decomposition for a
real dense
matrix.Utility class for computing operations between a complex sparse COO tensor and a real coo tensor.
This class contains low-level operations which act on a real/complex dense and a complex/real
sparse
CSR matrix.This class provides low-level implementation of matrix multiplication between a real CSR matrix and a complex
CSR matrix.
This class contains low-level implementations for element-wise operations on real/complex CSR matrices.
This class contains methods for checking the equality of real dense/sparse and complex dense/sparse tensors.
This class contains low level implementations of operations between real/complex and dense/sparse matrices.
This class contains methods to apply common binary operations to a real/complex dense matrix and to a complex/real sparse matrix.
This class provides low level methods for computing operations between a real/complex dense/sparse vector and a
complex/real sparse/dense vector.
This class contains methods for checking the equality of real/complex sparse tensors.
This class contains low level methods for computing the multiplication between a real/complex matrix and a complex/real
matrix/vector.
This class has low level implementations for operations between a real sparse matrix and a complex sparse matrix.
This class contains low level implementations of operations on a real sparse tensor and a complex sparse tensor.
Utility class for computing tensor dot products between two
real sparse COO tensors.Utility class for computing operations between two real sparse COO tensors backed by a primitive double array.
This class contains low level implementations for operations on a real sparse COO vector.
This class contains low-level implementations of real sparse-dense matrix multiplication where the sparse matrix
is in
CSR format.This class contains low-level operations which act on a real dense and a real sparse
CSR matrix.This class contains methods to check equality or approximate equality between two sparse CSR matrices.
Utility class for manipulating
real sparse CSR matrices (e.g.This class provides low-level implementation of matrix multiplication between two real CSR matrices.
This utility class provides implementations for tensor dot products on two real sparse CSR matrices.
This class contains low-level implementations for operations on CSR matrices.
This class contains low-level implementations for evaluating properties of real sparse CSR matrices.
This class contains methods for computing the determinant of a real dense matrix.
This class contains low level implementations of element-wise division algorithms for real dense tensors.
This class contains low level implementations of element-wise multiplications algorithms for real dense tensors.
This class provides methods for checking the equality of real dense tensors.
This class contains several low level methods for computing matrix-matrix multiplications.
Singleton class which stores a map of all viable real dense matrix multiply algorithms and uses that map to dispatch
a real dense matrix multiply problem to the appropriate algorithm.
Simple enum class containing all possible choices of real dense matrix multiply algorithms.
This class contains several low level methods for computing matrix-matrix multiplications with a transpose for
two real dense matrices.
This class provides low level methods for computing operations on real dense tensors.
This class contains low-level implementations for operations which check if a tensor satisfies some property.
This class contains low-level implementations of setting operations for real dense tensors.
This class contains methods for checking the equality of a real dense and real sparse tensors.
This class contains low level methods for computing the matrix multiplication (and matrix vector multiplication) between
a real dense/sparse matrix and a real sparse/dense matrix or vector.
This class contains several low level methods for computing matrix-matrix multiplications with a transpose for
a real dense matrix and a real sparse matrix.
This class contains low-level operations between a real dense and real sparse matrix.
This class contains methods to apply common binary operations to a real dense matrix and to a real sparse matrix.
This class provides low level methods for computing operations between a real dense/sparse vector and a
real sparse/dense vector.
Functional interface for creating a lambda which implements an operation acting on two real dense tensors.
This class contains methods for computing a tensor dot product, i.e.
This class contains several low-level algorithms for computing the transpose of real dense tensors.
This class provides low level implementations for several vector operation.
Solver for solving a well determined system of linear equations in an exact sense using the
LU decomposition.Solver for solving a real well determined linear tensor equation A*X=B in an exact sense.
This class contains low level methods for computing the matrix multiplication (and matrix vector multiplication) between
a real dense/sparse matrix and a sparse/dense field matrix/vector.
This class contains several low level methods for computing matrix-matrix multiplications with a transpose for
a real/field and sparse/dense matrix.
This class contains low level implementations of operations between real/field and dense/sparse matrices.
This class contains methods to apply common binary operations to a real/field dense matrix and to a field/real sparse matrix.
This class provides low level methods for computing operations between a real/field dense/sparse vector and a
field/real sparse/dense vector.
This class contains low-level implementations of real-complex sparse-dense matrix multiplication where the sparse matrix
is in CSR format.
This class contains low-level operations which act on a real/complex dense and a complex/real
sparse CSR matrix.
This class contains low-level implementations of element-wise tensor division for a dense real and dense
field tensor.
This class contains low-level implementations of element-wise tensor multiplication for a
dense real and dense field tensor.
This class provides methods for checking the equality of one dense real and one dense field tensors.
This class contains several low level methods for computing dense matrix-matrix multiplications between one field matrix and one
real matrix.
This class contains several low level methods for computing matrix-matrix multiplications with a transpose for a
real dense matrix and a dense field matrix.
This class provides low level methods for computing operations with at least one real tensor
and at least one field tensor.
This class provides low level implementations for vector operations with one dense real vector and one dense field vector.
A real number backed by a 32-bit floating point number.
A real number backed by a 64-bit floating point number.
This solver solves linear systems of equations where the coefficient matrix in a lower triangular real dense matrix
and the constant vector is a real dense vector.
Computes the Hessenburg decomposition of a real dense square matrix.
A real number backed by a 16-bit integer number.
A real number backed by a 32-bit integer number.
This class solves a linear system of equations Ax=b in a least-squares sense.
This class provides methods for computing the LU decomposition of a real dense matrix.
This class provides low level methods for computing operations on real tensors.
This class provides low level methods for checking tensor properties.
Instances of this class compute the
QR decomposition of a real dense matrix.This class computes the Schur decomposition of a real dense square matrix.
This class contains methods for checking the equality of real sparse tensors.
This utility class provides methods for inserting/removing values in a real sparse vector.
This class provides methods for getting and setting elements and slices from/to a real sparse matrix.
This utility class contains implementations for real sparse COO matrix manipulations.
This class contains low level implementations of matrix multiplication for real sparse matrices.
This class has low level implementations for operations between two real sparse matrices.
This class contains low level implementations for methods to evaluate certain properties of a real sparse matrix.
This class contains low level implementations of norms for tensors, matrices and vector.
Instances of this class can be used to compute the singular value decomposition (SVD) of a
real dense matrix.This class is the base class for real matrix decompositions which proceed by using unitary/orthogonal transformations
(specifically HouseholderOld reflectors) to bring a matrix into an upper triangular/Hessenburg matrix.
This interface specifies a mathematical ring.
Utility class useful for computing operations on
Ring tensors.Utility class for checking properties of
Ring'sThis interface provides default functionality for all tensors whose entries are elements of a
Ring.This class contains static methods for computing row echelon, reduced row echelon, and extended reduced row echelon
forms of a matrix.
The base class for Schur decompositions.
This interface specifies a mathematical semi-ring.
This utility class contains operations for tensors whose elements are members of a
Field.This utility class provides methods useful for determining properties of semi-ring tensors.
This interface provides default functionality for all tensors whose entries are elements of a
Semiring.An object to store the shape of a tensor.
An exception which is thrown when some operation not defined for singular matrices is attempted to be
performed on a singular matrix.
This class provides methods for efficiently finding if a sparse vector, matrix, or tensor contains a non-zero
item at a specified index.
Data class for storing information for a sparse (CSR or COO) matrix.
This interface specifies methods which sparse tensors should implement.
Contains common utility functions for working with sparse matrices.
Data class for storing information for a sparse COO vector.
This interface specifies methods which all sparse vectors should implement.
A class which provides simple utility methods for
strings.This class contains several methods for computing the subspace of a matrix.
This abstract class specifies methods for computing the singular value decomposition (SVD) of a matrix.
Computes the Hessenburg decomposition of a real dense symmetric matrix.
A real symmetric tri-diagonal matrix.
A real dense tensor backed by a primitive double array.
This interface specifies Binary operations which all tensors should implement.
A
TensorInputStream obtains bytes from a system file using a FileInputStream containing a serialized
tensor, matrix, or vector.This utility class provides static methods for computing the 'inverse' of a tensor with respect to some
tensor dot product operation.
This interface specifies methods which all tensors should implement.
This utility class provides static methods useful for computing norms of a tensor.
Functional interface for general tensor operation.
A class for writing tensors to a file in various formats.
This interface specifies methods which any tensor whose entries are elements of a field should implement.
This abstract class defines a tensor whose elements satisfy the axioms of a field.
This interface specifies methods which any tensor whose entries are elements of a ring should implement.
This abstract class defines a tensor whose elements satisfy the axioms of a ring.
This interface specifies methods which any tensor whose entries are elements of a semi-ring should implement.
This abstract class defines a tensor whose elements satisfy the axioms of a semi-ring.
This tensor specified operations between tensors and primitive values.
The TensorReader class provides several static methods for reading serialized
tensors, matrices, and vectors from a file.
This interface defines scalar operations between a tensor and a scalar field element.
An exception to be thrown when there is an error related to tensor shapes.
The TensorWriter class provides several static methods for writing serialized
tensors, matrices, and vectors to a file.
This class contains the base thread pool for all concurrent operations and methods for managing the pool.
A utility class for computing transformations on
Semiring arrays.Provides a dispatch method for dynamically choosing the best matrix transpose algorithm.
Simple enum class containing available algorithms for computing a matrix transpose.
Data record to store an ordered list of values (i.e., a n-tuple).
This class is the base class for all decompositions which proceed by using unitary transformations
(specifically HouseholderOld reflectors) to bring a matrix into an upper triangular matrix (QR decomposition) or an upper Hessenburg
matrix (Hessenburg decomposition).
This utility class contains several methods for ensuring a parameter has certain properties.
A dense vector backed by a primitive double array.
This interface specifies operations between a vector and a matrix that a vector should implement.
This interface specifies methods which all vectors should implement.
This interface specifies operations that a vector should implement.
Utility class for computing norms of vectors.
Utility class containing static for generating view matrices.