dispatch.hpp

Go to the documentation of this file.

#ifndef TATAMI_MULT_DENSE_MATRIX_DISPATCH_HPP
#define TATAMI_MULT_DENSE_MATRIX_DISPATCH_HPP
 
#include "dense_row/dispatch.hpp"
#include "dense_column/dispatch.hpp"
#include "sparse_row/dispatch.hpp"
#include "sparse_column/dispatch.hpp"
 
namespace tatami_mult {
 
struct MultiplyWithDenseMatrixOptions {
    MultiplyDenseRowWithDenseMatrixOptions dense_row;
 
    MultiplyDenseColumnWithDenseMatrixOptions dense_column;
 
    MultiplySparseRowWithDenseMatrixOptions sparse_row;
 
    MultiplySparseColumnWithDenseMatrixOptions sparse_column;
};
 
inline void set_num_threads(MultiplyWithDenseMatrixOptions& options, int num_threads) {
    set_num_threads(options.dense_row, num_threads);
    set_num_threads(options.dense_column, num_threads);
    set_num_threads(options.sparse_row, num_threads);
    set_num_threads(options.sparse_column, num_threads);
}
 
inline void set_dense_primary_block_size(MultiplyWithDenseMatrixOptions& options, int primary_block_size) {
    set_dense_primary_block_size(options.dense_row, primary_block_size);
    set_dense_primary_block_size(options.dense_column, primary_block_size);
}
 
inline void set_dense_secondary_block_size(MultiplyWithDenseMatrixOptions& options, int secondary_block_size) {
    set_dense_secondary_block_size(options.dense_row, secondary_block_size);
    set_dense_secondary_block_size(options.dense_column, secondary_block_size);
}
 
inline void set_sparse_block_size(MultiplyWithDenseMatrixOptions& options, int block_size) {
    set_sparse_block_size(options.sparse_row, block_size);
    set_sparse_block_size(options.sparse_column, block_size);
}
 
template<std::size_t accumulators_ = 4, typename LeftValue_, typename LeftIndex_, typename RightValue_, typename RightIndex_, typename Output_>
void multiply_with_dense_matrix(
    const tatami::Matrix<LeftValue_, LeftIndex_>& left,
    const tatami::Matrix<RightValue_, RightIndex_>& right,
    Output_* const output,
    const bool output_row_major,
    const MultiplyWithDenseMatrixOptions& options
) {
    if (left.is_sparse()) {
        if (left.prefer_rows()) {
            multiply_sparse_row_with_dense_matrix<accumulators_>(left, right, output, output_row_major, options.sparse_row);
        } else {
            multiply_sparse_column_with_dense_matrix(left, right, output, output_row_major, options.sparse_column);
        }
    } else {
        if (left.prefer_rows()) {
            multiply_dense_row_with_dense_matrix<accumulators_>(left, right, output, output_row_major, options.dense_row);
        } else {
            multiply_dense_column_with_dense_matrix(left, right, output, output_row_major, options.dense_column);
        }
    }
}
 
}
 
#endif