MTRandom.h

Go to the documentation of this file.

// Mersenne Twister random number generator
// It is proved that the period is 2^19937-1, and 623-dimensional equidistribution property is assured.
// http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/emt.html
// About 1.3 times slower than rand() on Windows XP / VC++6

// C++ include file for MT19937, with initialization improved 2002/1/26.
// Coded by Takuji Nishimura and Makoto Matsumoto.
//
// The generators returning floating point numbers are based on
// a version by Isaku Wada, 2002/01/09
//
// Ported to C++ by Jasper Bedaux 2003/1/1 (see http://www.bedaux.net/mtrand/).
//
// Modified by Razvan Florian (http://coneural.org/florian/) to implement static 
// methods for random number generation, 2005/07/27
//
// Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura
// Copyright (C) 2005, Razvan Florian
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions
// are met:
//
// 1. Redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. The names of its contributors may not be used to endorse or promote
//    products derived from this software without specific prior written
//    permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Any feedback is very welcome.
// email: matumoto@math.keio.ac.jp


#if !defined(AFX_MTRANDOM_H__80B8318A_FECC_423A_9199_FF3E5F3A05D3__INCLUDED_)
#define AFX_MTRANDOM_H__80B8318A_FECC_423A_9199_FF3E5F3A05D3__INCLUDED_

// the following constants are not class members because Visual C++ 6 does not allow it
static const int MTRandomN = 624, MTRandomM = 397; // compile time constants

class MTRandom  {
public:
   MTRandom();
   virtual ~MTRandom();

   static void seed(unsigned long); // seed with 32 bit integer
   static void seed(const unsigned long*, int size); // seed with array

   inline static unsigned long int getLongInt() { 
      if (p == MTRandomN) gen_state(); // new state vector needed
      // gen_state() is split off to be non-inline, because it is only called once
      // in every 624 calls and otherwise irand() would become too big to get inlined
      unsigned long x = state[p++];
      x ^= (x >> 11);
      x ^= (x << 7) & 0x9D2C5680UL;
      x ^= (x << 15) & 0xEFC60000UL;
      return x ^ (x >> 18);
   }

   inline static unsigned int getInt(unsigned int n){
      return (unsigned int)(getLongInt() % (unsigned long int)(n+1));
   }

   inline static float getFloat(){
      return static_cast<float>(getLongInt()) * (1.f / 4294967296.f);  // divided by 2^32
   }

   inline static double getDouble(){
      return static_cast<double>(getLongInt()) * (1. / 4294967296.);  // divided by 2^32
   }

   inline static double getDoubleClosed(){
      return static_cast<double>(getLongInt()) * (1. / 4294967295.);  // divided by 2^32 - 1
   }

   inline static double getDoubleOpen(){
      return (static_cast<double>(getLongInt()) + .5) * (1. / 4294967296.);  // divided by 2^32
   }

   inline static double getDoubleHR(){
      return (static_cast<double>(getLongInt() >> 5) * 67108864. + 
      static_cast<double>(getLongInt() >> 6)) * (1. / 9007199254740992.);
   }

private:

   // the variables below are static (no duplicates can exist)
   static unsigned long int state[MTRandomN]; // state vector array
   static int p; // position in state array

   static void gen_state(); // generate new state

   inline static unsigned long twiddle(unsigned long u, unsigned long v) { //used by gen_state()
      return (((u & 0x80000000UL) | (v & 0x7FFFFFFFUL)) >> 1)
         ^ ((v & 1UL) ? 0x9908B0DFUL : 0x0UL);
   }
  

   // make copy constructor and assignment operator unavailable, they don't make sense
  MTRandom(const MTRandom&); // copy constructor not defined
  void operator=(const MTRandom&); // assignment operator not defined

   //void saveState();
   //void verifyState(unsigned long s);
};

#endif // !defined(AFX_MTRANDOM_H__80B8318A_FECC_423A_9199_FF3E5F3A05D3__INCLUDED_)

Thyrix homepage • Users' guide

(C) Arxia 2004-2005