dl_random.h

浏览该文件的文档.

#pragma once
 
#include <random>
#include "io/dl_log.h"
#include "base/dl_type_def.h"
#include "math/dl_algorithm.h"
#include "memory/dl_buffer.h"
 
 
namespace dl
{
class Random
{
    using FloatType = Float;
public:
    static void SetSeed(uint32_t seed)
    {
        if (seed == 0)
        {
            std::random_device rd;
            _re.seed(_seed = rd());
        }
        else
            _re.seed(_seed = seed);
    }

    template <typename T>
    static T Float(T min, T max)
    {
        //参数检查
        if (min > max)
        {
            log("min > max！");
            std::swap(min, max);
        }
        static std::uniform_real_distribution<T> dist_double;
        //设定区间
        using D = std::decay_t<decltype(dist_double)>;
        using P = typename D::param_type;
        dist_double.param(P{min, max});
        return dist_double(_re);
    }

    template <typename T>
    static T Integer(T min, T max)
    {
        //参数检查
        if (min > max)
        {
            log("min > max！");
            std::swap(min, max);
        }
        static std::uniform_int_distribution<T> dist_int;
        //设定区间
        using D = std::decay_t<decltype(dist_int)>;
        using P = typename D::param_type;
        dist_int.param(P{min, max});
        return dist_int(_re);
    }

    template <typename T>
    static T Normal(T u = 0, T o = 1)
    {
        static std::normal_distribution<T> dist;
        //设定区间
        using D = std::decay_t<decltype(dist)>;
        using P = typename D::param_type;
        dist.param(P{ u, o });
        return dist(_re);
    }
 
    static FloatType FloatNormal(FloatType u = 0_f, FloatType o = 1_f)
    {
        return Normal(u, o);
    }

    static FloatType FloatNormalX(
        FloatType scale = 1/3_f,
        FloatType min = -1, FloatType max = 1)
    {
#if DL_PLATFORM == DL_PLATFORM_LINUX
        return dl::clamp(FloatNormal() * scale, min, max);
#else
        return std::clamp(FloatNormal() * scale, min, max);
#endif
    }
 
 
    static bool Bool()
    {
        return Integer(0, 1) == 1;
    }

    static int Int(int min, int max)
    {
        return Integer(min, max);
    }

    static unsigned Uint(unsigned min, unsigned max)
    {
        return Integer(min, max);
    }

    static size_t SizeT(size_t min, size_t max)
    {
        return Integer(min, max);
    }
    template<size_t N>
    static std::array<std::byte, N> Array()
    {
        std::array<std::byte, N> ret;
        size_t X = N / 8;
        size_t Y = N % 8;
        for (size_t i = 0; i < X; ++i)
        {
            ((uint64_t*)ret.data())[i] = Integer<uint64_t>(0, (std::numeric_limits<uint64_t>::max)());
        }
        uint8_t* p = (uint8_t*)ret.data() + X * 8;
        for (size_t j = 0; j < Y; ++j)
        {
            p[j] = (uint8_t)Int(0, 7);
        }
        return ret;
    }
 
    static Buffer BufferX(size_t len)
    {
        Buffer ret{ len };
        size_t X = len / 8;
        size_t Y = len % 8;
        for (size_t i = 0; i < X; ++i)
        {
            ((uint64_t*)ret.data())[i] = Integer<uint64_t>(0, (std::numeric_limits<uint64_t>::max)());
        }
        uint8_t* p = (uint8_t*)ret.data() + X * 8;
        for (size_t j = 0; j < Y; ++j)
        {
            p[j] = (uint8_t)Int(0, 7);
        }
        return ret;
    }

    template <typename C>
    static auto& Select(C& container)
    {
        assert(!container.empty());
        size_t index = Integer<size_t>(0, container.size() - 1);
        auto iter = container.begin();
        advance(iter, index);
        return *iter;
    }

    template <typename C>
    static auto SelectErase(C& container)
    {
        assert(!container.empty());
        size_t index = Integer<size_t>(0, container.size() - 1);
        auto iter = container.begin();
        advance(iter, index);
        auto ret = *iter;
        container.erase(iter);
        return ret;
    }
 
    static Point ExPoint(const Point& p0, const Point& p1)
    {
        return { Int(p0[0], p1[0]), Int(p0[1], p1[1]) };
    }
    static PointU ExPointU(const PointU& p0, const PointU& p1)
    {
        return { Uint(p0[0], p1[0]), Uint(p0[1], p1[1]) };
    }
    static Position ExDirection()
    {
        float r = Random::Angle();
        return { std::cos(r), std::sin(r)};
    }

    static bool Percent(int v)
    {
        return Int(0, 99) < v;
    }

    static float Angle(float min = 0, float max = 3.1415926f * 2.0f)
    {
        return Float(min, max);
    }
    static float Float(const std::array<float, 2>& mm)
    {
        return Float(mm[0], mm[1]);
    }
    static float Float(const dl::Array<float, 2>& mm)
    {
        return Float(mm[0], mm[1]);
    }

    static std::default_random_engine& GetEngine()
    {
        return _re;
    }
private:
    static uint32_t _seed;
    static std::default_random_engine _re;
};
}