simulate_compressed_sparse_matrix.hpp

Go to the documentation of this file.

#ifndef SCRAN_TESTS_SIMULATE_COMPRESSED_SPARSE_MATRIX_HPP
#define SCRAN_TESTS_SIMULATE_COMPRESSED_SPARSE_MATRIX_HPP
 
#include <random>
#include <vector>
#include <type_traits>
#include <cstddef>
 
#include "simulate_vector.hpp"
 
namespace scran_tests {
 
template<typename Data_ = double>
struct SimulateCompressedSparseMatrixParameters {
    double density = 0.2;
 
    Data_ lower = default_simulation_min<Data_>(); 
 
    Data_ upper = 10;
 
    typename RngEngine::result_type seed = 1234567890;
};
 
template<typename Data_, typename Index_, typename Pointer_>
struct SimulatedCompressedSparseMatrix {
    Index_ primary;
 
    Index_ secondary;
 
    std::vector<Data_> data;
 
    std::vector<Index_> index;
 
    std::vector<Pointer_> pointers;
};
 
template<typename Data_ = double, typename Index_ = int, typename Pointer_ = std::size_t>
SimulatedCompressedSparseMatrix<Data_, Index_, Pointer_> simulate_compressed_sparse_matrix(
    Index_ primary,
    Index_ secondary,
    const SimulateCompressedSparseMatrixParameters<Data_>& params
) {
    RngEngine rng(params.seed);
    auto unif = create_simulating_distribution(params.lower, params.upper);
 
    SimulatedCompressedSparseMatrix<Data_, Index_, Pointer_> output;
    output.primary = primary;
    output.secondary = secondary;
    output.pointers.reserve(static_cast<typename std::vector<Pointer_>::size_type>(primary) + 1);
    output.pointers.push_back(0);
 
    std::uniform_real_distribution<double> nonzero(0.0, 1.0);
    for (Index_ p = 0; p < primary; ++p) {
        for (Index_ s = 0; s < secondary; ++s) {
            if (nonzero(rng) <= params.density) {
                output.index.push_back(s);
                output.data.push_back(unif(rng));
            }
        }
        output.pointers.push_back(output.index.size());
    }
 
    return output;
}
 
}
 
#endif