simulate_compressed_sparse.hpp

Go to the documentation of this file.

#ifndef TATAMI_TEST_SIMULATE_COMPRESSED_SPARSE_HPP
#define TATAMI_TEST_SIMULATE_COMPRESSED_SPARSE_HPP
 
#include <random>
#include <vector>
#include <cstddef>
 
#include "sanisizer/sanisizer.hpp"
 
#include "utils.hpp"
 
namespace tatami_test {
 
struct SimulateCompressedSparseOptions {
    double lower = 0;
 
    double upper = 100;
 
    double density = 0.1;
 
    SeedType seed = sanisizer::cap<SeedType>(1234567890);
};
 
template<typename Value_, typename Index_>
struct SimulateCompressedSparseResult {
    std::vector<Value_> data;
 
    std::vector<Index_> index;
 
    std::vector<std::size_t> indptr;
};
 
template<typename Value_, typename Index_>
SimulateCompressedSparseResult<Value_, Index_> simulate_compressed_sparse(const Index_ primary, const Index_ secondary, const SimulateCompressedSparseOptions& options) {
    RngEngine rng(options.seed);
    std::uniform_real_distribution<> nonzero(0.0, 1.0);
    std::uniform_real_distribution<> unif(options.lower, options.upper);
 
    SimulateCompressedSparseResult<Value_, Index_> output;
    output.indptr.resize(sanisizer::sum<I<decltype(output.indptr.size())> >(primary, 1));
    for (I<decltype(primary)> p = 0; p < primary; ++p) {
        auto idx = output.indptr[p];
        for (I<decltype(secondary)> s = 0; s < secondary; ++s) {
            if (nonzero(rng) < options.density) {
                output.data.push_back(unif(rng));
                output.index.push_back(s);
                ++idx;
            }
        }
        output.indptr[p + 1] = idx;
    }
 
    return output;
}
 
}
 
#endif