dense_row.hpp

Go to the documentation of this file.

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