random.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_NUMERIC_RANDOM_HPP__
#define NEFORCE_CORE_NUMERIC_RANDOM_HPP__

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


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 {
        uint64_t result = 0;
        result = static_cast<uint64_t>(generate_32bit()) << 32;
        result |= generate_32bit();
        return result;
    }
 
    decltype(auto) generate(true_type) noexcept { return generate_32bit(); }
 
    decltype(auto) generate(false_type) 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) {
            return 0;
        }
        if (max == 1) {
            return 0;
        }
 
        const uint64_t value = generate_64bit();
        const uint64_t product = value * static_cast<uint64_t>(max);
        return static_cast<T>(product >> 32);
    }

    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) {
            return 0;
        }
        if (max == 1) {
            return 0;
        }
 
        const uint64_t value = generate_64bit();
        return value % 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 = static_cast<T>(this->generate(bool_constant<sizeof(T) <= 4>()));
        using IntT = decay_t<decltype(gen)>;
        return gen / 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) noexcept { return generate_32bit(); }
 
    decltype(auto) generate(false_type) 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) {
            return 0;
        }
        if (max == 1) {
            return 0;
        }
 
        const uint64_t value = generate_64bit();
        const uint64_t product = value * static_cast<uint64_t>(max);
        return static_cast<T>(product >> 32);
    }

    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) {
            return 0;
        }
        if (max == 1) {
            return 0;
        }
 
        const uint64_t value = generate_64bit();
        return value % 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 = static_cast<T>(this->generate(bool_constant<sizeof(T) <= 4>()));
        using IntT = decay_t<decltype(gen)>;
        return gen / 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;
        get_random_bytes(reinterpret_cast<byte_t*>(&value), sizeof(value));
        return value;
    }
 
    static uint64_t generate_64bit() {
        uint64_t value;
        get_random_bytes(reinterpret_cast<byte_t*>(&value), sizeof(value));
        return value;
    }
 
    static decltype(auto) generate(true_type) { return generate_32bit(); }
 
    static decltype(auto) generate(false_type) { 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;
        }
 
        const uint64_t value = generate_64bit();
        const uint64_t product = value * static_cast<uint64_t>(max);
        return static_cast<T>(product >> 32);
    }

    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) {
            return 0;
        }
        if (max == 1) {
            return 0;
        }
 
        const uint64_t value = generate_64bit();
        return value % 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 = static_cast<T>(secret::generate(bool_constant<sizeof(T) <= 4>()));
        using IntT = decay_t<decltype(gen)>;
        return gen / 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) * 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 next_float(static_cast<T>(0), max);
    }

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