dispatch.hpp

Go to the documentation of this file.

#ifndef TATAMI_MULT_MULTIPLE_VECTORS_DISPATCH_HPP
#define TATAMI_MULT_MULTIPLE_VECTORS_DISPATCH_HPP
 
#include "dense_row.hpp"
#include "dense_column.hpp"
#include "sparse_row.hpp"
#include "sparse_column.hpp"
 
namespace tatami_mult {
 
struct MultiplyWithMultipleVectorsOptions {
    MultiplyDenseRowWithMultipleVectorsOptions dense_row;
 
    MultiplyDenseColumnWithMultipleVectorsOptions dense_column;
 
    MultiplySparseRowWithMultipleVectorsOptions sparse_row;
 
    MultiplySparseColumnWithMultipleVectorsOptions sparse_column;
};
 
inline void set_num_threads(MultiplyWithMultipleVectorsOptions& options, int num_threads) {
    options.dense_row.num_threads = num_threads;
    options.dense_column.num_threads = num_threads;
    options.sparse_row.num_threads = num_threads;
    options.sparse_column.num_threads = num_threads;
}
 
inline void set_dense_primary_block_size(MultiplyWithMultipleVectorsOptions& options, int primary_block_size) {
    options.dense_row.primary_block_size = primary_block_size;
    options.dense_column.primary_block_size = primary_block_size;
}
 
inline void set_dense_secondary_block_size(MultiplyWithMultipleVectorsOptions& options, int secondary_block_size) {
    options.dense_row.secondary_block_size = secondary_block_size;
    options.dense_column.secondary_block_size = secondary_block_size;
}
 
inline void set_sparse_block_size(MultiplyWithMultipleVectorsOptions& options, int block_size) {
    options.sparse_row.block_size = block_size;
    options.sparse_column.block_size = block_size;
}
 
template<std::size_t accumulators_ = 4, typename Value_, typename Index_, typename Right_, typename Output_>
void multiply_with_multiple_vectors(
    const tatami::Matrix<Value_, Index_>& left,
    const std::vector<Right_*>& right,
    const std::vector<Output_*>& output,
    const MultiplyWithMultipleVectorsOptions& options
) {
    if (left.is_sparse()) {
        if (left.prefer_rows()) {
            multiply_sparse_row_with_multiple_vectors<accumulators_>(left, right, output, options.sparse_row);
        } else {
            multiply_sparse_column_with_multiple_vectors(left, right, output, options.sparse_column);
        }
    } else {
        if (left.prefer_rows()) {
            multiply_dense_row_with_multiple_vectors<accumulators_>(left, right, output, options.dense_row);
        } else {
            multiply_dense_column_with_multiple_vectors(left, right, output, options.dense_column);
        }
    }
}
 
template<std::size_t accumulators_ = 4, typename Left_, typename Value_, typename Index_, typename Output_>
void multiply_with_multiple_vectors(
    const std::vector<Left_*>& left,
    const tatami::Matrix<Value_, Index_>& right,
    const std::vector<Output_*>& output,
    const MultiplyWithMultipleVectorsOptions& options
) {
    auto tright = tatami::make_DelayedTranspose(tatami::wrap_shared_ptr(&right));
    multiply_with_multiple_vectors<accumulators_>(*tright, left, output, options);
}
 
}
 
#endif