simulate_vector.hpp

Go to the documentation of this file.

#ifndef SCRAN_TESTS_SIMULATE_VECTOR_HPP
#define SCRAN_TESTS_SIMULATE_VECTOR_HPP
 
#include <random>
#include <vector>
#include <cstdint>
#include <type_traits>
#include <cstddef>
 
namespace scran_tests {
 
typedef std::mt19937_64 RngEngine;
 
template<typename Type_>
constexpr Type_ default_simulation_min() {
    if constexpr(std::is_unsigned<Type_>::value) {
        return 0;
    } else {
        return -10;
    }
}
 
template<typename Type_ = double>
struct SimulateVectorParameters {
    double density = 1;
 
    Type_ lower = default_simulation_min<Type_>();
 
    Type_ upper = 10;
 
    typename RngEngine::result_type seed = 1234567890;
};
 
template<typename Type_>
auto create_simulating_distribution(const Type_ lower, const Type_ upper) {
    if constexpr(std::is_floating_point<Type_>::value) {
        return std::uniform_real_distribution<Type_>(lower, upper);
    } else {
        return std::uniform_int_distribution<Type_>(lower, upper - 1);
    }
}
 
// Back-compatibility.
template<typename Type_ = double>
using SimulationParameters = SimulateVectorParameters<Type_>;
template<typename Type_ = double>
std::vector<Type_> simulate_vector(const typename std::vector<Type_>::size_type length, const SimulateVectorParameters<Type_>& params) {
    RngEngine rng(params.seed);
    auto unif = create_simulating_distribution(params.lower, params.upper);
    std::vector<Type_> values(length);
 
    if (params.density == 1) {
        for (auto& v : values) {
            v = unif(rng);
        }
    } else {
        std::uniform_real_distribution<double> nonzero(0.0, 1.0);
        for (auto& v : values) {
            if (nonzero(rng) <= params.density) {
                v = unif(rng);
            }
        }
    }
 
    return values;
}
 
}
 
#endif