random.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_NUMERIC_RANDOM_HPP__
#define NEFORCE_CORE_NUMERIC_RANDOM_HPP__

 
#include "NeForce/core/config/msvc_intrinsic.hpp"
#include "NeForce/core/numeric/numeric_traits.hpp"
#include "NeForce/core/typeinfo/type_traits.hpp"
NEFORCE_BEGIN_NAMESPACE__

 
template <typename Generator>
uint64_t lemire_bounded(Generator&& gen, const uint64_t max) noexcept(noexcept(gen())) {
    uint64_t hi = 0;
    uint64_t lo = _NEFORCE _umul128(gen(), max, &hi);
 
    if (lo >= max) {
        return hi;
    }
 
    const uint64_t threshold = (static_cast<uint64_t>(0) - max) % max;
    while (lo < threshold) {
        lo = _NEFORCE _umul128(gen(), max, &hi);
    }
    return hi;
}

class NEFORCE_API random_lcd {
public:
    using seed_type = uint32_t; 
 
private:
    static constexpr seed_type a = 1103515245; 
    static constexpr seed_type c = 12345;      
    static constexpr seed_type m = 1U << 31;   
 
    seed_type seed_; 
 
    uint32_t generate_32bit() noexcept {
        seed_ = a * seed_ + c;
        seed_ %= m;
        return static_cast<uint32_t>(seed_);
    }
 
    uint64_t generate_64bit() noexcept {
        const auto hi = static_cast<uint64_t>(generate_32bit()) << 32;
        const auto lo = static_cast<uint64_t>(generate_32bit());
        return hi | lo;
    }
 
    decltype(auto) generate(true_type /*unused*/) noexcept { return generate_32bit(); }
    decltype(auto) generate(false_type /*unused*/) noexcept { return generate_64bit(); }
 
public:
    random_lcd() noexcept;

    explicit random_lcd(const seed_type seed) noexcept :
    seed_(seed) {}

    template <typename T>
    T next_int(T max) noexcept {
        static_assert(is_integral_v<T>, "only integral types are supported");
 
        if (max <= 0 || max == 1) {
            return 0;
        }
        return static_cast<T>(
                _NEFORCE lemire_bounded([this]() noexcept { return generate_64bit(); }, static_cast<uint64_t>(max)));
    }

    template <typename T>
    T next_int(T min, T max) noexcept {
        if (min >= max) {
            return min;
        }
        return min + this->next_int<T>(max - min);
    }

    template <typename T>
    T next_int() noexcept {
        static_assert(is_integral_v<T>, "only integral types are supported");
        return static_cast<T>(this->generate(bool_constant<sizeof(T) <= 4>()));
    }

    uint64_t next_uint64(uint64_t max) noexcept {
        if (max == 0 || max == 1) {
            return 0;
        }
        return lemire_bounded([this]() noexcept { return generate_64bit(); }, max);
    }

    uint64_t next_uint64() noexcept { return generate_64bit(); }

    template <typename T>
    T next_float() noexcept {
        static_assert(is_floating_point_v<T>, "only floating point types are supported");
        auto gen = this->generate(bool_constant<sizeof(T) <= 4>());
        using IntT = decay_t<decltype(gen)>;
        return static_cast<T>(gen) / static_cast<T>(numeric_traits<IntT>::max());
    }

    template <typename T>
    T next_float(T min, T max) noexcept {
        if (min >= max) {
            return min;
        }
        return min + (max - min) * next_float<T>();
    }

    template <typename T>
    T next_float(T max) noexcept {
        return this->next_float(static_cast<T>(0), max);
    }
};
 

class NEFORCE_API random_mt {
public:
    using seed_type = uint32_t; 
 
private:
    static constexpr size_t n = 624;           
    static constexpr size_t m = 397;           
    static constexpr seed_type a = 0x9908b0df; 
    static constexpr seed_type u = 11;         
    static constexpr seed_type s = 7;          
    static constexpr seed_type b = 0x9d2c5680; 
    static constexpr seed_type t = 15;         
    static constexpr seed_type c = 0xefc60000; 
    static constexpr seed_type l = 18;         
 
    seed_type state_[n] = {}; 
    size_t index_ = n;        
 
    void twist() noexcept;
 
    seed_type generate_32bit() noexcept;
    uint64_t generate_64bit() noexcept;
 
    decltype(auto) generate(true_type /*unused*/) noexcept { return generate_32bit(); }
    decltype(auto) generate(false_type /*unused*/) noexcept { return generate_64bit(); }
 
public:
    random_mt() noexcept;

    explicit random_mt(const seed_type seed) noexcept { set_seed(seed); }

    void set_seed(seed_type seed) noexcept;

    template <typename T>
    T next_int(T max) noexcept {
        static_assert(is_integral_v<T>, "only integral types are supported");
 
        if (max <= 0 || max == 1) {
            return 0;
        }
        return static_cast<T>(
                _NEFORCE lemire_bounded([this]() noexcept { return generate_64bit(); }, static_cast<uint64_t>(max)));
    }

    template <typename T>
    T next_int(T min, T max) noexcept {
        if (min >= max) {
            return min;
        }
        return min + this->next_int<T>(max - min);
    }

    template <typename T>
    T next_int() noexcept {
        static_assert(is_integral_v<T>, "only integral types are supported");
        return static_cast<T>(this->generate(bool_constant<sizeof(T) <= 4>()));
    }

    uint64_t next_uint64(uint64_t max) noexcept {
        if (max == 0 || max == 1) {
            return 0;
        }
        return _NEFORCE lemire_bounded([this]() noexcept { return generate_64bit(); }, max);
    }

    uint64_t next_uint64() noexcept { return generate_64bit(); }

    template <typename T>
    T next_float() noexcept {
        static_assert(is_floating_point_v<T>, "only floating point types are supported");
        auto gen = this->generate(bool_constant<sizeof(T) <= 4>());
        using IntT = decay_t<decltype(gen)>;
        return static_cast<T>(gen) / static_cast<T>(numeric_traits<IntT>::max());
    }

    template <typename T>
    T next_float(T min, T max) noexcept {
        if (min >= max) {
            return min;
        }
        return min + (max - min) * next_float<T>();
    }

    template <typename T>
    T next_float(T max) noexcept {
        return this->next_float(static_cast<T>(0), max);
    }
};
 

class NEFORCE_API secret {
private:
    static void get_random_bytes(byte_t* buffer, size_t length);
 
    static uint32_t generate_32bit() {
        uint32_t value = 0;
        get_random_bytes(reinterpret_cast<byte_t*>(&value), sizeof(value));
        return value;
    }
 
    static uint64_t generate_64bit() {
        uint64_t value = 0;
        get_random_bytes(reinterpret_cast<byte_t*>(&value), sizeof(value));
        return value;
    }
 
    static decltype(auto) generate(true_type /*unused*/) { return generate_32bit(); }
    static decltype(auto) generate(false_type /*unused*/) { return generate_64bit(); }
 
public:
    template <typename T>
    static T next_int(T max) {
        static_assert(is_integral_v<T>, "only integral types are supported");
 
        if (max <= 0) {
            return 0;
        }
        if (max == 1) {
            return 0;
        }
        return static_cast<T>(
                _NEFORCE lemire_bounded([]() { return secret::generate_64bit(); }, static_cast<uint64_t>(max)));
    }

    template <typename T>
    static T next_int(T min, T max) {
        if (min >= max) {
            return min;
        }
        return min + secret::next_int<T>(max - min);
    }

    template <typename T>
    static T next_int() {
        static_assert(is_integral_v<T>, "only integral types are supported");
        return static_cast<T>(secret::generate(bool_constant<sizeof(T) <= 4>()));
    }

    static uint64_t next_uint64(uint64_t max) {
        if (max == 0 || max == 1) {
            return 0;
        }
        return lemire_bounded([]() { return secret::generate_64bit(); }, max);
    }

    static uint64_t next_uint64() { return generate_64bit(); }

    template <typename T>
    static T next_float() {
        static_assert(is_floating_point_v<T>, "only floating point types are supported");
        auto gen = secret::generate(bool_constant<sizeof(T) <= 4>());
        using IntT = decay_t<decltype(gen)>;
        return static_cast<T>(gen) / static_cast<T>(numeric_traits<IntT>::max());
    }

    template <typename T>
    static T next_float(T min, T max) {
        static_assert(is_floating_point_v<T>, "only floating point types are supported");
        if (min >= max) {
            return min;
        }
        return min + (max - min) * secret::next_float<T>();
    }

    template <typename T>
    static T next_float(T max) {
        static_assert(is_floating_point_v<T>, "only floating point types are supported");
        return secret::next_float(static_cast<T>(0), max);
    }

    static bool system_supported();
};
 // RandomGenerators
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_NUMERIC_RANDOM_HPP__