Uses of Interface
org.flag4j.algebraic_structures.Field

Packages that use Field
Package
Description
org.flag4j.algebraic_structures
Provides algebraic structures such as semirings, rings, and fields, along with their concrete implementations.
org.flag4j.arrays
 
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
 
org.flag4j.linalg.ops
 
org.flag4j.linalg.ops.common.field_ops
 
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
 
org.flag4j.linalg.ops.dense.real_field_ops
 
org.flag4j.linalg.ops.sparse.csr
 
org.flag4j.util
 

  • Uses of Field in org.flag4j.algebraic_structures

    Classes in org.flag4j.algebraic_structures 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.algebraic_structures 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.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[] entries, int[] rowIndices, int[] colIndices)
    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
    AbstractCooFieldVector(Shape shape, Y[] data, int[] indices)
    Creates a tensor with the specified data and shape.
    protected
    AbstractCsrFieldMatrix(Shape shape, W[] entries, int[] rowPointers, int[] colIndices)
    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 parameters of type Field
    Modifier and Type
    Method
    Description
    CooFieldMatrix<T>
    CsrFieldMatrix.makeLikeCooMatrix(Shape shape, T[] entries, 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[] entries)
    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[] entries)
    Constructs a tensor of the same type as this tensor with the given the shape and data.
    CsrFieldMatrix<T>
    CsrFieldMatrix.makeLikeTensor(Shape shape, T[] entries, 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.
    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[] entries, 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>>
    This class provides methods for computing the LU decomposition of a dense matrix whose elements are members of a Field.

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

    Methods in org.flag4j.linalg.ops with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    MatrixMultiplyDispatcher.dispatch(FieldMatrix<T> A, FieldMatrix<T> B)
    Dispatches a matrix multiplication problem to the appropriate algorithm based on the size.
    static <T extends Field<T>>
    T[]
    MatrixMultiplyDispatcher.dispatch(FieldMatrix<T> A, FieldVector<T> b)
    Dynamically chooses the appropriate matrix-vector multiplication algorithm based on the shapes of the matrix and vector.
    static <T extends Field<T>>
    T[]
    MatrixMultiplyDispatcher.dispatch(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Dispatches a matrix multiplication problem to the appropriate algorithm based on the size.
    Methods in org.flag4j.linalg.ops that return Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    MatrixMultiplyDispatcher.dispatch(FieldMatrix<T> A, FieldMatrix<T> B)
    Dispatches a matrix multiplication problem to the appropriate algorithm based on the size.
    static <T extends Field<T>>
    T[]
    MatrixMultiplyDispatcher.dispatch(FieldMatrix<T> A, FieldVector<T> b)
    Dynamically chooses the appropriate matrix-vector multiplication algorithm based on the shapes of the matrix and vector.
    static <T extends Field<T>>
    T[]
    MatrixMultiplyDispatcher.dispatch(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Dispatches a matrix multiplication problem to the appropriate algorithm based on the size.
    Methods in org.flag4j.linalg.ops with parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    T[]
    MatrixMultiplyDispatcher.dispatch(T[] src1, Shape shape1, T[] src2, Shape shape2, T[] dest)
    Dispatches a matrix multiplication problem to the appropriate algorithm based on the size.

  • 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, Field<T> b)
    Subtracts a scalar from a sparse COO tensor.
    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(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 2x2 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.util

    Methods in org.flag4j.util with type parameters of type Field
    Modifier and Type
    Method
    Description
    static <T extends Field<T>>
    boolean
    ArrayUtils.equals(double[] src1, T[] src2)
    Checks if a double array is numerically equal to a complex number array.
    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>>
    boolean
    ArrayUtils.equals(double[] src1, T[] src2)
    Checks if a double array is numerically equal to a complex number array.
    static <T extends Field<T>>
    T[]
    ArrayUtils.flatten(T[][] src)
    Flattens a two-dimensional array.