GenRandomValue.h

Go to the documentation of this file.

// GenRandomValue.h:
// -----------------
//

#ifndef __IPSDKUTIL_GENRANDOMVALUE_H__
#define __IPSDKUTIL_GENRANDOMVALUE_H__

#include <IPSDKUtil/IPSDKUtilExports.h>
#include <IPSDKUtil/BaseTypes.h>
#include <IPSDKUtil/Tools/ForceInline.h>
#include <IPSDKUtil/Tools/NumericLimits.h>

#include <boost/random/mersenne_twister.hpp>
#include <boost/random/discrete_distribution.hpp>
#include <boost/random/uniform_real_distribution.hpp>
#include <boost/type_traits/is_integral.hpp>

namespace ipsdk {


class IPSDKUTIL_API RandomUniformGenerator
{
    friend struct RandomUniformGeneratorSeedLocker;
    template<typename T, typename Enable> friend struct GenRandomUniform;

    static boost::mt19937& getGen();
    static void setSeed(ipUInt32 seed);
    static void resetSeed();
};

struct RandomUniformGeneratorSeedLocker {
    RandomUniformGeneratorSeedLocker(ipUInt32 seed)
    {
        RandomUniformGenerator::setSeed(seed);
    }
    
    ~RandomUniformGeneratorSeedLocker()
    {
        RandomUniformGenerator::resetSeed();
    }

};

template <typename T, typename Enable=void>
struct GenRandomUniform
{
};

template <typename T>
struct GenRandomUniform<T, 
    typename boost::enable_if_c<boost::is_integral<T>::value>::type>
{
    static IPSDK_FORCEINLINE T act(const T& minVal, const T& maxVal)
    {
        boost::random::uniform_int_distribution<T> dist(minVal, maxVal);
        return dist(RandomUniformGenerator::getGen());
    }

    static IPSDK_FORCEINLINE T act()
    {
        return act(NumericLimits<T>::min(), NumericLimits<T>::max());
    }
};

template <typename T>
struct GenRandomUniform<T,
    typename boost::enable_if_c<!boost::is_integral<T>::value>::type>
{
    static IPSDK_FORCEINLINE T act(const T& minVal, const T& maxVal)
    {
        // this test is a work-around for 
        // boost::random::uniform_real_distribution issue 
        // (boost 1.53 and prior)
        if(maxVal / 2 - minVal / 2 > (NumericLimits<T>::max)() / 2) {
            boost::random::uniform_real_distribution<T> dist(minVal/2, maxVal/2);
            return dist(RandomUniformGenerator::getGen());
        }
        else {
            boost::random::uniform_real_distribution<T> dist(minVal, maxVal);
            return dist(RandomUniformGenerator::getGen());
        }
    }

    static IPSDK_FORCEINLINE T act()
    {
        return act(NumericLimits<T>::min(), NumericLimits<T>::max());
    }
};

// (the seed of the random number generator is implicitly initialized to std::time(0))
template <typename T> IPSDK_FORCEINLINE  T genRandomUniformValue(const T& minVal,
                                                                 const T& maxVal)
{
    return GenRandomUniform<T>::act(minVal, maxVal);
}

// value for type T] (the seed of the random number generator is implicitly initialized to std::time(0))
template <typename T> IPSDK_FORCEINLINE  T genRandomUniformValue()
{
    return GenRandomUniform<T>::act();
}


} // end of namespace ipsdk

#endif // __IPSDKUTIL_GENRANDOMVALUE_H__