sparse_row.hpp

Go to the documentation of this file.

#ifndef TATAMI_MULT_SINGLE_VECTOR_SPARSE_ROW_HPP
#define TATAMI_MULT_SINGLE_VECTOR_SPARSE_ROW_HPP
 
#include <cstddef>
#include <vector>
 
#include "tatami/tatami.hpp"
 
#include "../sparse_dot_product.hpp"
 
namespace tatami_mult {
 
/* See https://github.com/tatami-inc/test-multiplication/tree/master/sparse_row/single_vector
 * for an explanation of the choice of algorithm.
 */
 
struct MultiplySparseRowWithSingleVectorOptions {
    int num_threads = 1;
};
 
template<std::size_t accumulators_ = 4, typename LeftValue_, typename LeftIndex_, typename RightValue_, typename Output_>
void multiply_sparse_row_with_single_vector(
    const tatami::Matrix<LeftValue_, LeftIndex_>& left,
    const RightValue_* const right,
    Output_* const output,
    const MultiplySparseRowWithSingleVectorOptions& options
) {
    const auto NR = left.nrow();
    const auto NC = left.ncol();
    tatami::parallelize([&](int, LeftIndex_ start, LeftIndex_ length) -> void {
        auto ext = tatami::consecutive_extractor<true>(left, true, start, length);
        auto vbuffer = tatami::create_container_of_Index_size<std::vector<LeftValue_> >(NC);
        auto ibuffer = tatami::create_container_of_Index_size<std::vector<LeftIndex_> >(NC);
        for (LeftIndex_ r = start, end = start + length; r < end; ++r) {
            auto range = ext->fetch(vbuffer.data(), ibuffer.data());
            output[r] = sparse_dot_product<accumulators_>(
                range.number, // tatami guarantees that range.number will fit in a std::size_t, so no need to protect the function call.
                range.value,
                range.index,
                right,
                static_cast<Output_>(0)
            );
        }
    }, NR, options.num_threads);
}
 
}
 
#endif