counts.hpp

Go to the documentation of this file.

#ifndef TATAMI_STATS_COUNTS_HPP
#define TATAMI_STATS_COUNTS_HPP
 
#include <vector>
#include <algorithm>
#include <cmath>
#include <type_traits>
 
#include "tatami/tatami.hpp"
#include "sanisizer/sanisizer.hpp"
 
namespace tatami_stats {
 
namespace counts {
 
template<typename Value_, typename Index_, typename Output_, class Condition_>
void apply(bool row, const tatami::Matrix<Value_, Index_>& mat, Output_* output, int num_threads, Condition_ condition) {
    const Index_ dim = (row ? mat.nrow() : mat.ncol());
    const Index_ otherdim = (row ? mat.ncol() : mat.nrow());
 
    if (mat.prefer_rows() == row) {
        if (mat.sparse()) {
            tatami::Options opt;
            opt.sparse_ordered_index = false;
            const bool count_zero = condition(0);
 
            tatami::parallelize([&](int, Index_ start, Index_ len) -> void {
                auto xbuffer = tatami::create_container_of_Index_size<std::vector<Value_> >(otherdim);
                auto ibuffer = tatami::create_container_of_Index_size<std::vector<Index_> >(otherdim);
                auto ext = tatami::consecutive_extractor<true>(mat, row, start, len, opt);
 
                for (Index_ x = 0; x < len; ++x) {
                    auto range = ext->fetch(xbuffer.data(), ibuffer.data());
                    Output_ target = 0;
                    for (Index_ j = 0; j < range.number; ++j) {
                        target += condition(range.value[j]);
                    }
                    if (count_zero) {
                        target += otherdim - range.number;
                    }
                    output[x + start] = target;
                }
            }, dim, num_threads);
 
        } else {
            tatami::parallelize([&](int, Index_ start, Index_ len) -> void {
                auto xbuffer = tatami::create_container_of_Index_size<std::vector<Value_> >(otherdim);
                auto ext = tatami::consecutive_extractor<false>(mat, row, start, len);
 
                for (Index_ x = 0; x < len; ++x) {
                    auto ptr = ext->fetch(xbuffer.data());
                    Output_ target = 0;
                    for (Index_ j = 0; j < otherdim; ++j) {
                        target += condition(ptr[j]);
                    }
                    output[x + start] = target;
                }
            }, dim, num_threads);
        }
 
    } else {
        // Directly write the result to the output buffer for the first thread, everything else goes into these temporary vectors.
        auto threaded_output = sanisizer::create<std::vector<std::optional<std::vector<Output_> > > >(num_threads <= 1 ? 0 : num_threads - 1);
        const auto get_output_ptr = [&](const int thread, std::optional<std::vector<Output_> >& tmp_output) -> Output_* {
            if (thread) {
                tmp_output.emplace(tatami::cast_Index_to_container_size<std::vector<Output_> >(dim));
                return tmp_output->data();
            } else {
                return output;
            }
        };
        const auto save_output = [&](const int thread, std::optional<std::vector<Output_> >& tmp_output) -> void {
            if (thread) {
                threaded_output[thread - 1] = std::move(tmp_output);
            }
        };
 
        int num_used;
        if (mat.sparse()) {
            tatami::Options opt;
            opt.sparse_ordered_index = false;
            bool count_zero = condition(0);
 
            num_used = tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                std::optional<std::vector<Output_> > tmp_output;
                auto curoutput = get_output_ptr(thread, tmp_output);
 
                auto xbuffer = tatami::create_container_of_Index_size<std::vector<Value_> >(dim);
                auto ibuffer = tatami::create_container_of_Index_size<std::vector<Index_> >(dim);
                auto ext = tatami::consecutive_extractor<true>(mat, !row, start, len, opt);
                auto nonzeros = tatami::create_container_of_Index_size<std::vector<Index_> >(dim);
 
                for (Index_ x = 0; x < len; ++x) {
                    auto range = ext->fetch(xbuffer.data(), ibuffer.data());
                    for (Index_ j = 0; j < range.number; ++j) {
                        auto idx = range.index[j];
                        curoutput[idx] += condition(range.value[j]);
                        ++(nonzeros[idx]);
                    }
                }
 
                if (count_zero) {
                    for (Index_ d = 0; d < dim; ++d) {
                        curoutput[d] += len - nonzeros[d];
                    }
                }
 
                save_output(thread, tmp_output);
            }, otherdim, num_threads);
 
        } else {
            num_used = tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                std::optional<std::vector<Output_> > tmp_output;
                auto curoutput = get_output_ptr(thread, tmp_output);
 
                auto xbuffer = tatami::create_container_of_Index_size<std::vector<Value_> >(dim);
                auto ext = tatami::consecutive_extractor<false>(mat, !row, start, len);
 
                for (Index_ x = 0; x < len; ++x) {
                    auto ptr = ext->fetch(xbuffer.data());
                    for (Index_ j = 0; j < dim; ++j) {
                        curoutput[j] += condition(ptr[j]);
                    }
                }
 
                save_output(thread, tmp_output);
            }, otherdim, num_threads);
        }
 
        if (num_used == 0) {
            // Make sure we reset it if no workers were run.
            std::fill(output, output + dim, 0);
        } else {
            for (int thread = 1; thread < num_used; ++thread) {
                const auto& curout = *(threaded_output[thread - 1]);
                for (Index_ d = 0; d < dim; ++d) {
                    output[d] += curout[d];
                }
            }
        }
    }
}
 
// Back-compatibility only.
template<typename Value_, typename Index_, typename Output_, class Condition_>
void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, int num_threads, Condition_ condition) {
    apply(row, *p, output, num_threads, std::move(condition));
}
namespace nan {
 
struct Options {
    int num_threads = 1;
 
};
 
template<typename Value_, typename Index_, typename Output_>
void apply(bool row, const tatami::Matrix<Value_, Index_>& mat, Output_* output, const Options& nopt) {
    counts::apply(row, mat, output, nopt.num_threads, [](Value_ x) -> bool { return std::isnan(x); });
}
 
// Back-compatibility only.
template<typename Value_, typename Index_, typename Output_>
void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, const Options& nopt) {
    apply(row, *p, output, nopt);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>& mat, const Options& nopt) {
    auto output = tatami::create_container_of_Index_size<std::vector<Output_> >(mat.nrow());
    apply(true, mat, output.data(), nopt);
    return output;
}
 
// Back-compatibility only.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p, const Options& nopt) {
    return by_row<Output_>(*p, nopt);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>& mat) {
    return by_row<Output_>(mat, Options());
}
 
// Back-compatibility only.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p) {
    return by_row<Output_>(*p);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>& mat, const Options& nopt) {
    auto output = tatami::create_container_of_Index_size<std::vector<Output_> >(mat.ncol());
    apply(false, mat, output.data(), nopt);
    return output;
}
 
// Back-compatibility only.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p, const Options& nopt) {
    return by_column<Output_>(*p, nopt);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>& mat) {
    return by_column<Output_>(mat, Options());
}
 
// Back-compatibility only.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p) {
    return by_column<Output_>(*p);
}
}
 
namespace zero {
 
struct Options {
    int num_threads = 1;
};
 
template<typename Value_, typename Index_, typename Output_>
void apply(bool row, const tatami::Matrix<Value_, Index_>& mat, Output_* output, const Options& zopt) {
    counts::apply(row, mat, output, zopt.num_threads, [](Value_ x) -> bool { return x == 0; });
}
 
// Back-compatibility.
template<typename Value_, typename Index_, typename Output_>
void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, const Options& zopt) {
    apply(row, *p, output, zopt);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>& mat, const Options& zopt) {
    auto output = tatami::create_container_of_Index_size<std::vector<Output_> >(mat.nrow());
    apply(true, mat, output.data(), zopt);
    return output;
}
 
// Back-compatibility.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p, const Options& zopt) {
    return by_row<Output_>(*p, zopt);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>& mat) {
    return by_row<Output_>(mat, Options());
}
 
// Back-compatibility.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p) {
    return by_row<Output_>(*p);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>& mat, const Options& zopt) {
    auto output = tatami::create_container_of_Index_size<std::vector<Output_> >(mat.ncol());
    apply(false, mat, output.data(), zopt);
    return output;
}
 
// Back-compatibility.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p, const Options& zopt) {
    return by_column<Output_>(*p, zopt);
}
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>& mat) {
    return by_column<Output_>(mat, Options());
}
 
// Back-compatibility.
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p) {
    return by_column<Output_>(*p);
}
}
 
}
 
}
 
#endif