FastRandom.h

Go to the documentation of this file.

// FastRandom.h

// Declares the cFastRandom class representing a fast random number generator

/*
The cFastRandom alias should be avoided in favor of the result of a call to GetRandomProvider().
The MTRand generator used is faster, has a better range and provides higher quality randomness.
Note that MTRand is relatively costly to construct and so instances should be long lived,
prefer calls to GetRandomProvider over creating new instances.
*/





#pragma once





namespace Detail
{
    UInt32 GetRandomSeed();

    template <class Char>
    using IsChar = typename std::is_same<typename std::make_signed<Char>::type, signed char>::type;

    template <class IntType>
    struct cUniformImpl :
        public std::conditional<
            IsChar<IntType>::value,
            typename std::conditional<  // Match signed-ness of IntType
                std::is_signed<IntType>::value,
                std::uniform_int_distribution<short>,
                std::uniform_int_distribution<unsigned short>
            >::type,
            std::uniform_int_distribution<IntType>
        >
    {
    };

    template <class IntType>
    using cUniform = typename cUniformImpl<IntType>::type;
}





template <class RandomEngine>
class cRandomWrapper
{
public:
    cRandomWrapper():
        m_Engine(Detail::GetRandomSeed())
    {
    }


    template <class SeedSeq>
    cRandomWrapper(SeedSeq & a_SeedSeq):
        m_Engine(a_SeedSeq)
    {
    }



    template <class IntType = int>
    IntType RandInt(IntType a_Min, IntType a_Max)
    {
        ASSERT(
            (a_Max >= a_Min) &&
            (a_Max <= std::numeric_limits<IntType>::max()) &&
            (a_Min >= std::numeric_limits<IntType>::min())
        );
        Detail::cUniform<IntType> dist(
            static_cast<IntType>(a_Min),
            static_cast<IntType>(a_Max)
        );
        return static_cast<IntType>(dist(m_Engine));
    }





    template <class IntType = int>
    IntType RandInt(IntType a_Max)
    {
        ASSERT((a_Max >= 0) && (a_Max <= std::numeric_limits<IntType>::max()));
        Detail::cUniform<IntType> dist(IntType(0), static_cast<IntType>(a_Max));
        return static_cast<IntType>(dist(m_Engine));
    }





    template <class IntType = int>
    IntType RandInt()
    {
        Detail::cUniform<IntType> dist(IntType(0), std::numeric_limits<IntType>::max());
        return static_cast<IntType>(dist(m_Engine));
    }





    template <class RealType = float>
    RealType RandReal(RealType a_Min, RealType a_Max)
    {
        std::uniform_real_distribution<RealType> dist(a_Min, a_Max);
        return dist(m_Engine);
    }





    template <class RealType = float>
    RealType RandReal(RealType a_Max)
    {
        std::uniform_real_distribution<RealType> dist(RealType(0), a_Max);
        return dist(m_Engine);
    }





    template <class RealType = float>
    RealType RandReal()
    {
        std::uniform_real_distribution<RealType> dist;
        return dist(m_Engine);
    }





    bool RandBool(double a_TrueProbability = 0.5)
    {
        std::bernoulli_distribution dist(a_TrueProbability);
        return dist(m_Engine);
    }




    RandomEngine & Engine()
    {
        return m_Engine;
    }

private:

    RandomEngine m_Engine;
};





struct cRandomDeviceSeeder
{
    using result_type = std::random_device::result_type;

    template <class Itr>
    void generate(Itr first, Itr last)
    {
        std::random_device rd;
        std::uniform_int_distribution<result_type> dist;
        for (; first != last; ++first)
        {
            *first = dist(rd);
        }
    }
};





using cFastRandom = cRandomWrapper<std::minstd_rand>;
using MTRand = cRandomWrapper<std::mt19937>;

MTRand & GetRandomProvider();