org.ejml.sparse.csc.CommonOps_MT_FSCC Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of ejml-fsparse Show documentation
A fast and easy to use dense and sparse matrix linear algebra library written in Java.
The newest version!
/*
 * Copyright (c) 2022, Peter Abeles. All Rights Reserved.
 *
 * This file is part of Efficient Java Matrix Library (EJML).
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package org.ejml.sparse.csc;

import javax.annotation.Generated;
import org.ejml.MatrixDimensionException;
import org.ejml.data.FGrowArray;
import org.ejml.data.FMatrixRMaj;
import org.ejml.data.FMatrixSparseCSC;
import org.ejml.sparse.csc.misc.ImplCommonOps_MT_FSCC;
import org.ejml.sparse.csc.mult.ImplMultiplication_MT_FSCC;
import org.ejml.sparse.csc.mult.Workspace_MT_FSCC;
import org.jetbrains.annotations.Nullable;
import pabeles.concurrency.GrowArray;

import static org.ejml.UtilEjml.reshapeOrDeclare;
import static org.ejml.UtilEjml.stringShapes;

/**
 * Concurrent implementations of functions found in {@link CommonOps_FSCC}.
 *
 * @author Peter Abeles
 */
@Generated("org.ejml.sparse.csc.CommonOps_MT_DSCC")
public class CommonOps_MT_FSCC {
    private CommonOps_MT_FSCC(){}

    /**
     * Matrix multiplication C = A*B. Handles optional data structures requires by 
     * {@link #mult(FMatrixSparseCSC, FMatrixSparseCSC, FMatrixSparseCSC, GrowArray)}.
     *
     * @param A (Input) Sparse matrix. Not modified.
     * @param B (Input) Sparse matrix. Not modified.
     * @param outputC (Output) Storage for results. If null a new instance is returned.
     * @return Results of matrix multiplication, the 'C' matrix
     */
    public static FMatrixSparseCSC mult( FMatrixSparseCSC A, FMatrixSparseCSC B, @Nullable FMatrixSparseCSC outputC ) {
        return mult(A, B, outputC, null);
    }

    /**
     * Performs matrix multiplication. C = A*B. Concurrency workspace is about the same size as the resulting "output"
     * matrix.
     *
     * @param A (Input) Sparse matrix. Not modified.
     * @param B (Input) Sparse matrix. Not modified.
     * @param outputC (Output) Storage for results. If null a new instance is returned.
     * @param workspace (Optional) Storage for internal workspace. Can be null.
     * @return Results of matrix multiplication, the 'C' matrix
     */
    public static FMatrixSparseCSC mult( FMatrixSparseCSC A, FMatrixSparseCSC B, @Nullable FMatrixSparseCSC outputC,
                                         @Nullable GrowArray workspace ) {
        if (A.numCols != B.numRows)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        outputC = reshapeOrDeclare(outputC, A, A.numRows, B.numCols);

        if (workspace == null)
            workspace = new GrowArray<>(Workspace_MT_FSCC::new);

        ImplMultiplication_MT_FSCC.mult(A, B, outputC, workspace);

        return outputC;
    }

    /**
     * Performs matrix addition:

     *
     * C = αA + βB
     *
     * @param alpha (Input) scalar value multiplied against A
     * @param A (Input) Sparse matrix. Not modified.
     * @param beta (Input) scalar value multiplied against B
     * @param B (Input) Sparse matrix. Not modified.
     * @param outputC (Output) Dense Matrix. If null a new instance is returned.
     * @param workspace (Optional) Storage for internal workspace. Can be null.
     * @return Results of matrix multiplication, the 'C' matrix
     */
    public static FMatrixSparseCSC add( float alpha, FMatrixSparseCSC A, float beta, FMatrixSparseCSC B,
                                        @Nullable FMatrixSparseCSC outputC,
                                        @Nullable GrowArray workspace ) {
        if (A.numRows != B.numRows || A.numCols != B.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        outputC = reshapeOrDeclare(outputC, A, A.numRows, A.numCols);

        if (workspace == null)
            workspace = new GrowArray<>(Workspace_MT_FSCC::new);

        ImplCommonOps_MT_FSCC.add(alpha, A, beta, B, outputC, workspace);

        return outputC;
    }

    /**
     * Performs matrix multiplication. C = A^T*B
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix. If null a new instance is returned.
     * @param workspace (Optional) Storage for internal workspace. Can be null.
     * @return Results of matrix multiplication, the 'C' matrix
     */
    public static FMatrixRMaj mult( FMatrixSparseCSC A, FMatrixRMaj B, @Nullable FMatrixRMaj outputC,
                                    @Nullable GrowArray workspace ) {
        if (A.numCols != B.numRows)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        outputC = reshapeOrDeclare(outputC, A.numRows, B.numCols);
        if (workspace == null)
            workspace = new GrowArray<>(FGrowArray::new);

        ImplMultiplication_MT_FSCC.mult(A, B, outputC, workspace);

        return outputC;
    }

    /**
     * C = C + A^T*B
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix.
     */
    public static void multAdd( FMatrixSparseCSC A, FMatrixRMaj B, FMatrixRMaj outputC,
                                @Nullable GrowArray workspace ) {
        if (A.numCols != B.numRows)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        if (A.numRows != outputC.numRows || B.numCols != outputC.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B, outputC));

        if (workspace == null)
            workspace = new GrowArray<>(FGrowArray::new);

        ImplMultiplication_MT_FSCC.multAdd(A, B, outputC, workspace);
    }

    /**
     * Performs matrix multiplication. C = A^T*B
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix. If null a new instance is returned.
     * @param workspace (Optional) Storage for internal workspace. Can be null.
     * @return Results of matrix multiplication, the 'C' matrix
     */
    public static FMatrixRMaj multTransA( FMatrixSparseCSC A, FMatrixRMaj B, @Nullable FMatrixRMaj outputC,
                                          @Nullable GrowArray workspace ) {
        if (A.numRows != B.numRows)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));

        outputC = reshapeOrDeclare(outputC, A.numCols, B.numCols);

        if (workspace == null)
            workspace = new GrowArray<>(FGrowArray::new);

        ImplMultiplication_MT_FSCC.multTransA(A, B, outputC, workspace);

        return outputC;
    }

    /**
     * C = C + A^T*B
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix.
     * @param workspace (Optional) Storage for internal workspace. Can be null.
     */
    public static void multAddTransA( FMatrixSparseCSC A, FMatrixRMaj B, FMatrixRMaj outputC,
                                      @Nullable GrowArray workspace ) {
        if (A.numRows != B.numRows)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        if (A.numCols != outputC.numRows || B.numCols != outputC.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B, outputC));

        if (workspace == null)
            workspace = new GrowArray<>(FGrowArray::new);

        ImplMultiplication_MT_FSCC.multAddTransA(A, B, outputC, workspace);
    }

    /**
     * Performs matrix multiplication. C = A*B^T
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix. If null a new instance is returned.
     * @param workspace (Optional) Storage for internal workspace. Can be null.
     * @return Results of matrix multiplication, the 'C' matrix
     */
    public static FMatrixRMaj multTransB( FMatrixSparseCSC A, FMatrixRMaj B, @Nullable FMatrixRMaj outputC,
                                          @Nullable GrowArray workspace ) {
        if (A.numCols != B.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        outputC = reshapeOrDeclare(outputC, A.numRows, B.numRows);

        if (workspace == null)
            workspace = new GrowArray<>(FGrowArray::new);

        ImplMultiplication_MT_FSCC.multTransB(A, B, outputC, workspace);

        return outputC;
    }

    /**
     * C = C + A*B^T
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix.
     * @param workspace (Optional) Storage for internal workspace. Can be null.
     */
    public static void multAddTransB( FMatrixSparseCSC A, FMatrixRMaj B, FMatrixRMaj outputC,
                                      @Nullable GrowArray workspace ) {
        if (A.numCols != B.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        if (A.numRows != outputC.numRows || B.numRows != outputC.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B, outputC));

        if (workspace == null)
            workspace = new GrowArray<>(FGrowArray::new);

        ImplMultiplication_MT_FSCC.multAddTransB(A, B, outputC, workspace);
    }

    /**
     * Performs matrix multiplication. C = A^T*B^T
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix.
     * @return Results of matrix multiplication, the 'C' matrix
     */
    public static FMatrixRMaj multTransAB( FMatrixSparseCSC A, FMatrixRMaj B, FMatrixRMaj outputC ) {
        if (A.numRows != B.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        outputC = reshapeOrDeclare(outputC, A.numCols, B.numRows);

        ImplMultiplication_MT_FSCC.multTransAB(A, B, outputC);

        return outputC;
    }

    /**
     * C = C + A^T*B^T
     *
     * @param A (Input) Sparse Matrix. Not modified.
     * @param B (Input) Dense Matrix. Not modified.
     * @param outputC (Output) Dense Matrix.
     */
    public static void multAddTransAB( FMatrixSparseCSC A, FMatrixRMaj B, FMatrixRMaj outputC ) {
        if (A.numRows != B.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B));
        if (A.numCols != outputC.numRows || B.numRows != outputC.numCols)
            throw new MatrixDimensionException("Inconsistent matrix shapes. " + stringShapes(A, B, outputC));

        ImplMultiplication_MT_FSCC.multAddTransAB(A, B, outputC);
    }
}