rng.h

Go to the documentation of this file.

#pragma once
 
#include "zeroerr/internal/config.h"
 
#include <cstdint>
#include <cstring>
#include <vector>
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_PUSH
 
namespace zeroerr {
 
class Rng final {
public:
    using result_type = uint64_t;
 
    static uint64_t min();
    static uint64_t max();
 
    Rng(Rng const&) = delete;
 
    Rng& operator=(Rng const&) = delete;
 
    // moving is ok
    Rng(Rng&&) noexcept            = default;
    Rng& operator=(Rng&&) noexcept = default;
    ~Rng() noexcept                = default;
 
    Rng();
 
    explicit Rng(uint64_t seed) noexcept;
    Rng(uint64_t x, uint64_t y) noexcept;
    Rng(std::vector<uint64_t> const& data);
 
    Rng copy() const noexcept;
 
    inline uint64_t operator()() noexcept {
        auto x = mX;
 
        mX = UINT64_C(15241094284759029579) * mY;
        mY = rotl(mY - x, 27);
 
        return x;
    }
 
    // This is slightly biased. See
 
    inline uint32_t bounded(uint32_t range) noexcept {
        uint64_t r32         = static_cast<uint32_t>(operator()());
        auto     multiresult = r32 * range;
        return static_cast<uint32_t>(multiresult >> 32U);
    }
 
    // random double in range [0, 1]
    // see http://prng.di.unimi.it/
 
    inline double uniform01() noexcept {
        auto i = (UINT64_C(0x3ff) << 52U) | (operator()() >> 12U);
        // can't use union in c++ here for type puning, it's undefined behavior.
        // std::memcpy is optimized anyways.
        double d;
        std::memcpy(&d, &i, sizeof(double));
        return d - 1.0;
    }
 
    template <typename Container>
    void shuffle(Container& container) noexcept {
        auto size = static_cast<uint32_t>(container.size());
        for (auto i = size; i > 1U; --i) {
            using std::swap;
            auto p = bounded(i);  // number in [0, i)
            swap(container[i - 1], container[p]);
        }
    }
 
    std::vector<uint64_t> state() const;
 
private:
    static uint64_t rotl(uint64_t x, unsigned k) noexcept;
 
    uint64_t mX;
    uint64_t mY;
};
 
} // namespace zeroerr
 
ZEROERR_SUPPRESS_COMMON_WARNINGS_POP