blocking.hpp

Go to the documentation of this file.

#ifndef SCRAN_UTILS_BLOCKING_HPP
#define SCRAN_UTILS_BLOCKING_HPP
 
#include "macros.hpp"
 
#include <vector>
#include <algorithm>
#include <stdexcept>
 
namespace scran {
 
template<typename Id_>
size_t count_ids(size_t length, const Id_* ids) {
    if (!length) {
        return 0;
    } else {
        return static_cast<size_t>(*std::max_element(ids, ids + length)) + 1;
    }
}
 
template<typename Output_ = int, bool allow_zeros_ = false, typename Id_> 
std::vector<Output_> tabulate_ids(size_t length, const Id_* ids, bool allow_zeros = false) {
    size_t nids = count_ids(length, ids);
 
    std::vector<Output_> ids_size(nids);
    for (size_t j = 0; j < length; ++j) {
        ++ids_size[ids[j]];
    }
 
    if (!allow_zeros) {
        for (auto b : ids_size) {
            if (b == 0) {
                throw std::runtime_error("IDs must be 0-based and consecutive with no empty blocks");
            }
        }
    }
 
    return ids_size;
}
 
enum class WeightPolicy : char { NONE, VARIABLE, EQUAL };
 
struct VariableBlockWeightParameters {
    constexpr VariableBlockWeightParameters(double l = 0, double u = 1000) : upper_bound(u), lower_bound(l) {}
 
    double lower_bound;
 
    double upper_bound;
};
 
inline double variable_block_weight(double s, const VariableBlockWeightParameters& params) {
    if (s < params.lower_bound || s == 0) {
        return 0;
    }
 
    if (s > params.upper_bound) {
        return 1;
    }
 
    return (s - params.lower_bound) / (params.upper_bound - params.lower_bound);
}
 
template<typename Size_>
std::vector<double> compute_block_weights(const std::vector<Size_>& sizes, WeightPolicy policy, const VariableBlockWeightParameters& param) {
    size_t nblocks = sizes.size();
    std::vector<double> weights;
    weights.reserve(nblocks);
 
    if (policy == WeightPolicy::NONE) {
        weights.insert(weights.end(), sizes.begin(), sizes.end());
    } else if (policy == WeightPolicy::EQUAL) {
        for (auto s : sizes) {
            weights.push_back(s > 0);
        }
    } else {
        for (auto s : sizes) {
            weights.push_back(variable_block_weight(s, param));
        }
    }
 
    return weights;
}
 
}
 
#endif