random function, again

class c_RandomSequence{  public:    c_RandomSequence(unsigned __int64 Seed = 0)    {      if (Seed == 0)      {        GetSystemTimeAsFileTime((FILETIME*)mNumber64);        QueryPerformanceCounter((LARGE_INTEGER*)mConstant);        mNumber64 ^= mConstant;      }      else      {        mNumber64 = Seed;      }      //Random crap to get a number 0-9 out of mNumber64      //Any of the following numbers will work well for mConstant      //Try to make sure that both mConstant * 2^32 - 1 and      //  (mConstant * 2^32 - 2) / 2 are prime      switch (((mNumber64) ^ (mNumber64 >> 4) ^ (mNumber64 >> 8)) % 10)      {        case 0:  mConstant = 1075433238;  break;        case 1:  mConstant = 1447497129;  break;        case 2:  mConstant = 1517746329;  break;        case 3:  mConstant = 1557985959;  break;        case 4:  mConstant = 1606218150;  break;        case 5:  mConstant = 1655692410;  break;        case 6:  mConstant = 1781943330;  break;        case 7:  mConstant = 1893513180;  break;        case 8:  mConstant = 1967773755;  break;        case 9:  mConstant = 2051013963;  break;      }    }    unsigned __int32 Random()    {      mNumber64 = mConstant * mNumber32 + mCarry32;      return mNumber32;    }  private:    union    {      struct      {        unsigned __int32 mNumber32;        unsigned __int32 mCarry32;      };      unsigned __int64 mNumber64;    };    unsigned __int64 mConstant;};

class uniform{    mutable unsigned x; // current seed value    unsigned a; // coefficient    unsigned b; // increment    unsigned m; // basepublic:    // Initialise the generator with seed x0 and parameters a, b, m as above    // Note: 0x7FFFFFFE = 2^31 - 1    uniform(unsigned x0=12345U, unsigned a=1103515245U, unsigned b=12345U,            unsigned m=0x7FFFFFFEU);    // Return a random number. Note that the internal seed changes even in a    // const object (else the generator is quite useless).    unsigned operator()() const;    // Random number in [a, b)    float operator()(float x0, float x1) const    {        return x0 + (static_cast<float>((*this)())/m * (x1-x0));    }    // Set the seed to x0 and return a random number. A constant generator    // cannot be reseeded.    unsigned operator()(unsigned x0);    unsigned max() const { return m; }};uniform::uniform(unsigned x0, unsigned a, unsigned b, unsigned m): x(x0), a(a), b(b), m(m){    ;}unsigned uniform::operator()() const{    return (x = (a*x + b) % m);}unsigned uniform::operator()(unsigned x0){    x = x0;    return (*this)();}

#define INT_BITS (sizeof(int)*8)#define INEG_MASK(x) (x >> (INT_BITS-1))#define Ran_MM 2147483647 // Mersenne's prime number#define Ran_AA 48217 // good at spectral test#define Ran_QQ 44488 // Ran_MM / Ran_AA#define Ran_QQ 3399 // Ran_MM % Ran_AAtemplate<int nCount>int randomLinear(int x){  // Most of the time all this checkings are obsolete,  // cause we're passing quite small numbers as inputs, but for completeness sake...  // On the other hand we are passing FtoDW(f) somethimes and those can be mess.  // Cut negatives to positives. This results in distortion of negative numbers  // construction, but we shouldn't care.  // But if you do care, use the first sentence.  /* x = ABS_INT(x); */  x &= 0x7FffFFff;  // There is only small amount of space to fall out of range, so shr(x, 1) is sufficient.  // Only that we would want to save last bit, so r(x) and r(x+1) wouldn't be the same,  // so we're clearing the most significant bit instead.  if ( x >= Ran_MM )   x &= 0x3FffFFff;  // Hope compiler would expand this for nCount = 1,2 or 3.  for (int i=0; i<nCount; i++)  {    // IOW this is x = (x * Ran_AA) % Ran_MM, but that way we avoid overflow ;)    x = Ran_AA * (x % Ran_QQ) - Ran_RR * (x / Ran_QQ);    // Negative x gives us INEG_MASK(x)=0xFFffFFff.    /* if (x < 0) x += Ran_MM; */    x += Ran_MM & INEG_MASK(x);  };  return x;}