|| || || || || ||

---

Random.h

Go to the documentation of this file.

#ifndef Impala_Util_NewRandom_h
#define Impala_Util_NewRandom_h

#include <ctime>
#include <cstdlib>
#include <set>

#include "Basis/ILog.h"
#include "Basis/NativeTypes.h"

namespace Impala
{
namespace Util
{

class Random
{
public:
    static Random&
    GetGlobal()
    {
        static Random globalInstance;
        return globalInstance;
    }


    Random()
    {
        SetSeed(1);
    }
    
    ~Random()
    {
    }
    
    void
    SetSeed(long seed)
    {
        mSeed = (seed ^ 0x5DEECE66DLL) & ((1LL << 48) - 1);
    }
    
    void
    RandomizeSeed()
    {
        SetSeed(time(0));
    }

    int
    GetRandMax()
    {
        return (1LL << cRandomIntBits) -1;
    }

    int
    GetInt()
    {
        return Next(cRandomIntBits);
    }

    int
    GetInt(int upperBound)
    {
        if(upperBound < 0)
        {
            ILOG_ERROR("upperbound must be positive");
            return 0;
        }
        if(upperBound > GetRandMax())
            ILOG_WARNING(upperBound <<" upperBound > rand max "<< GetRandMax());
        
        // special case for when upperBound is a power of two: return the
        // higher-order bits in stead of the lower order. These have better
        // statistical properties.
        if(!((upperBound -1) & upperBound)) // (x-1)&x is 0 iff x is a power of two
            return (int)((upperBound * (UInt64)Next(31)) >> 31);

        // Because of the modulo some values would be returned more than
        // others. This loop rejects these numbers
        int bits, val;
        do {
            bits = Next(31);
            val = bits % upperBound;
        } while(bits - val + (upperBound-1) < 0); // this check works because of
                                                  // overflow
        return val;
    }

    double
    GetDouble()
    {
        return (((UInt64)Next(26) << 27) + Next(27)) / (double)(1LL << 53);

    }

    std::set<int>
    RandomUniqueNumbers(int count, int upperBound)
    {
        std::set<int> set;
        if(count > upperBound)
        {
            ILOG_ERROR("count > upperBound:"<< count <<" "<< upperBound);
            for(int i=0 ; i<count ; ++i)
                set.insert(i);
            return set;
        }
        if(count >= GetRandMax())
        {
            ILOG_ERROR("count >= GetRandMax:"<< count <<" "<< GetRandMax());
            for(int i=0 ; i<count ; ++i)
                set.insert(i);
            return set;
        }
        while(set.size() < count)
        {
            int draw = GetInt(upperBound);
            if(set.find(draw) == set.end())
                set.insert(draw);
        }
        return set;
    }

    int
    operator() (int upperBound)
    {
        return GetInt(upperBound);
    }
    
private:
    Int64 mSeed;
    static const int cRandomIntBits = 31;
    ILOG_CLASS;

    Int64
    Next(int bits)
    {
        mSeed = (mSeed * 0x5DEECE66DLL + 0xBL) & ((1LL << 48) - 1);
        return (mSeed >> (48 - bits));
    }
};

ILOG_CLASS_INIT(Random, Impala.Util);   

    
} // namespace Util
} // namespace Impala

#endif

---