RNG.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <Eigen/Core>
#include <cstdint>
#include <random>
 
namespace vulcan::rng {

class RNG {
  public:
    using Engine = std::mt19937_64;
    using result_type = Engine::result_type;

    explicit RNG(uint64_t seed)
        : engine_(seed), seed_(seed), normal_(0.0, 1.0), uniform_(0.0, 1.0) {}

    explicit RNG(std::seed_seq &seq)
        : engine_(seq), seed_(0), normal_(0.0, 1.0), uniform_(0.0, 1.0) {}
 
    // Prevent copying (each RNG should have unique state)
    RNG(const RNG &) = delete;
    RNG &operator=(const RNG &) = delete;
 
    // Allow moving
    RNG(RNG &&) = default;
    RNG &operator=(RNG &&) = default;

    result_type operator()() { return engine_(); }

    double gaussian() { return normal_(engine_); }

    double gaussian(double mean, double stddev) {
        return mean + stddev * normal_(engine_);
    }

    double uniform() { return uniform_(engine_); }

    double uniform(double min, double max) {
        return min + (max - min) * uniform_(engine_);
    }

    int64_t uniform_int(int64_t min, int64_t max) {
        std::uniform_int_distribution<int64_t> dist(min, max);
        return dist(engine_);
    }

    Eigen::Vector3d gaussian3() {
        return Eigen::Vector3d(normal_(engine_), normal_(engine_),
                               normal_(engine_));
    }

    template <int N> Eigen::Vector<double, N> gaussianN() {
        Eigen::Vector<double, N> v;
        for (int i = 0; i < N; ++i) {
            v(i) = normal_(engine_);
        }
        return v;
    }

    Engine &engine() { return engine_; }
    const Engine &engine() const { return engine_; }

    uint64_t seed() const { return seed_; }

    void discard(uint64_t n) { engine_.discard(n); }

    void reset() {
        engine_.seed(seed_);
        normal_.reset();  // Clear Box-Muller cache
        uniform_.reset(); // Clear any distribution cache
    }

    void reseed(uint64_t new_seed) {
        seed_ = new_seed;
        engine_.seed(new_seed);
        normal_.reset();
        uniform_.reset();
    }
 
  private:
    Engine engine_;
    uint64_t seed_;
    std::normal_distribution<double> normal_;
    std::uniform_real_distribution<double> uniform_;
};
 
} // namespace vulcan::rng