Uses of Interface
org.flag4j.numbers.Field

Packages that use Field
Package
Description
org.flag4j.arrays
Provides implementations of "smart" array objects, the tensor shape object, and tuples.
org.flag4j.arrays.backend.field_arrays
 
org.flag4j.arrays.backend.smart_visitors
 
org.flag4j.arrays.dense
Provides implementations for dense tensors, matrices, and vectors.
org.flag4j.arrays.sparse
Contains implementations for sparse tensors, matrices, and vectors.
org.flag4j.linalg.decompositions.lu
Provides implementations of the LU decomposition for real, complex, and field matrices.
org.flag4j.linalg.ops.common.field_ops
Implementations of operations on two Field array objects.
org.flag4j.linalg.ops.dense_sparse.coo.field_ops
 
org.flag4j.linalg.ops.dense_sparse.coo.real_field_ops
 
org.flag4j.linalg.ops.dense_sparse.csr.field_ops
 
org.flag4j.linalg.ops.dense_sparse.csr.real_field_ops
 
org.flag4j.linalg.ops.dense.field_ops
Implementations of operations on Field dense array objects.
org.flag4j.linalg.ops.dense.real_field_ops
Implementations of operations between real array objects and Field dense array objects.
org.flag4j.linalg.ops.sparse.csr
 
org.flag4j.numbers
Provides algebraic structures such as semirings, rings, and fields, along with their concrete implementations.
org.flag4j.util
General utilities for arrays, strings, data validation, and generating error messages.

  • Uses of Field in org.flag4j.arrays

    Constructors in org.flag4j.arrays with parameters of type Field
    Modifier
    Constructor
    Description
     
    SmartMatrix(T[][] matrix)
    Constructs a SmartMatrix from a 2D Field array.

  • Uses of Field in org.flag4j.arrays.backend.field_arrays

    Classes in org.flag4j.arrays.backend.field_arrays with type parameters of type Field
    Modifier and Type
    Class
    Description
    class 
    AbstractCooFieldMatrix<T extends AbstractCooFieldMatrix<T,U,V,W>,U extends AbstractDenseFieldMatrix<U,?,W>,V extends AbstractCooFieldVector<V,?,T,U,W>,W extends Field<W>>
    A sparse matrix stored in coordinate list (COO) format.
    class 
    AbstractCooFieldTensor<T extends AbstractCooFieldTensor<T,U,V>,U extends AbstractDenseFieldTensor<U,V>,V extends Field<V>>
    Base class for all sparse Field tensors stored in coordinate list (COO) format.
    class 
    AbstractCooFieldVector<T extends AbstractCooFieldVector<T,U,V,W,Y>,U extends AbstractDenseFieldVector<U,W,Y>,V extends AbstractCooFieldMatrix<V,W,T,Y>,W extends AbstractDenseFieldMatrix<W,U,Y>,Y extends Field<Y>>
    A sparse vector stored in coordinate list (COO) format.
    class 
    AbstractCsrFieldMatrix<T extends AbstractCsrFieldMatrix<T,U,V,W>,U extends AbstractDenseFieldMatrix<U,?,W>,V extends AbstractCooFieldVector<V,?,?,U,W>,W extends Field<W>>
     
    class 
    AbstractDenseFieldMatrix<T extends AbstractDenseFieldMatrix<T,U,V>,U extends AbstractDenseFieldVector<U,T,V>,V extends Field<V>>
     
    class 
    AbstractDenseFieldTensor<T extends AbstractDenseFieldTensor<T,V>,V extends Field<V>>
    The base class for all dense Field tensors.
    class 
    AbstractDenseFieldVector<T extends AbstractDenseFieldVector<T,U,V>,U extends AbstractDenseFieldMatrix<U,T,V>,V extends Field<V>>
    The base class for all dense vectors whose data are Field elements.
    interface 
    FieldTensorMixin<T extends FieldTensorMixin<T,U,V>,U extends FieldTensorMixin<U,U,V>,V extends Field<V>>
    This interface provides default functionality for all tensors whose data are elements of a Field.
    Methods in org.flag4j.arrays.backend.field_arrays that return Field
    Modifier and Type
    Method
    Description
    default V[]
    FieldTensorMixin.makeEmptyDataArray(int length)
    Creates an empty array of the same type as the data array of this tensor.
    Methods in org.flag4j.arrays.backend.field_arrays with parameters of type Field
    Modifier and Type
    Method
    Description
    abstract AbstractCsrFieldMatrix<?,U,V,W>
    AbstractCooFieldMatrix.makeLikeCsrMatrix(Shape shape, W[] entries, int[] rowPointers, int[] colIndices)
    Constructs a sparse CSR matrix of a similar type to this sparse COO matrix.
    abstract AbstractCsrFieldMatrix<?,T,?,V>
    AbstractDenseFieldMatrix.makeLikeCsrMatrix(Shape shape, V[] entries, int[] rowPointers, int[] colIndices)
    Constructs a sparse CSR matrix which is of a similar type as this dense matrix.
    Constructors in org.flag4j.arrays.backend.field_arrays with parameters of type Field
    Modifier
    Constructor
    Description
    protected
    AbstractCooFieldMatrix(Shape shape, W[] data, int[] rowIndices, int[] colIndices)
    Creates a sparse coo matrix with the specified non-zero data, non-zero indices, and shape.
    protected
    AbstractCooFieldMatrix(Shape shape, W[] data, int[] rowIndices, int[] colIndices, Object dummy)
    Creates a sparse coo matrix with the specified non-zero data, non-zero indices, and shape.
    protected
    AbstractCooFieldTensor(Shape shape, V[] entries, int[][] indices)
    Creates a tensor with the specified data and shape.
    protected
    AbstractCooFieldTensor(Shape shape, V[] data, int[][] indices, Object dummy)
    Constructor useful for avoiding parameter validation while constructing COO tensors.
    protected
    AbstractCooFieldVector(Shape shape, Y[] data, int[] indices)
    Creates a tensor with the specified data and shape.
    protected
    AbstractCooFieldVector(Shape shape, Y[] data, int[] indices, Object dummy)
    Creates a tensor with the specified data and shape without performing any validation on the parameters.
    protected
    AbstractCsrFieldMatrix(Shape shape, W[] data, int[] rowPointers, int[] colIndices)
    Creates a sparse CSR matrix with the specified shape, non-zero data, row pointers, and non-zero column indices.
    protected
    AbstractCsrFieldMatrix(Shape shape, W[] data, int[] rowPointers, int[] colIndices, Object dummy)
    Creates a sparse CSR matrix with the specified shape, non-zero data, row pointers, and non-zero column indices.
    protected
    AbstractDenseFieldMatrix(Shape shape, V[] data)
    Creates a tensor with the specified data and shape.
    protected
    AbstractDenseFieldTensor(Shape shape, V[] entries)
    Creates a tensor with the specified data and shape.
    protected
    AbstractDenseFieldVector(Shape shape, V[] entries)
    Creates a tensor with the specified data and shape.

  • Uses of Field in org.flag4j.arrays.backend.smart_visitors

    Methods in org.flag4j.arrays.backend.smart_visitors with type parameters of type Field
    Modifier and Type
    Method
    Description
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    AddVisitor.visit(FieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    AddVisitor.visit(CooFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    AddVisitor.visit(CsrFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    DivVisitor.visit(FieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    DivVisitor.visit(CooFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    DivVisitor.visit(CsrFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    ElemMultVisitor.visit(FieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    ElemMultVisitor.visit(CooFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    ElemMultVisitor.visit(CsrFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    MatMultVisitor.visit(FieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    MatMultVisitor.visit(CooFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    MatMultVisitor.visit(CsrFieldMatrix<U> matrix)
     
    abstract <U extends Field<U>>
    T
    MatrixVisitor.visit(FieldMatrix<U> matrix)
     
    abstract <U extends Field<U>>
    T
    MatrixVisitor.visit(CooFieldMatrix<U> matrix)
     
    abstract <U extends Field<U>>
    T
    MatrixVisitor.visit(CsrFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    SubVisitor.visit(FieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    SubVisitor.visit(CooFieldMatrix<U> matrix)
     
    <U extends Field<U>>
    MatrixMixin<?,?,?,?>
    SubVisitor.visit(CsrFieldMatrix<U> matrix)
     

  • Uses of Field in org.flag4j.arrays.dense

    Classes in org.flag4j.arrays.dense with type parameters of type Field
    Modifier and Type
    Class
    Description
    class 
    FieldMatrix<T extends Field<T>>
    Instances of this class represents a dense matrix backed by a Field array.
    class 
    FieldTensor<T extends Field<T>>
    Instances of this class represent a dense tensor backed by a Field array.
    class 
    FieldVector<T extends Field<T>>
    Instances of this class represents a dense vector backed by a Field array.
    Methods in org.flag4j.arrays.dense with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    FieldMatrix<T>
    FieldMatrix.I(int numRows, int numCols, T fieldValue)
    Constructs an identity-like matrix of the specified shape.
    static <T extends Field<T>>
    FieldMatrix<T>
    FieldMatrix.I(int size, T fieldValue)
    Constructs an identity matrix of the specified size.
    static <T extends Field<T>>
    FieldMatrix<T>
    FieldMatrix.I(Shape shape, T fieldValue)
    Constructs an identity-like matrix of the specified shape.
    Methods in org.flag4j.arrays.dense with parameters of type Field
    Modifier and Type
    Method
    Description
    CooFieldMatrix<T>
    FieldMatrix.makeLikeCooMatrix(Shape shape, T[] entries, int[] rowIndices, int[] colIndices)
    Constructs a sparse COO matrix of similar type to this dense matrix.
    protected CooFieldMatrix<T>
    FieldMatrix.makeLikeCooTensor(Shape shape, T[] entries, int[][] indices)
    Constructs a sparse COO tensor which is of a similar type as this dense tensor.
    protected CooFieldTensor<T>
    FieldTensor.makeLikeCooTensor(Shape shape, T[] entries, int[][] indices)
    Constructs a sparse COO tensor which is of a similar type as this dense tensor.
    protected CooFieldVector<T>
    FieldVector.makeLikeCooTensor(Shape shape, T[] entries, int[][] indices)
    Constructs a sparse COO tensor which is of a similar type as this dense tensor.
    CsrFieldMatrix<T>
    FieldMatrix.makeLikeCsrMatrix(Shape shape, T[] entries, int[] rowPointers, int[] colIndices)
    Constructs a sparse CSR matrix of similar type to this dense matrix.
    FieldMatrix<T>
    FieldVector.makeLikeMatrix(Shape shape, T[] entries)
    Constructs a matrix of similar type to this vector with the specified shape and data.
    FieldMatrix<T>
    FieldMatrix.makeLikeTensor(Shape shape, T[] entries)
    Constructs a tensor of the same type as this tensor with the given the shape and data.
    FieldTensor<T>
    FieldTensor.makeLikeTensor(Shape shape, T[] entries)
    Constructs a tensor of the same type as this tensor with the given the shape and data.
    FieldVector<T>
    FieldVector.makeLikeTensor(Shape shape, T[] entries)
    Constructs a tensor of the same type as this tensor with the given the shape and data.
    FieldVector<T>
    FieldVector.makeLikeTensor(T... entries)
    Creates a vector with the specified data.
    protected FieldVector<T>
    FieldMatrix.makeLikeVector(Shape shape, T[] entries)
    Constructs a vector of a similar type as this matrix.
    FieldVector<T>
    FieldMatrix.makeLikeVector(T... entries)
    Constructs a vector of similar type to this matrix with the given data.
    Constructors in org.flag4j.arrays.dense with parameters of type Field
    Modifier
    Constructor
    Description
     
    FieldMatrix(int rows, int cos, T[] entries)
    Creates a dense field matrix with the specified data and shape.
     
    FieldMatrix(int rows, int cols, T[][] entries)
    Creates a dense field matrix with the specified data and shape.
     
    FieldMatrix(Shape shape, T[] entries)
    Creates a dense field matrix with the specified data and shape.
     
    FieldMatrix(T[][] entries)
    Creates a dense field matrix with the specified data and shape.
     
    FieldTensor(Shape shape, T[] entries)
    Creates a tensor with the specified data and shape.
     
    FieldVector(Shape shape, T[] entries)
    Constructs a dense complex vector with the given shape and entries.
     
    FieldVector(T... entries)
    Creates a vector with the specified data.

  • Uses of Field in org.flag4j.arrays.sparse

    Classes in org.flag4j.arrays.sparse with type parameters of type Field
    Modifier and Type
    Class
    Description
    class 
    CooFieldMatrix<T extends Field<T>>
    Instances of this class represent a sparse matrix whose non-zero elements are stored in Coordinate List (COO) format, with all data elements belonging to a specified Field type.
    class 
    CooFieldTensor<T extends Field<T>>
    Represents a sparse tensor whose non-zero elements are stored in Coordinate List (COO) format, with all data elements belonging to a specified Field type.
    class 
    CooFieldVector<T extends Field<T>>
    Represents a sparse vector whose non-zero elements are stored in Coordinate List (COO) format, with all data elements belonging to a specified Field type.
    class 
    CsrFieldMatrix<T extends Field<T>>
    Instances of this class represent a sparse matrix using the compressed sparse row (CSR) format where all data elements belonging to a specified Field type.
    Methods in org.flag4j.arrays.sparse with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    CooFieldMatrix<T>
    CooFieldMatrix.unsafeMake(Shape shape, T[] data, int[] rowIndices, int[] colIndices)
    Factory to construct a COO matrix which bypasses any validation checks on the data and indices.
    static <T extends Field<T>>
    CooFieldTensor<T>
    CooFieldTensor.unsafeMake(Shape shape, T[] data, int[][] indices)
    Factory to construct a COO tensor which bypasses any validation checks on the data and indices.
    static <T extends Field<T>>
    CooFieldVector<T>
    CooFieldVector.unsafeMake(int size, T[] data, int[] indices)
    Factory to construct a COO vector which bypasses any validation checks on the data and indices.
    static <T extends Field<T>>
    CooFieldVector<T>
    CooFieldVector.unsafeMake(Shape shape, T[] data, int[] indices)
    Factory to construct a COO vector which bypasses any validation checks on the data and indices.
    static <T extends Field<T>>
    CsrFieldMatrix<T>
    CsrFieldMatrix.unsafeMake(Shape shape, Complex128[] data, int[] rowPointers, int[] colIndices)
    Factory to construct a CSR matrix which bypasses any validation checks on the data and indices.
    Methods in org.flag4j.arrays.sparse with parameters of type Field
    Modifier and Type
    Method
    Description
    CooFieldMatrix<T>
    CsrFieldMatrix.makeLikeCooMatrix(Shape shape, T[] data, int[] rowIndices, int[] colIndices)
    Constructs a sparse COO matrix of a similar type to this sparse CSR matrix.
    CsrFieldMatrix<T>
    CooFieldMatrix.makeLikeCsrMatrix(Shape shape, T[] entries, int[] rowPointers, int[] colIndices)
    Constructs a sparse CSR matrix of a similar type to this sparse COO matrix.
    FieldMatrix<T>
    CooFieldVector.makeLikeDenseMatrix(Shape shape, T... entries)
    Constructs a dense matrix of a similar type as this vector with the specified shape and data.
    FieldMatrix<T>
    CooFieldMatrix.makeLikeDenseTensor(Shape shape, T[] entries)
    Constructs a dense tensor with the specified shape and data which is a similar type to this sparse tensor.
    FieldTensor<T>
    CooFieldTensor.makeLikeDenseTensor(Shape shape, T[] entries)
    Constructs a dense tensor that is a similar type as this sparse COO tensor.
    FieldVector<T>
    CooFieldVector.makeLikeDenseTensor(Shape shape, T... entries)
    Constructs a dense vector of a similar type as this vector with the specified shape and data.
    FieldMatrix<T>
    CsrFieldMatrix.makeLikeDenseTensor(Shape shape, T[] data)
    Constructs a dense matrix which is of a similar type to this sparse CSR matrix.
    CooFieldMatrix<T>
    CooFieldVector.makeLikeMatrix(Shape shape, T[] entries, int[] rowIndices, int[] colIndices)
    Constructs a COO matrix with the specified shape, non-zero data, and row and column indices.
    CooFieldMatrix<T>
    CooFieldMatrix.makeLikeTensor(Shape shape, T[] entries)
    Constructs a tensor of the same type as this tensor with the given the shape and data.
    CooFieldMatrix<T>
    CooFieldMatrix.makeLikeTensor(Shape shape, T[] entries, int[] rowIndices, int[] colIndices)
    Constructs a sparse COO tensor of the same type as this tensor with the specified non-zero data and indices.
    CooFieldTensor<T>
    CooFieldTensor.makeLikeTensor(Shape shape, T[] entries)
    Constructs a sparse tensor of the same type as this tensor with the same indices as this sparse tensor and with the provided the shape and data.
    CooFieldTensor<T>
    CooFieldTensor.makeLikeTensor(Shape shape, T[] entries, int[][] indices)
    Constructs a tensor of the same type as this tensor with the specified shape and non-zero data.
    CooFieldVector<T>
    CooFieldVector.makeLikeTensor(Shape shape, T[] entries)
    Constructs a tensor of the same type as this tensor with the given the shape and data.
    CooFieldVector<T>
    CooFieldVector.makeLikeTensor(Shape shape, T[] entries, int[] indices)
    Constructs a sparse COO vector of the same type as this vector with the specified non-zero data and indices.
    CsrFieldMatrix<T>
    CsrFieldMatrix.makeLikeTensor(Shape shape, T[] data)
    Constructs a tensor of the same type as this tensor with the given the shape and data.
    CsrFieldMatrix<T>
    CsrFieldMatrix.makeLikeTensor(Shape shape, T[] data, int[] rowPointers, int[] colIndices)
    Constructs a sparse CSR tensor of the same type as this tensor with the specified non-zero data and indices.
    CooFieldVector<T>
    CooFieldMatrix.makeLikeVector(Shape shape, T[] entries, int[] indices)
    Constructs a sparse COO vector of a similar type to this COO matrix.
    static <T extends Field<T>>
    CooFieldMatrix<T>
    CooFieldMatrix.unsafeMake(Shape shape, T[] data, int[] rowIndices, int[] colIndices)
    Factory to construct a COO matrix which bypasses any validation checks on the data and indices.
    static <T extends Field<T>>
    CooFieldTensor<T>
    CooFieldTensor.unsafeMake(Shape shape, T[] data, int[][] indices)
    Factory to construct a COO tensor which bypasses any validation checks on the data and indices.
    static <T extends Field<T>>
    CooFieldVector<T>
    CooFieldVector.unsafeMake(int size, T[] data, int[] indices)
    Factory to construct a COO vector which bypasses any validation checks on the data and indices.
    static <T extends Field<T>>
    CooFieldVector<T>
    CooFieldVector.unsafeMake(Shape shape, T[] data, int[] indices)
    Factory to construct a COO vector which bypasses any validation checks on the data and indices.
    Constructors in org.flag4j.arrays.sparse with parameters of type Field
    Modifier
    Constructor
    Description
     
    CooFieldMatrix(int rows, int cols, T[] entries, int[] rowIndices, int[] colIndices)
    Creates a sparse coo matrix with the specified non-zero data, non-zero indices, and shape.
     
    CooFieldMatrix(Shape shape, T[] entries, int[] rowIndices, int[] colIndices)
    Creates a sparse coo matrix with the specified non-zero data, non-zero indices, and shape.
     
    CooFieldTensor(Shape shape, T[] entries, int[][] indices)
    creates a tensor with the specified data and shape.
     
    CooFieldVector(int size, T[] entries, int[] indices)
    Creates sparse COO vector with the specified size, non-zero data, and non-zero indices.
     
    CooFieldVector(Shape shape, T[] entries, int[] indices)
    Creates sparse COO vector with the specified size, non-zero data, and non-zero indices.
     
    CsrFieldMatrix(Shape shape, T[] data, int[] rowPointers, int[] colIndices)
    Creates a sparse CSR matrix with the specified shape, non-zero data, row pointers, and non-zero column indices.

  • Uses of Field in org.flag4j.linalg.decompositions.lu

    Classes in org.flag4j.linalg.decompositions.lu with type parameters of type Field
    Modifier and Type
    Class
    Description
    class 
    FieldLU<T extends Field<T>>
    Instances of this class can be used to compute the LU decomposition of a complex dense matrix.

  • Uses of Field in org.flag4j.linalg.ops.common.field_ops

    Methods in org.flag4j.linalg.ops.common.field_ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <V extends Field<V>>
    void
    FieldOps.add(double[] src, V scalar, V[] dest)
    Adds a scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.add(V[] src, double scalar, V[] dest)
    Adds a primitive scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.conj(V[] src, V[] dest)
    Computes the element-wise complex conjugate of a tensor.
    static <V extends Field<V>>
    void
    FieldOps.div(double[] src, V scalar, V[] dest)
    Divides each entry of the src tensor by a scalar.
    static <V extends Field<V>>
    void
    FieldOps.div(V[] src, double scalar, V[] dest)
    Divides each entry of the src tensor by a primitive scalar.
    static <V extends Field<V>>
    void
    FieldOps.div(V[] src, V scalar, V[] dest)
    Divides each entry of the src tensor by a scalar.
    static <V extends Field<V>>
    boolean
    FieldOps.isFinite(V[] src)
    Checks if all elements of a tensor are finite.
    static <V extends Field<V>>
    boolean
    FieldOps.isInfinite(V[] src)
    Checks if any element of a tensor is infinite.
    static <V extends Field<V>>
    boolean
    FieldOps.isNaN(V[] src)
    Checks if any element of a tensor is NaN.
    static <V extends Field<V>>
    void
    FieldOps.mult(double[] src, V scalar, V[] dest)
    Multiplies a scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.mult(V[] src, double scalar, V[] dest)
    Multiplies a primitive scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.recip(V[] src, V[] dest)
    Computes the reciprocals, element-wise, of a tensor.
    static <V extends Field<V>>
    void
    FieldOps.scalMult(double[] entries, V factor, V[] dest)
    Computes the scalar multiplication of a tensor.
    static <T extends Field<T>>
    T[]
    FieldOps.scalMult(T[] src, double factor, int start, int n, int stride, T[] dest)
    Scales entries by the specified factor within src starting at index start and scaling a total of n elements spaced by stride.
    static <V extends Field<V>>
    void
    FieldOps.scalMult(V[] src, double factor, V[] dest)
    Computes the scalar multiplication of a tensor with a scalar value.
    static <V extends Field<V>>
    void
    FieldOps.sqrt(V[] src, V[] dest)
    Computes the element-wise square root of a tensor.
    static <V extends Field<V>>
    void
    FieldOps.sub(double[] src, V scalar, V[] dest)
    Subtracts a scalar value from each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.sub(V[] src, double scalar, V[] dest)
    Subtracts a primitive scalar value from each entry of the src tensor.
    Methods in org.flag4j.linalg.ops.common.field_ops that return Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    FieldOps.scalMult(T[] src, double factor, int start, int n, int stride, T[] dest)
    Scales entries by the specified factor within src starting at index start and scaling a total of n elements spaced by stride.
    Methods in org.flag4j.linalg.ops.common.field_ops with parameters of type Field
    Modifier and Type
    Method
    Description
    static <V extends Field<V>>
    void
    FieldOps.add(double[] src, V scalar, V[] dest)
    Adds a scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.add(V[] src, double scalar, V[] dest)
    Adds a primitive scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.conj(V[] src, V[] dest)
    Computes the element-wise complex conjugate of a tensor.
    static <V extends Field<V>>
    void
    FieldOps.div(double[] src, V scalar, V[] dest)
    Divides each entry of the src tensor by a scalar.
    static <V extends Field<V>>
    void
    FieldOps.div(V[] src, double scalar, V[] dest)
    Divides each entry of the src tensor by a primitive scalar.
    static <V extends Field<V>>
    void
    FieldOps.div(V[] src, V scalar, V[] dest)
    Divides each entry of the src tensor by a scalar.
    static <V extends Field<V>>
    boolean
    FieldOps.isFinite(V[] src)
    Checks if all elements of a tensor are finite.
    static <V extends Field<V>>
    boolean
    FieldOps.isInfinite(V[] src)
    Checks if any element of a tensor is infinite.
    static <V extends Field<V>>
    boolean
    FieldOps.isNaN(V[] src)
    Checks if any element of a tensor is NaN.
    static <V extends Field<V>>
    void
    FieldOps.mult(double[] src, V scalar, V[] dest)
    Multiplies a scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.mult(V[] src, double scalar, V[] dest)
    Multiplies a primitive scalar value to each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.recip(V[] src, V[] dest)
    Computes the reciprocals, element-wise, of a tensor.
    static <V extends Field<V>>
    void
    FieldOps.scalMult(double[] entries, V factor, V[] dest)
    Computes the scalar multiplication of a tensor.
    static <T extends Field<T>>
    T[]
    FieldOps.scalMult(T[] src, double factor, int start, int n, int stride, T[] dest)
    Scales entries by the specified factor within src starting at index start and scaling a total of n elements spaced by stride.
    static <V extends Field<V>>
    void
    FieldOps.scalMult(V[] src, double factor, V[] dest)
    Computes the scalar multiplication of a tensor with a scalar value.
    static <V extends Field<V>>
    void
    FieldOps.sqrt(V[] src, V[] dest)
    Computes the element-wise square root of a tensor.
    static <V extends Field<V>>
    void
    FieldOps.sub(double[] src, V scalar, V[] dest)
    Subtracts a scalar value from each entry of the src tensor.
    static <V extends Field<V>>
    void
    FieldOps.sub(V[] src, double scalar, V[] dest)
    Subtracts a primitive scalar value from each entry of the src tensor.

  • Uses of Field in org.flag4j.linalg.ops.dense_sparse.coo.field_ops

    Methods in org.flag4j.linalg.ops.dense_sparse.coo.field_ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCooFieldMatrixOps.add(AbstractDenseFieldMatrix<?,?,T> src1, AbstractCooFieldMatrix<?,?,?,T> src2)
    Computes the element-wise sum of a dense matrix to a sparse COO matrix.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    DenseCooFieldTensorOps.add(AbstractCooFieldTensor<?,?,T> src1, Field<T> b)
    Adds a scalar to a complex sparse COO tensor.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    DenseCooFieldTensorOps.add(AbstractDenseFieldTensor<?,T> src1, AbstractCooFieldTensor<?,?,T> src2)
    Computes element-wise addition of a dense tensor with a sparse COO tensor.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    DenseCooFieldVectorOps.add(AbstractDenseFieldVector<?,?,T> src1, AbstractCooFieldVector<?,?,?,?,T> src2)
    Computes the element-wise addition between a dense complex vector and sparse complex vectors.
    static <T extends Field<T>>
    void
    DenseCooFieldMatrixOps.addEq(AbstractDenseFieldMatrix<?,?,T> src1, AbstractCooFieldMatrix<?,?,?,T> src2)
    Adds a complex dense matrix to a real sparse matrix and stores the result in the first matrix.
    static <T extends Field<T>>
    void
    DenseCooFieldTensorOps.addEq(AbstractDenseFieldTensor<?,T> src1, AbstractCooFieldTensor<?,?,T> src2)
    Computes element-wise addition of a dense tensor with a sparse COO tensor.
    static <T extends Field<T>>
    void
    DenseCooFieldVectorOps.addEq(AbstractDenseFieldVector<?,?,T> src1, AbstractCooFieldVector<?,?,?,?,T> src2)
    Computes the element-wise addition between a dense complex vector and sparse complex vectors.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCooFieldMatrixOps.addToEachCol(AbstractCooFieldMatrix<?,?,?,T> src, AbstractDenseFieldVector<?,?,T> col)
    Adds a dense vector to each column as if the vector is a column vector.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCooFieldMatrixOps.addToEachRow(AbstractCooFieldMatrix<?,?,?,T> src, AbstractDenseFieldVector<?,?,T> row)
    Adds a dense vector to add to each row as if the vector is a row vector.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.blockedVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentBlockedVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a real dense matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandard(T[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a real sparse matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandardVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    AbstractCooFieldMatrix<?,?,?,T>
    DenseCooFieldMatrixOps.elemDiv(AbstractCooFieldMatrix<?,?,?,T> src1, AbstractDenseFieldMatrix<?,?,T> src2)
    Computes the element-wise division between a complex sparse matrix and a complex dense matrix.
    static <T extends Field<T>>
    AbstractCooFieldTensor<?,?,T>
    DenseCooFieldTensorOps.elemDiv(AbstractCooFieldTensor<?,?,T> src1, AbstractDenseFieldTensor<?,T> src2)
    Computes the element-wise division between a complex dense tensor and a complex sparse tensor.
    static <T extends Field<T>>
    AbstractCooFieldVector<?,?,?,?,T>
    DenseCooFieldVectorOps.elemDiv(AbstractCooFieldVector<?,?,?,?,T> src1, AbstractDenseFieldVector<?,?,T> src2)
    Compute the element-wise division between a complex sparse vector and a complex dense vector.
    static <T extends Field<T>>
    void
    DenseCooFieldMatrixOps.elemMult(Shape shape1, T[] data1, Shape shape2, T[] data2, int[] rowIndices2, int[] colIndices2, T[] dest)
    Computes the element-wise multiplication between a real dense matrix and a real sparse matrix.
    static <T extends Field<T>>
    AbstractCooFieldTensor<?,?,T>
    DenseCooFieldTensorOps.elemMult(AbstractDenseFieldTensor<?,T> src1, AbstractCooFieldTensor<?,?,T> src2)
    Computes the element-wise tensor multiplication between a complex dense tensor and a complex sparse tensor.
    static <T extends Field<T>>
    AbstractCooFieldVector<?,?,?,?,T>
    DenseCooFieldVectorOps.elemMult(AbstractDenseFieldVector<?,?,T> src1, AbstractCooFieldVector<?,?,?,?,T> src2)
    Computes the element-wise multiplication of a complex dense vector with a complex sparse vector.
    static <T extends Field<T>>
    T
    DenseCooFieldVectorOps.innerProduct(T[] src1, int[] indices, int sparseSize, T[] src2)
    Computes the vector inner product between a complex dense vector and a complex sparse vector.
    static <T extends Field<T>>
    T
    DenseCooFieldVectorOps.innerProduct(T[] src1, T[] src2, int[] indices, int sparseSize)
    Computes the vector inner product between a complex dense vector and a complex sparse vector.
    static <T extends Field<T>>
    boolean
    DenseCooFieldEquals.matrixEquals(AbstractDenseFieldMatrix<?,?,T> A, AbstractCooFieldMatrix<?,?,?,T> B)
    Checks if two real dense matrices are equal.
    static <T extends Field<T>>
    T[]
    DenseCooFieldVectorOps.outerProduct(T[] src2, int[] indices, int sparseSize, T[] src1)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    DenseCooFieldVectorOps.outerProduct(T[] src1, T[] src2, int[] indices, int sparseSize, T[] dest)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a sparse COO matrix and a dense matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standard(T[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a dense matrix and a sparse COO matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standardVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCooFieldMatrixOps.sub(AbstractCooFieldMatrix<?,?,?,T> src2, AbstractDenseFieldMatrix<?,?,T> src1)
    Subtracts a complex dense matrix from a complex sparse matrix.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCooFieldMatrixOps.sub(AbstractDenseFieldMatrix<?,?,T> src1, AbstractCooFieldMatrix<?,?,?,T> src2)
    Subtracts a real sparse matrix from a real dense matrix.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    DenseCooFieldTensorOps.sub(AbstractCooFieldTensor<?,?,T> src1, AbstractDenseFieldTensor<?,T> src2)
    Subtracts a complex dense tensor from a complex sparse tensor.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    DenseCooFieldTensorOps.sub(AbstractCooFieldTensor<?,?,T> src1, Field<T> b)
    Subtracts a scalar from a sparse COO tensor.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    DenseCooFieldTensorOps.sub(AbstractDenseFieldTensor<?,T> src1, AbstractCooFieldTensor<?,?,T> src2)
    Computes the element-wise tensor a complex sparse tensor from a complex dense tensor.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    DenseCooFieldVectorOps.sub(AbstractCooFieldVector<?,?,?,?,T> src1, AbstractDenseFieldVector<?,?,T> src2)
    Subtracts a complex dense vector from a complex sparse vector.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    DenseCooFieldVectorOps.sub(AbstractDenseFieldVector<?,?,T> src1, AbstractCooFieldVector<?,?,?,?,T> src2)
    Subtracts a complex sparse vector from a complex dense vector.
    static <T extends Field<T>>
    void
    DenseCooFieldMatrixOps.subEq(AbstractDenseFieldMatrix<?,?,T> src1, AbstractCooFieldMatrix<?,?,?,T> src2)
    Subtracts a complex sparse matrix from a complex dense matrix and stores the result in the dense matrix.
    static <T extends Field<T>>
    void
    DenseCooFieldTensorOps.subEq(AbstractDenseFieldTensor<?,T> src1, AbstractCooFieldTensor<?,?,T> src2)
    Computes element-wise subtraction of a complex dense tensor with a complex sparse tensor.
    static <T extends Field<T>>
    void
    DenseCooFieldVectorOps.subEq(AbstractDenseFieldVector<?,?,T> src1, AbstractCooFieldVector<?,?,?,?,T> src2)
    Computes the element-wise subtraction between a dense complex vector and sparse complex vectors.
    static <T extends Field<T>>
    boolean
    DenseCooFieldEquals.tensorEquals(AbstractDenseFieldTensor<?,T> A, AbstractCooFieldTensor<?,?,T> B)
    Checks if a complex dense tensor is equal to a complex sparse tensor.
    static <T extends Field<T>>
    boolean
    DenseCooFieldEquals.vectorEquals(AbstractDenseFieldVector<?,?,T> src1, AbstractCooFieldVector<?,?,?,?,T> src2)
    Checks if a complex dense vector is equal to a complex sparse vector.
    Methods in org.flag4j.linalg.ops.dense_sparse.coo.field_ops that return Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    DenseCooFieldVectorOps.outerProduct(T[] src2, int[] indices, int sparseSize, T[] src1)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    Methods in org.flag4j.linalg.ops.dense_sparse.coo.field_ops with parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    DenseCooFieldTensorOps.add(AbstractCooFieldTensor<?,?,T> src1, Field<T> b)
    Adds a scalar to a complex sparse COO tensor.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.blockedVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentBlockedVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a real dense matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandard(T[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a real sparse matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.concurrentStandardVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatrixOps.elemMult(Shape shape1, T[] data1, Shape shape2, T[] data2, int[] rowIndices2, int[] colIndices2, T[] dest)
    Computes the element-wise multiplication between a real dense matrix and a real sparse matrix.
    static <T extends Field<T>>
    T
    DenseCooFieldVectorOps.innerProduct(T[] src1, int[] indices, int sparseSize, T[] src2)
    Computes the vector inner product between a complex dense vector and a complex sparse vector.
    static <T extends Field<T>>
    T
    DenseCooFieldVectorOps.innerProduct(T[] src1, T[] src2, int[] indices, int sparseSize)
    Computes the vector inner product between a complex dense vector and a complex sparse vector.
    static <T extends Field<T>>
    T[]
    DenseCooFieldVectorOps.outerProduct(T[] src2, int[] indices, int sparseSize, T[] src1)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    DenseCooFieldVectorOps.outerProduct(T[] src1, T[] src2, int[] indices, int sparseSize, T[] dest)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a sparse COO matrix and a dense matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standard(T[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a dense matrix and a sparse COO matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    DenseCooFieldMatMult.standardVector(T[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    DenseCooFieldTensorOps.sub(AbstractCooFieldTensor<?,?,T> src1, Field<T> b)
    Subtracts a scalar from a sparse COO tensor.

  • Uses of Field in org.flag4j.linalg.ops.dense_sparse.coo.real_field_ops

    Methods in org.flag4j.linalg.ops.dense_sparse.coo.real_field_ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCooMatrixOps.add(AbstractDenseFieldMatrix<?,?,T> src1, CooMatrix src2)
    Adds a real dense matrix to a real sparse matrix.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    RealFieldDenseCooOps.add(AbstractDenseFieldTensor<?,T> src1, CooTensor src2)
    Adds a dense complex tensor to a real sparse tensor.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    RealFieldDenseCooVectorOps.add(AbstractDenseFieldVector<?,?,T> src1, CooVector src2)
    Adds a complex dense matrix to a real sparse matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatrixOps.addEq(AbstractDenseFieldMatrix<?,?,T> src1, CooMatrix src2)
    Adds a complex dense matrix to a real sparse matrix and stores the result in the first matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooOps.addEq(AbstractDenseFieldTensor<?,T> src1, CooTensor src2)
    Computes element-wise addition between a complex dense tensor and a real sparse tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.addEq(AbstractDenseFieldVector<?,?,T> src1, CooVector src2)
    Computes the vector addition between a dense complex vector and a sparse real vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.blockedVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.blockedVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentBlockedVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentBlockedVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(double[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(T[] src1, Shape shape1, double[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    AbstractCooFieldMatrix<?,?,?,T>
    RealFieldDenseCooMatrixOps.elemDiv(AbstractCooFieldMatrix<?,?,?,T> src1, Matrix src2)
    Computes the element-wise division between a complex sparse matrix and a real dense matrix.
    static <T extends Field<T>>
    AbstractCooFieldTensor<?,?,T>
    RealFieldDenseCooOps.elemDiv(AbstractCooFieldTensor<?,?,T> src1, Tensor src2)
    Computes the element-wise division between a real dense tensor and a real sparse tensor.
    static <T extends Field<T>>
    AbstractCooFieldVector<?,?,?,?,T>
    RealFieldDenseCooVectorOps.elemDiv(AbstractCooFieldVector<?,?,?,?,T> src1, Vector src2)
    Compute the element-wise division between a sparse vector and a dense vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatrixOps.elemMult(AbstractDenseFieldMatrix<?,?,T> src1, CooMatrix src2, Field<T>[] destEntries)
    Computes the element-wise multiplication between two matrices.
    static <T extends Field<T>>
    AbstractCooFieldMatrix<?,?,?,T>
    RealFieldDenseCooMatrixOps.elemMult(Matrix src1, AbstractCooFieldMatrix<?,?,?,T> src2)
    Computes the element-wise multiplication between a real dense matrix and a complex sparse matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooOps.elemMult(AbstractDenseFieldTensor<?,T> src1, CooTensor src2, T[] destEntries, int[][] destIndices)
    Computes the element-wise multiplication between a real dense tensor and a complex sparse tensor.
    static <T extends Field<T>>
    AbstractCooFieldTensor<?,?,T>
    RealFieldDenseCooOps.elemMult(Tensor src1, AbstractCooFieldTensor<?,?,T> src2)
    Computes the element-wise multiplication between a real dense tensor and a complex sparse tensor.
    static <T extends Field<T>>
    T[]
    RealFieldDenseCooVectorOps.elemMult(AbstractDenseFieldVector<?,?,T> src1, CooVector src2)
    Computes the element-wise product between a dense Field vector and a real COO vector.
    static <T extends Field<T>>
    AbstractCooFieldVector<?,?,?,?,T>
    RealFieldDenseCooVectorOps.elemMult(Vector src1, AbstractCooFieldVector<?,?,?,?,T> src2)
    Computes the element-wise multiplication of a real dense vector with a complex sparse vector.
    static <T extends Field<T>>
    T
    RealFieldDenseCooVectorOps.inner(double[] src1, int[] indices, int sparseSize, T[] src2)
    Computes the vector inner product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    T
    RealFieldDenseCooVectorOps.inner(double[] src1, T[] src2, int[] indices, int sparseSize)
    Computes the vector inner product between a real dense vector and a complex sparse vector.
    static <T extends Field<T>>
    T
    RealFieldDenseCooVectorOps.inner(T[] src1, double[] src2, int[] indices, int sparseSize)
    Computes the vector inner product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMultTranspose.multTranspose(double[] deSrc, Shape deShape, T[] spSrc, int[] rowIndices, int[] colIndices, Shape spShape, T[] dest)
    Multiplies a real dense matrix to the transpose of a sparse field matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMultTranspose.multTranspose(T[] dSrc, Shape dShape, double[] spSrc, int[] rowIndices, int[] colIndices, Shape spShape, T[] dest)
    Multiplies a dense field matrix to the transpose of a real sparse matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.outerProduct(double[] src1, int[] indices, int sparseSize, T[] src2, T[] dest)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.outerProduct(double[] src1, T[] src2, int[] indices, int sparseSize, T[] dest)
    Computes the vector outer product between a real dense vector and a complex sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.outerProduct(T[] src1, double[] src2, int[] indices, int sparseSize, T[] dest)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    T[]
    RealFieldDenseCooVectorOps.outerProduct(T[] src1, int[] indices, int sparseSize, double[] src2, T[] dest)
    Computes the vector outer product between a rea; dense vector and a complex sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(double[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(T[] src1, Shape shape1, double[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCooMatrixOps.sub(AbstractDenseFieldMatrix<?,?,T> src1, CooMatrix src2)
    Subtracts a real sparse matrix from a complex dense matrix.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCooMatrixOps.sub(CooMatrix src1, AbstractDenseFieldMatrix<?,?,T> src2)
    Subtracts a real sparse matrix from a real dense matrix.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    RealFieldDenseCooOps.sub(AbstractDenseFieldTensor<?,T> src1, CooTensor src2)
    Adds a dense complex tensor to a real sparse tensor.
    static <T extends Field<T>>
    AbstractDenseFieldTensor<?,T>
    RealFieldDenseCooOps.sub(CooTensor src1, AbstractDenseFieldTensor<?,T> src2)
    Subtracts a complex dense tensor from a real sparse tensor.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    RealFieldDenseCooVectorOps.sub(AbstractDenseFieldVector<?,?,T> src1, CooVector src2)
    Subtracts a real sparse vector from a complex dense vector.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    RealFieldDenseCooVectorOps.sub(CooVector src1, AbstractDenseFieldVector<?,?,T> src2)
    Subtracts a complex dense vector from a complex sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatrixOps.subEq(AbstractDenseFieldMatrix<?,?,T> src1, CooMatrix src2)
    Subtracts a real sparse matrix from a complex dense matrix and stores the result in the first matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooOps.subEq(AbstractDenseFieldTensor<?,T> src1, CooTensor src2)
    Computes element-wise subtraction between a complex dense tensor and a real sparse tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.subEq(AbstractDenseFieldVector<?,?,T> src1, CooVector src2)
    Computes the vector subtraction between a dense complex vector and a real sparse vector.
    Methods in org.flag4j.linalg.ops.dense_sparse.coo.real_field_ops that return Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    RealFieldDenseCooVectorOps.elemMult(AbstractDenseFieldVector<?,?,T> src1, CooVector src2)
    Computes the element-wise product between a dense Field vector and a real COO vector.
    static <T extends Field<T>>
    T[]
    RealFieldDenseCooVectorOps.outerProduct(T[] src1, int[] indices, int sparseSize, double[] src2, T[] dest)
    Computes the vector outer product between a rea; dense vector and a complex sparse vector.
    Methods in org.flag4j.linalg.ops.dense_sparse.coo.real_field_ops with parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.blockedVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.blockedVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentBlockedVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentBlockedVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(double[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandard(T[] src1, Shape shape1, double[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.concurrentStandardVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a concurrent standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatrixOps.elemMult(AbstractDenseFieldMatrix<?,?,T> src1, CooMatrix src2, Field<T>[] destEntries)
    Computes the element-wise multiplication between two matrices.
    static <T extends Field<T>>
    void
    RealFieldDenseCooOps.elemMult(AbstractDenseFieldTensor<?,T> src1, CooTensor src2, T[] destEntries, int[][] destIndices)
    Computes the element-wise multiplication between a real dense tensor and a complex sparse tensor.
    static <T extends Field<T>>
    T
    RealFieldDenseCooVectorOps.inner(double[] src1, int[] indices, int sparseSize, T[] src2)
    Computes the vector inner product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    T
    RealFieldDenseCooVectorOps.inner(double[] src1, T[] src2, int[] indices, int sparseSize)
    Computes the vector inner product between a real dense vector and a complex sparse vector.
    static <T extends Field<T>>
    T
    RealFieldDenseCooVectorOps.inner(T[] src1, double[] src2, int[] indices, int sparseSize)
    Computes the vector inner product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMultTranspose.multTranspose(double[] deSrc, Shape deShape, T[] spSrc, int[] rowIndices, int[] colIndices, Shape spShape, T[] dest)
    Multiplies a real dense matrix to the transpose of a sparse field matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMultTranspose.multTranspose(T[] dSrc, Shape dShape, double[] spSrc, int[] rowIndices, int[] colIndices, Shape spShape, T[] dest)
    Multiplies a dense field matrix to the transpose of a real sparse matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.outerProduct(double[] src1, int[] indices, int sparseSize, T[] src2, T[] dest)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.outerProduct(double[] src1, T[] src2, int[] indices, int sparseSize, T[] dest)
    Computes the vector outer product between a real dense vector and a complex sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooVectorOps.outerProduct(T[] src1, double[] src2, int[] indices, int sparseSize, T[] dest)
    Computes the vector outer product between a complex dense vector and a real sparse vector.
    static <T extends Field<T>>
    T[]
    RealFieldDenseCooVectorOps.outerProduct(T[] src1, int[] indices, int sparseSize, double[] src2, T[] dest)
    Computes the vector outer product between a rea; dense vector and a complex sparse vector.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(double[] src1, Shape shape1, T[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real sparse matrix and a dense field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standard(T[] src1, Shape shape1, double[] src2, int[] rowIndices, int[] colIndices, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix and a sparse field matrix using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(double[] src1, int[] rowIndices, int[] colIndices, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(double[] src1, Shape shape1, T[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(T[] src1, int[] rowIndices, int[] colIndices, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the sparse matrix dense vector multiplication using a standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseCooMatMult.standardVector(T[] src1, Shape shape1, double[] src2, int[] indices, T[] dest)
    Computes the dense matrix sparse vector multiplication using a standard algorithm.

  • Uses of Field in org.flag4j.linalg.ops.dense_sparse.csr.field_ops

    Methods in org.flag4j.linalg.ops.dense_sparse.csr.field_ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCsrFieldOps.add(AbstractCsrFieldMatrix<?,?,?,T> a, AbstractDenseFieldMatrix<?,?,T> b)
    Computes the element-wise sum of two matrices.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCsrFieldOps.applyBinOpp(AbstractCsrFieldMatrix<?,?,?,T> src1, double b, BinaryOperator<T> opp, UnaryOperator<Double> uOpp)
    Applies the specified binary operator element-wise to a matrix and a scalar.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCsrFieldOps.applyBinOpp(AbstractCsrFieldMatrix<?,?,?,T> src1, AbstractDenseFieldMatrix<?,?,T> src2, BinaryOperator<T> opp, UnaryOperator<T> uOpp)
    Applies the specified binary operator element-wise to the two matrices.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCsrFieldOps.applyBinOpp(AbstractCsrFieldMatrix<?,?,?,T> src1, T b, BinaryOperator<T> opp, UnaryOperator<T> uOpp)
    Applies the specified binary operator element-wise to a matrix and a scalar.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCsrFieldOps.applyBinOpp(AbstractDenseFieldMatrix<?,?,T> src1, AbstractCsrFieldMatrix<?,?,?,T> src2, BinaryOperator<T> opp)
    Applies the specified binary operator element-wise to the two matrices.
    static <T extends Field<T>>
    AbstractCsrFieldMatrix<?,?,?,T>
    DenseCsrFieldOps.applyBinOppToSparse(AbstractDenseFieldMatrix<?,?,T> src1, AbstractCsrFieldMatrix<?,?,?,T> src2, BinaryOperator<T> opp)
    Applies an element-wise binary operation to a real dense and real sparse CSR matrix under the assumption that opp.apply(x, 0d) = 0d and opp.apply(0d, x) = 0d.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCsrFieldOps.sub(AbstractCsrFieldMatrix<?,?,?,T> a, AbstractDenseFieldMatrix<?,?,T> b)
    Computes the element-wise difference of two matrices.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    DenseCsrFieldOps.sub(AbstractDenseFieldMatrix<?,?,T> a, AbstractCsrFieldMatrix<?,?,?,T> b)
    Computes the element-wise difference of two matrices.

  • Uses of Field in org.flag4j.linalg.ops.dense_sparse.csr.real_field_ops

    Methods in org.flag4j.linalg.ops.dense_sparse.csr.real_field_ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrOps.add(CsrMatrix a, AbstractDenseFieldMatrix<?,?,T> b)
    Computes the element-wise sum of two matrices.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrOps.applyBinOpp(AbstractDenseFieldMatrix<?,?,T> src1, CsrMatrix src2, BiFunction<T,Double,T> opp)
    Applies the specified binary operator element-wise to the two matrices.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrOps.applyBinOpp(CsrMatrix src1, AbstractDenseFieldMatrix<?,?,T> src2, BiFunction<Double,T,T> opp, UnaryOperator<T> uOpp)
    Applies the specified binary operator element-wise to the two matrices.
    static <T extends Field<T>>
    AbstractCsrFieldMatrix<?,?,?,T>
    RealFieldDenseCsrOps.applyBinOppToSparse(AbstractDenseFieldMatrix<?,?,T> src1, CsrMatrix src2, BiFunction<T,Double,T> opp)
    Applies an element-wise binary operation to a real dense and real sparse CSR matrix under the assumption that opp.apply(x, 0d) = 0d and opp.apply(0d, x) = 0d.
    static <T extends Field<T>>
    AbstractCsrFieldMatrix<?,?,?,T>
    RealFieldDenseCsrOps.applyBinOppToSparse(Matrix src1, AbstractCsrFieldMatrix<?,?,?,T> src2, BiFunction<Double,T,T> opp)
    Applies an element-wise binary operation to a real dense and real sparse CSR matrix under the assumption that opp.apply(x, 0d) = 0d and opp.apply(0d, x) = 0d.
    static <T extends Field<T>>
    AbstractCsrFieldMatrix<?,?,?,T>
    RealFieldDenseCsrOps.applyBinOppToSparse(CsrMatrix src1, AbstractDenseFieldMatrix<?,?,T> src2, BiFunction<Double,T,T> opp)
    Applies an element-wise binary operation to a real sparse and complex dense CSR matrix under the assumption that opp.apply(0d, x) = 0d where x is a Complex128.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrMatMult.standard(AbstractCsrFieldMatrix<?,?,?,T> src1, Matrix src2)
    Computes the matrix multiplication between a complex sparse CSR matrix and a real dense matrix.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrMatMult.standard(AbstractDenseFieldMatrix<?,?,T> src1, CsrMatrix src2)
    Computes the matrix multiplication between a real dense matrix and a real sparse CSR matrix.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrMatMult.standard(Matrix src1, AbstractCsrFieldMatrix<?,?,?,T> src2)
    Computes the matrix multiplication between a real dense matrix and a real sparse CSR matrix.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrMatMult.standard(CsrMatrix src1, AbstractDenseFieldMatrix<?,?,T> src2)
    Computes the matrix multiplication between a real sparse CSR matrix and a complex dense matrix.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrMatMult.standardTranspose(CsrMatrix src1, AbstractDenseFieldMatrix<?,?,T> src2)
    Computes the matrix multiplication between a real sparse CSR matrix and the transpose of a complex dense matrix.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    RealFieldDenseCsrMatMult.standardVector(AbstractCsrFieldMatrix<?,?,?,T> src1, Vector src2)
    Computes the matrix-vector multiplication between a real sparse CSR matrix and a complex dense vector.
    static <T extends Field<T>>
    AbstractDenseFieldVector<?,?,T>
    RealFieldDenseCsrMatMult.standardVector(CsrMatrix src1, AbstractDenseFieldVector<?,?,T> src2)
    Computes the matrix-vector multiplication between a real sparse CSR matrix and a complex dense vector.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrOps.sub(AbstractDenseFieldMatrix<?,?,T> a, CsrMatrix b)
    Computes the element-wise difference of two matrices.
    static <T extends Field<T>>
    AbstractDenseFieldMatrix<?,?,T>
    RealFieldDenseCsrOps.sub(CsrMatrix a, AbstractDenseFieldMatrix<?,?,T> b)
    Computes the element-wise difference of two matrices.

  • Uses of Field in org.flag4j.linalg.ops.dense.field_ops

    Methods in org.flag4j.linalg.ops.dense.field_ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T
    DenseFieldDeterminant.det(AbstractDenseFieldMatrix<?,?,T> mat)
    Computes the determinant of a square matrix.
    static <T extends Field<T>>
    T
    DenseFieldDeterminant.det1(AbstractDenseFieldMatrix<?,?,T> mat)
    Explicitly computes the determinant of a 1x1 matrix.
    static <T extends Field<T>>
    T
    DenseFieldDeterminant.det2(AbstractDenseFieldMatrix<?,?,T> mat)
    Explicitly computes the determinant of a 2×2 matrix.
    static <T extends Field<T>>
    T
    DenseFieldDeterminant.det3(AbstractDenseFieldMatrix<?,?,T> mat)
    Explicitly computes the determinant of a 3x3 matrix.
    static <T extends Field<T>>
    T
    DenseFieldDeterminant.detLU(AbstractDenseFieldMatrix<?,?,T> mat)
    Computes the determinant of a square matrix using the LU factorization.
    static <T extends Field<T>>
    T
    DenseFieldDeterminant.detTri(AbstractDenseFieldMatrix<?,?,T> tri)
    Computes the determinant of a triangular matrix.
    static <T extends Field<T>>
    T
    DenseFieldDeterminant.detTriUnsafe(AbstractDenseFieldMatrix<?,?,T> tri)
    Computes the determinant of a triangular matrix.
    static <T extends Field<T>>
    void
    DenseFieldElemDiv.dispatch(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Dynamically chooses and applies element-wise division algorithm to use based on the number of data in the tensors.
    static <T extends Field<T>>
    void
    DenseFieldOps.div(Shape shape1, T[] src1, Shape shape2, T[] src2, T[] dest)
    Computes the element-wise division between two tensors.
    static <T extends Field<T>>
    T
    DenseFieldVectorOps.dotProduct(T[] src1, T[] src2)
    Computes the vector dot product for two vectors.
    static <T extends Field<T>>
    void
    DenseFieldElemDiv.elemDiv(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors.
    static <T extends Field<T>>
    void
    DenseFieldElemDiv.elemDivConcurrent(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    T
    DenseFieldVectorOps.innerProduct(T[] src1, T[] src2)
    Computes the vector inner product for two vectors.
    static <T extends Field<T>>
    void
    DenseFieldVectorOps.outerProduct(T[] src1, T[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors.
    static <T extends Field<T>>
    void
    DenseFieldVectorOps.outerProductConcurrent(T[] src1, T[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors using a concurrent implementation.
    Methods in org.flag4j.linalg.ops.dense.field_ops with parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    void
    DenseFieldElemDiv.dispatch(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Dynamically chooses and applies element-wise division algorithm to use based on the number of data in the tensors.
    static <T extends Field<T>>
    void
    DenseFieldOps.div(Shape shape1, T[] src1, Shape shape2, T[] src2, T[] dest)
    Computes the element-wise division between two tensors.
    static <T extends Field<T>>
    T
    DenseFieldVectorOps.dotProduct(T[] src1, T[] src2)
    Computes the vector dot product for two vectors.
    static <T extends Field<T>>
    void
    DenseFieldElemDiv.elemDiv(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors.
    static <T extends Field<T>>
    void
    DenseFieldElemDiv.elemDivConcurrent(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    T
    DenseFieldVectorOps.innerProduct(T[] src1, T[] src2)
    Computes the vector inner product for two vectors.
    static <T extends Field<T>>
    void
    DenseFieldVectorOps.outerProduct(T[] src1, T[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors.
    static <T extends Field<T>>
    void
    DenseFieldVectorOps.outerProductConcurrent(T[] src1, T[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors using a concurrent implementation.

  • Uses of Field in org.flag4j.linalg.ops.dense.real_field_ops

    Methods in org.flag4j.linalg.ops.dense.real_field_ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    void
    RealFieldDenseOps.add(double[] src, T a, T[] dest)
    Adds a scalar value to all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.add(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise addition of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.add(T[] src, double a, T[] dest)
    Adds a scalar value to all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseVectorOps.add(double[] src, T a, T[] dest)
    Adds a scalar value to all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blocked(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blocked(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedReordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedReordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlocked(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlocked(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedReordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedReordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentReordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentReordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandard(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandard(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandardVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandardVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.dispatch(Shape shape1, double[] src1, Shape shape2, T[] src2, T[] dest)
    Dynamically chooses and applies the appropriate algorithm for element-wise tensor multiplication.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.dispatch(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Dynamically chooses and applies the appropriate algorithm for element-wise tensor multiplication.
    static <T extends Field<T>>
    void
    RealFieldDenseElemMult.dispatch(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Dynamically chooses and applies element-wise multiplication algorithm to use based on the number of data in the tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDiv(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDiv(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.elemDiv(Shape shape1, double[] src1, Shape shape2, T[] src2, T[] dest)
    Computes the element-wise division between two dense tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.elemDiv(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise division between two dense tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDivConcurrent(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDivConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseElemMult.elemMult(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise multiplication of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.elemMult(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise multiplication between two dense tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemMult.elemMultConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise multiplication of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    T
    RealFieldDenseVectorOps.inner(double[] src1, T[] src2)
    Computes the vector inner product for a real dense vector and a complex dense vector.
    static <T extends Field<T>>
    T
    RealFieldDenseVectorOps.inner(T[] src1, double[] src2)
    Computes the vector inner product for a complex dense vector and a real dense vector.
    static <T extends Field<T>>
    boolean
    RealFieldDenseEquals.matrixEquals(Matrix A, AbstractDenseFieldMatrix<?,?,T> B)
    Checks if two real dense matrices are equal.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTranspose(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTranspose(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlocked(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlocked(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlockedConcurrent(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlockedConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeConcurrent(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseVectorOps.outerProduct(double[] src1, T[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors.
    static <T extends Field<T>>
    void
    RealFieldDenseVectorOps.outerProduct(T[] src1, double[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.reordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.reordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.scalDiv(double[] src, T divisor, T[] dest)
    Computes the scalar multiplication of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.scalDiv(T[] src, double divisor, T[] dest)
    Computes the scalar division of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standard(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standard(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standardVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standardVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(double[] src, T a, T[] dest)
    Subtracts a scalar value from all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(Shape shape1, double[] src1, Shape shape2, T[] src2, T[] dest)
    Computes the element-wise subtraction of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise subtraction of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(T[] src, double a, T[] dest)
    Subtracts a scalar value from all data of a tensor.
    static <T extends Field<T>>
    boolean
    RealFieldDenseEquals.tensorEquals(double[] src1, Shape shape1, T[] src2, Shape shape2)
    Checks if two dense tensors are equal.
    static <T extends Field<T>>
    boolean
    RealFieldDenseEquals.tensorEquals(Tensor A, AbstractDenseFieldTensor<?,T> B)
    Checks if two real dense tensors are equal.
    Methods in org.flag4j.linalg.ops.dense.real_field_ops with parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    void
    RealFieldDenseOps.add(double[] src, T a, T[] dest)
    Adds a scalar value to all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.add(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise addition of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.add(T[] src, double a, T[] dest)
    Adds a scalar value to all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseVectorOps.add(double[] src, T a, T[] dest)
    Adds a scalar value to all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blocked(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blocked(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedReordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedReordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.blockedVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlocked(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlocked(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedReordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedReordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of a blocked algorithm with the j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentBlockedVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentReordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentReordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandard(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandard(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication of a real dense matrix with a dense field matrix using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandardVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.concurrentStandardVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using a concurrent implementation of the standard matrix multiplication algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.dispatch(Shape shape1, double[] src1, Shape shape2, T[] src2, T[] dest)
    Dynamically chooses and applies the appropriate algorithm for element-wise tensor multiplication.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.dispatch(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Dynamically chooses and applies the appropriate algorithm for element-wise tensor multiplication.
    static <T extends Field<T>>
    void
    RealFieldDenseElemMult.dispatch(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Dynamically chooses and applies element-wise multiplication algorithm to use based on the number of data in the tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDiv(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDiv(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.elemDiv(Shape shape1, double[] src1, Shape shape2, T[] src2, T[] dest)
    Computes the element-wise division between two dense tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.elemDiv(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise division between two dense tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDivConcurrent(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseElemDiv.elemDivConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise division of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseElemMult.elemMult(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise multiplication of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.elemMult(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise multiplication between two dense tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseElemMult.elemMultConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the element-wise multiplication of two tensors using a concurrent algorithm.
    static <T extends Field<T>>
    T
    RealFieldDenseVectorOps.inner(double[] src1, T[] src2)
    Computes the vector inner product for a real dense vector and a complex dense vector.
    static <T extends Field<T>>
    T
    RealFieldDenseVectorOps.inner(T[] src1, double[] src2)
    Computes the vector inner product for a complex dense vector and a real dense vector.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTranspose(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTranspose(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlocked(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlocked(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlockedConcurrent(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeBlockedConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent implementation of a blocked algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeConcurrent(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMultTranspose.multTransposeConcurrent(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Multiplies a matrix to the transpose of a second matrix using a concurrent algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseVectorOps.outerProduct(double[] src1, T[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors.
    static <T extends Field<T>>
    void
    RealFieldDenseVectorOps.outerProduct(T[] src1, double[] src2, T[] dest)
    Computes the vector outer product between two real dense vectors.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.reordered(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.reordered(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm with j-k loops swapped.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.scalDiv(double[] src, T divisor, T[] dest)
    Computes the scalar multiplication of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.scalDiv(T[] src, double divisor, T[] dest)
    Computes the scalar division of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standard(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standard(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the matrix multiplication between a real dense matrix with a dense field matrix using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standardVector(double[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseMatMult.standardVector(T[] src1, Shape shape1, double[] src2, Shape shape2, T[] dest)
    Computes the multiplication of a real dense matrix with a dense field vector using the standard algorithm.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(double[] src, T a, T[] dest)
    Subtracts a scalar value from all data of a tensor.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(Shape shape1, double[] src1, Shape shape2, T[] src2, T[] dest)
    Computes the element-wise subtraction of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(Shape shape1, T[] src1, Shape shape2, double[] src2, T[] dest)
    Computes the element-wise subtraction of two tensors.
    static <T extends Field<T>>
    void
    RealFieldDenseOps.sub(T[] src, double a, T[] dest)
    Subtracts a scalar value from all data of a tensor.
    static <T extends Field<T>>
    boolean
    RealFieldDenseEquals.tensorEquals(double[] src1, Shape shape1, T[] src2, Shape shape2)
    Checks if two dense tensors are equal.

  • Uses of Field in org.flag4j.linalg.ops.sparse.csr

    Methods in org.flag4j.linalg.ops.sparse.csr with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    void
    CsrOps.hermTranspose(T[] srcEntries, int[] srcRowPointers, int[] srcColIndices, T[] destEntries, int[] destRowPointers, int[] destColIndices)
    Computes herniation transpose of complex CSR matrix.
    Methods in org.flag4j.linalg.ops.sparse.csr with parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    void
    CsrOps.hermTranspose(T[] srcEntries, int[] srcRowPointers, int[] srcColIndices, T[] destEntries, int[] destRowPointers, int[] destColIndices)
    Computes herniation transpose of complex CSR matrix.

  • Uses of Field in org.flag4j.numbers

    Classes in org.flag4j.numbers with type parameters of type Field
    Modifier and Type
    Interface
    Description
    interface 
    Field<T extends Field<T>>
    Defines a mathematical field structure and specifies the operations that field elements must support.
    Classes in org.flag4j.numbers that implement Field
    Modifier and Type
    Class
    Description
    class 
    Complex128
    Represents an immutable complex number with double-precision floating point components.
    class 
    Complex64
    Represents an immutable complex number with single-precision floating point components.
    class 
    RealFloat32
    Represents an immutable real number backed by a 32-bit floating-point value.
    class 
    RealFloat64
    Represents an immutable real number backed by a 64-bit floating-point value.

  • Uses of Field in org.flag4j.util

    Methods in org.flag4j.util with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    ArrayUtils.flatten(T[][] src)
    Flattens a two-dimensional array.
    Methods in org.flag4j.util that return Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    ArrayUtils.flatten(T[][] src)
    Flattens a two-dimensional array.
    Methods in org.flag4j.util with parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    ArrayUtils.flatten(T[][] src)
    Flattens a two-dimensional array.