tatami_mult.hpp

Go to the documentation of this file.

#ifndef TATAMI_MULT_HPP
#define TATAMI_MULT_HPP
 
#include "single_vector/dispatch.hpp"
#include "multiple_vectors/dispatch.hpp"
#include "dense_matrix/dispatch.hpp"
#include "sparse_matrix/dispatch.hpp"
 
#include <vector>
 
#include "tatami/tatami.hpp"
#include "sanisizer/sanisizer.hpp"
 
namespace tatami_mult {
 
struct MultiplyWithMatrixOptions {
    MultiplyWithDenseMatrixOptions dense_matrix;
 
    MultiplyWithSparseMatrixOptions sparse_matrix;
 
    bool larger_left = true;
};
 
inline void set_num_threads(MultiplyWithMatrixOptions& options, int num_threads) {
    set_num_threads(options.dense_matrix, num_threads);
    set_num_threads(options.sparse_matrix, num_threads);
}
 
inline void set_dense_primary_block_size(MultiplyWithMatrixOptions& options, int primary_block_size) {
    set_dense_primary_block_size(options.dense_matrix, primary_block_size);
}
 
inline void set_dense_secondary_block_size(MultiplyWithMatrixOptions& options, int secondary_block_size) {
    set_dense_secondary_block_size(options.dense_matrix, secondary_block_size);
}
 
inline void set_sparse_block_size(MultiplyWithMatrixOptions& options, int block_size) {
    set_sparse_block_size(options.dense_matrix, block_size);
    set_sparse_block_size(options.sparse_matrix, block_size);
}
 
template<typename LeftValue_, typename LeftIndex_, typename RightValue_, typename RightIndex_, typename Output_>
void multiply_with_matrix(
    const tatami::Matrix<LeftValue_, LeftIndex_>& left,
    const tatami::Matrix<RightValue_, RightIndex_>& right,
    Output_* const output,
    const bool output_row_major,
    const MultiplyWithMatrixOptions& options
) {
    if (options.larger_left) {
        if (sanisizer::is_less_than(left.nrow(), right.ncol())) {
            auto tright = tatami::make_DelayedTranspose(tatami::wrap_shared_ptr(&right));
            auto tleft = tatami::make_DelayedTranspose(tatami::wrap_shared_ptr(&left));
            if (tleft->is_sparse()) {
                multiply_with_sparse_matrix(*tright, *tleft, output, !output_row_major, options.sparse_matrix);
            } else {
                multiply_with_dense_matrix(*tright, *tleft, output, !output_row_major, options.dense_matrix);
            }
            return;
        }
    }
 
    if (right.is_sparse()) {
        multiply_with_sparse_matrix(left, right, output, output_row_major, options.sparse_matrix);
    } else {
        multiply_with_dense_matrix(left, right, output, output_row_major, options.dense_matrix);
    }
}
 
// For back-compatibility only.
struct Options {
    int num_threads = 1;
    bool prefer_larger = true;
    bool column_major_output = true;
};
 
// For back-compatibility only.
template<typename Value_, typename Index_, typename Right_, typename Output_>
void multiply(const tatami::Matrix<Value_, Index_>& left, const Right_* right, Output_* output, const Options& opt) {
    multiply_with_single_vector(
        left,
        right,
        output,
        [&](){
            MultiplyWithSingleVectorOptions mopt;
            set_num_threads(mopt, opt.num_threads);
            return mopt;
        }()
    );
}
 
// For back-compatibility only.
template<typename Left_, typename Value_, typename Index_, typename Output_>
void multiply(const Left_* left, const tatami::Matrix<Value_, Index_>& right, Output_* output, const Options& opt) {
    multiply_with_single_vector(
        left,
        right,
        output,
        [&](){
            MultiplyWithSingleVectorOptions mopt;
            set_num_threads(mopt, opt.num_threads);
            return mopt;
        }()
    );
}
 
// For back-compatibility only.
template<typename Value_, typename Index_, typename Right_, typename Output_>
void multiply(const tatami::Matrix<Value_, Index_>& left, const std::vector<Right_*>& right, const std::vector<Output_*>& output, const Options& opt) {
    multiply_with_multiple_vectors(
        left,
        right,
        output,
        [&](){
            MultiplyWithMultipleVectorsOptions mopt;
            set_num_threads(mopt, opt.num_threads);
            return mopt;
        }()
    );
}
 
// For back-compatibility only.
template<typename Left_, typename Value_, typename Index_, typename Output_>
void multiply(const std::vector<Left_*>& left, const tatami::Matrix<Value_, Index_>& right, const std::vector<Output_*>& output, const Options& opt) {
    multiply_with_multiple_vectors(
        left,
        right,
        output,
        [&](){
            MultiplyWithMultipleVectorsOptions mopt;
            set_num_threads(mopt, opt.num_threads);
            return mopt;
        }()
    );
}
 
// For back-compatibility only.
template<typename LeftValue_, typename LeftIndex_, typename RightValue_, typename RightIndex_, typename Output_>
void multiply(const tatami::Matrix<LeftValue_, LeftIndex_>& left, const tatami::Matrix<RightValue_, RightIndex_>& right, Output_* const output, const Options& opt) {
    multiply_with_matrix(
        left,
        right,
        output,
        !opt.column_major_output,
        [&](){
            MultiplyWithMatrixOptions mopt;
            set_num_threads(mopt, opt.num_threads);
            mopt.larger_left = opt.prefer_larger;
            return mopt;
        }()
    );
}
}
 
#endif