block_weights.hpp

Go to the documentation of this file.

#ifndef SCRAN_BLOCKS_BLOCK_WEIGHTS_HPP
#define SCRAN_BLOCKS_BLOCK_WEIGHTS_HPP
 
#include <vector>
#include <cstddef>
#include <algorithm>
#include <cassert>
 
#include "sanisizer/sanisizer.hpp"
 
#include "utils.hpp"
 
namespace scran_blocks {
 
enum class WeightPolicy : char { NONE, SIZE, VARIABLE, EQUAL };
 
struct VariableWeightParameters {
    double lower_bound = 0;
 
    double upper_bound = 1000;
};
 
inline double compute_variable_weight(const double s, const VariableWeightParameters& params) {
    assert(params.lower_bound >= 0);
    assert(params.upper_bound >= params.lower_bound);
    if (s <= params.lower_bound) {
        return 0;
    }
    if (s >= params.upper_bound) {
        return 1;
    }
    return (s - params.lower_bound) / (params.upper_bound - params.lower_bound);
}
 
template<typename GetBlockSize_, typename SetBlockWeight_>
void compute_weights(
    const std::size_t num_blocks,
    GetBlockSize_ get_block_size,
    const WeightPolicy policy,
    const VariableWeightParameters& variable,
    SetBlockWeight_ set_block_weight
) {
    if (policy == WeightPolicy::NONE || policy == WeightPolicy::SIZE) {
        for (I<decltype(num_blocks)> s = 0; s < num_blocks; ++s) {
            set_block_weight(s, get_block_size(s));
        }
 
    } else if (policy == WeightPolicy::EQUAL) {
        for (I<decltype(num_blocks)> s = 0; s < num_blocks; ++s) {
            set_block_weight(s, get_block_size(s) > 0);
        }
 
    } else {
        for (I<decltype(num_blocks)> s = 0; s < num_blocks; ++s) {
            set_block_weight(s, compute_variable_weight(get_block_size(s), variable));
        }
    }
}
 
template<typename Size_, typename Weight_>
void compute_weights(const std::size_t num_blocks, const Size_* const sizes, const WeightPolicy policy, const VariableWeightParameters& variable, Weight_* const weights) {
    compute_weights(
        num_blocks,
        [&](std::size_t s) -> Size_ { return sizes[s]; },
        policy,
        variable,
        [&](std::size_t s, Weight_ w) -> void { weights[s] = w; }
    );
}
 
template<typename Weight_ = double, typename Size_>
std::vector<Weight_> compute_weights(const std::vector<Size_>& sizes, const WeightPolicy policy, const VariableWeightParameters& variable) {
    auto output = sanisizer::create<std::vector<Weight_> >(sizes.size());
    compute_weights(sizes.size(), sizes.data(), policy, variable, output.data());
    return output;
}
 
}
 
#endif