random.h

#pragma once
#include "platform.h"
#include "math.h"
namespace stingray_plugin_foundation {
// A fast LCG random number generator. The numbers it produces are not completely
// random but it is faster and more random than vanilla C rand(). It should be good
// enough for most purposes.
class Random
{
    // This variable should NOT need to be volatile, but there is a bug in VC++. If
    // this variable is not volatile Vector3(random(), random(), random()) sets all
    // components to the same value.
    volatile unsigned _state;
public:
    static const unsigned A = 1664525 , B = 1013904223;
    __forceinline Random() : _state(0) {}
    __forceinline Random(unsigned s) : _state(s) {}
    __forceinline unsigned seed() const {return _state;}
    __forceinline void set_seed(unsigned s) {_state = s;}
    __forceinline void next() {_state = A * _state + B;}
    __forceinline unsigned rand_u32() {next(); return _state;}
    __forceinline double rand_double() {return double(rand_u32()) * (0.5 / 0x80000000);}
    __forceinline float rand_float() {return float(rand_u32()) * (0.5f / 0x80000000);}
    __forceinline double operator()(double max) {return max * rand_double();}
    __forceinline double operator()(double min, double max) {return min + (max - min)*rand_double();}
    __forceinline float operator()() {return rand_float();}
    __forceinline float operator()(float max) {return max * rand_float();}
    __forceinline float operator()(float min, float max) {return min + (max - min)*rand_float();}
    __forceinline int operator()(int max_plus_1)  {return (int)floor(max_plus_1*rand_double());}
    __forceinline int operator()(int min, int max) {return (int)floor(min + (max - min + 1)*rand_double());}
    __forceinline unsigned operator()(unsigned max_plus_1)  {return unsigned(max_plus_1*rand_double());}
    __forceinline unsigned operator()(unsigned min, unsigned max) {return unsigned(min + (max - min + 1)*rand_double());}
    // Convenience methods -- coin toss
    __forceinline bool heads() {return rand_float() < 0.5f;}
    __forceinline bool tails() {return rand_float() > 0.5f;}
    // Convenience methods -- random picking
    template <class T> __forceinline T &pick(T &t1, T &t2) {return rand_float() < 0.5f ? t1 : t2;}
    template <class T> __forceinline const T &pick(const T &t1, const T &t2) {return rand_float() < 0.5f ? t1 : t2;}
    template <class T> __forceinline T &pick( T &v ) {return v[ (*this)(v.size()) ];}
    template <class T> __forceinline const T &pick( const T &v ) {return v[ (*this)(v.size()) ];}
    // Random pick with weight. T must have "weight" field.
    template <class T> __forceinline T &pick_weighted( T &v ) {
        float sum = 0;
        typename T::iterator it, begin = v.begin(), end = v.end();
        for (it=begin; it<end; ++it)
            sum += it->weight;
        float pick = (*this)(sum);
        float acc = 0;
        for (it=begin; it<end; ++it) {
            acc += it->weight;
            if (pick < acc) return *it;
        }
        return v.back();
    }
    template <class T> __forceinline const T &pick_weighted( T &v ) {
        float sum = 0;
        typename T::const_iterator it, begin = v.begin(), end = v.end();
        for (it=begin; it<end; ++it)
            sum += it->weight;
        float pick = (*this)(sum);
        float acc = 0;
        for (it=begin; it<end; ++it) {
            acc += it->weight;
            if (pick < acc) return *it;
        }
        return v.back();
    }
};
}