choose.hpp

Go to the documentation of this file.

#ifndef SINGLER_CLASSIC_MARKERS_CHOOSE_HPP
#define SINGLER_CLASSIC_MARKERS_CHOOSE_HPP
 
#include <cstddef>
#include <optional>
#include <vector>
 
#include "sanisizer/sanisizer.hpp"
#include "tatami/tatami.hpp"
#include "tatami_stats/tatami_stats.hpp"
 
#include "queue.hpp"
#include "scan.hpp"
#include "number.hpp"
 
namespace singler_classic_markers {
 
struct ChooseOptions {
    std::optional<std::size_t> number;
 
    bool keep_ties = false;
 
    int num_threads = 1;
};
 
template<bool include_stat_, typename Stat_, typename Value_, typename Index_, typename Label_>
Markers<include_stat_, Index_, Stat_> choose_raw(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const Label_* label,
    const ChooseOptions& options
) {
    const auto NC = matrix.ncol();
    auto group_sizes = tatami_stats::tabulate_groups(label, NC);
    const auto ngroups = group_sizes.size();
 
    const auto num_keep = get_num_keep<Index_>(ngroups, options.number);
    auto pqueues = sanisizer::create<std::vector<std::optional<PairwiseTopQueues<Stat_, Index_> > > >(options.num_threads);
 
    const auto num_used = scan_matrix<Stat_>(
        matrix,
        sanisizer::cast<std::size_t>(ngroups),
        label,
        group_sizes,
 
        /* setup = */ [&]() -> PairwiseTopQueues<Stat_, Index_> {
            PairwiseTopQueues<Stat_, Index_> output;
            allocate_pairwise_queues(output, num_keep, ngroups, options.keep_ties, /* check_nan = */ true);
            return output;
        },
 
        /* fun = */ [&](const Index_ r, const std::vector<Stat_>& medians, PairwiseTopQueues<Stat_, Index_>& curqueues) -> void {
            for (I<decltype(ngroups)> g1 = 1; g1 < ngroups; ++g1) {
                for (I<decltype(ngroups)> g2 = 0; g2 < g1; ++g2) {
                    const auto delta = medians[g1] - medians[g2];
                    curqueues[g1][g2].emplace(delta, r); 
                    curqueues[g2][g1].emplace(-delta, r); 
                }
            }
        },
 
        /* finalize = */ [&](const int t, PairwiseTopQueues<Stat_, Index_>& curqueues) -> void {
            pqueues[t] = std::move(curqueues);
        },
 
        options.num_threads
    );
 
    pqueues.resize(num_used); 
    Markers<include_stat_, Index_, Stat_> output;
    report_best_top_queues<include_stat_>(pqueues, ngroups, output);
    return output;
}
template<typename Stat_ = double, typename Value_, typename Index_, typename Label_>
std::vector<std::vector<std::vector<std::pair<Index_, Stat_> > > > choose(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const Label_* label,
    const ChooseOptions& options
) {
    return choose_raw<true, Stat_>(matrix, label, options);
}
 
template<typename Stat_ = double, typename Value_, typename Index_, typename Label_>
std::vector<std::vector<std::vector<Index_> > > choose_index(
    const tatami::Matrix<Value_, Index_>& matrix, 
    const Label_* label,
    const ChooseOptions& options
) {
    return choose_raw<false, Stat_>(matrix, label, options);
}
 
}
 
#endif