counts.hpp

Go to the documentation of this file.

#ifndef TATAMI_STATS_COUNTS_HPP
#define TATAMI_STATS_COUNTS_HPP
 
#include "tatami/tatami.hpp"
#include "subpar/subpar.hpp"
 
#include <vector>
#include <algorithm>
#include <cmath>
#include <type_traits>
 
namespace tatami_stats {
 
namespace counts {
 
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) {
    auto dim = (row ? p->nrow() : p->ncol());
    auto otherdim = (row ? p->ncol() : p->nrow());
    std::fill(output, output + dim, 0);
 
    if (p->prefer_rows() == row) {
        if (p->sparse()) {
            tatami::Options opt;
            opt.sparse_ordered_index = false;
            bool count_zero = condition(0);
 
            tatami::parallelize([&](int, Index_ start, Index_ len) -> void {
                std::vector<Value_> xbuffer(otherdim);
                std::vector<Index_> ibuffer(otherdim);
                auto ext = tatami::consecutive_extractor<true>(p, 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 {
                std::vector<Value_> xbuffer(otherdim);
                auto ext = tatami::consecutive_extractor<false>(p, 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 {
        num_threads = subpar::sanitize_num_workers(num_threads, otherdim); // provides some protection against silly num_threads iputs.
        std::vector<Output_*> threaded_output_ptrs(num_threads, output);
        std::vector<std::vector<Output_> > threaded_output;
        if (num_threads > 1) {
            threaded_output.resize(num_threads - 1);
            for (int t = 1; t < num_threads; ++t) {
                auto& curout = threaded_output[t - 1];
                curout.resize(dim);
                threaded_output_ptrs[t] = curout.data();
            }
        }
 
        if (p->sparse()) {
            tatami::Options opt;
            opt.sparse_ordered_index = false;
            bool count_zero = condition(0);
 
            tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                std::vector<Value_> xbuffer(dim);
                std::vector<Index_> ibuffer(dim);
                auto ext = tatami::consecutive_extractor<true>(p, !row, start, len, opt);
 
                auto curoutput = threaded_output_ptrs[thread];
                std::vector<Index_> nonzeros(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 (int d = 0; d < dim; ++d) {
                        curoutput[d] += len - nonzeros[d];
                    }
                }
            }, otherdim, num_threads);
 
        } else {
            tatami::parallelize([&](int thread, Index_ start, Index_ len) -> void {
                std::vector<Value_> xbuffer(dim);
                auto ext = tatami::consecutive_extractor<false>(p, !row, start, len);
                auto curoutput = threaded_output_ptrs[thread];
 
                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]);
                    }
                }
            }, otherdim, num_threads);
        }
 
        for (int t = 1; t < num_threads; ++t) {
            auto curoutput = threaded_output_ptrs[t];
            for (Index_ d = 0; d < dim; ++d) {
                output[d] += curoutput[d];
            }
        }
    }
}
 
namespace nan {
 
struct Options {
    int num_threads = 1;
};
 
template<typename Value_, typename Index_, typename Output_>
void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, const Options& nopt) {
    counts::apply(row, p, output, nopt.num_threads, [](Value_ x) -> bool { return std::isnan(x); });
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p, const Options& nopt) {
    std::vector<Output_> output(p->nrow());
    apply(true, p, output.data(), nopt);
    return output;
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p) {
    return by_row(p, Options());
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p, const Options& nopt) {
    std::vector<Output_> output(p->ncol());
    apply(false, p, output.data(), nopt);
    return output;
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p) {
    return by_column(p, Options());
}
 
}
 
namespace zero {
 
struct Options {
    int num_threads = 1;
};
 
template<typename Value_, typename Index_, typename Output_>
void apply(bool row, const tatami::Matrix<Value_, Index_>* p, Output_* output, const Options& zopt) {
    counts::apply(row, p, output, zopt.num_threads, [](Value_ x) -> bool { return x == 0; });
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p, const Options& zopt) {
    std::vector<Output_> output(p->nrow());
    apply(true, p, output.data(), zopt);
    return output;
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_row(const tatami::Matrix<Value_, Index_>* p) {
    return by_row(p, Options());
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p, const Options& zopt) {
    std::vector<Output_> output(p->ncol());
    apply(false, p, output.data(), zopt);
    return output;
}
 
template<typename Output_ = int, typename Value_, typename Index_>
std::vector<Output_> by_column(const tatami::Matrix<Value_, Index_>* p) {
    return by_column(p, Options());
}
 
}
 
}
 
}
 
#endif