roadrunner  2.6.0
Fast simulator for SBML models
mtrand.h
1 // mtrand.h
2 // C++ include file for MT19937, with initialization improved 2002/1/26.
3 // Coded by Takuji Nishimura and Makoto Matsumoto.
4 // Ported to C++ by Jasper Bedaux 2003/1/1 (see http://www.bedaux.net/mtrand/).
5 // The generators returning floating point numbers are based on
6 // a version by Isaku Wada, 2002/01/09
7 //
8 // Copyright (C) 1997 - 2002, Makoto Matsumoto and Takuji Nishimura,
9 // All rights reserved.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions
13 // are met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. The names of its contributors may not be used to endorse or promote
23 // products derived from this software without specific prior written
24 // permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
27 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
28 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
29 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Any feedback is very welcome.
39 // http://www.math.keio.ac.jp/matumoto/emt.html
40 // email: matumoto@math.keio.ac.jp
41 //
42 // Feedback about the C++ port should be sent to Jasper Bedaux,
43 // see http://www.bedaux.net/mtrand/ for e-mail address and info.
44 
45 #ifndef MTRAND_H
46 #define MTRAND_H
47 
48 #include "rrExporter.h"
49 
51 { // Mersenne Twister random number generator
52 public:
53 // default constructor: uses default seed only if this is the first instance
54  MTRand_int32() { if (!init) seed(5489UL); init = true; }
55 // constructor with 32 bit int as seed
56  MTRand_int32(unsigned long s) { seed(s); init = true; }
57 // constructor with array of size 32 bit ints as seed
58  MTRand_int32(const unsigned long* array, int size) { seed(array, size); init = true; }
59 // the two seed functions
60  void seed(unsigned long); // seed with 32 bit integer
61  void seed(const unsigned long*, int size); // seed with array
62 // overload operator() to make this a generator (functor)
63  unsigned long operator()() { return rand_int32(); }
64 // 2007-02-11: made the destructor virtual; thanks "double more" for pointing this out
65  virtual ~MTRand_int32() {} // destructor
66 protected: // used by derived classes, otherwise not accessible; use the ()-operator
67  unsigned long rand_int32() const; // generate 32 bit random integer
68 private:
69  static const int n;//
70  static const int m;//= 624, m = 397; // compile time constants
71 // the variables below are static (no duplicates can exist)
72  static unsigned long state[]; // state std::vector array
73  static int p; // position in state array
74  static bool init; // true if init function is called
75 // private functions used to generate the pseudo random numbers
76  unsigned long twiddle(unsigned long, unsigned long) const; // used by gen_state()
77  void gen_state() const; // generate new state
78 // make copy constructor and assignment operator unavailable, they don't make sense
79  MTRand_int32(const MTRand_int32&); // copy constructor not defined
80  void operator=(const MTRand_int32&); // assignment operator not defined
81 };
82 
83 // inline for speed, must therefore reside in header file
84 inline unsigned long MTRand_int32::twiddle(unsigned long u, unsigned long v) const {
85  return (((u & 0x80000000UL) | (v & 0x7FFFFFFFUL)) >> 1)
86  ^ ((v & 1UL) ? 0x9908B0DFUL : 0x0UL);
87 }
88 
89 inline unsigned long MTRand_int32::rand_int32() const { // generate 32 bit random int
90  if (p == n) gen_state(); // new state std::vector needed
91 // gen_state() is split off to be non-inline, because it is only called once
92 // in every 624 calls and otherwise irand() would become too big to get inlined
93  unsigned long x = state[p++];
94  x ^= (x >> 11);
95  x ^= (x << 7) & 0x9D2C5680UL;
96  x ^= (x << 15) & 0xEFC60000UL;
97  return x ^ (x >> 18);
98 }
99 
100 // generates double floating point numbers in the half-open interval [0, 1)
101 class MTRand : public MTRand_int32 {
102 public:
103  MTRand() : MTRand_int32() {}
104  MTRand(unsigned long seed) : MTRand_int32(seed) {}
105  MTRand(const unsigned long* seed, int size) : MTRand_int32(seed, size) {}
106  ~MTRand() {}
107  double operator()() const {
108  return static_cast<double>(rand_int32()) * (1. / 4294967296.); } // divided by 2^32
109 private:
110  MTRand(const MTRand&); // copy constructor not defined
111  void operator=(const MTRand&); // assignment operator not defined
112 };
113 
114 // generates double floating point numbers in the closed interval [0, 1]
115 class MTRand_closed : public MTRand_int32 {
116 public:
117  MTRand_closed() : MTRand_int32() {}
118  MTRand_closed(unsigned long seed) : MTRand_int32(seed) {}
119  MTRand_closed(const unsigned long* seed, int size) : MTRand_int32(seed, size) {}
120  ~MTRand_closed() {}
121  double operator()() {
122  return static_cast<double>(rand_int32()) * (1. / 4294967295.); } // divided by 2^32 - 1
123 private:
124  MTRand_closed(const MTRand_closed&); // copy constructor not defined
125  void operator=(const MTRand_closed&); // assignment operator not defined
126 };
127 
128 // generates double floating point numbers in the open interval (0, 1)
129 class MTRand_open : public MTRand_int32 {
130 public:
131  MTRand_open() : MTRand_int32() {}
132  MTRand_open(unsigned long seed) : MTRand_int32(seed) {}
133  MTRand_open(const unsigned long* seed, int size) : MTRand_int32(seed, size) {}
134  ~MTRand_open() {}
135  double operator()() {
136  return (static_cast<double>(rand_int32()) + .5) * (1. / 4294967296.); } // divided by 2^32
137 private:
138  MTRand_open(const MTRand_open&); // copy constructor not defined
139  void operator=(const MTRand_open&); // assignment operator not defined
140 };
141 
142 // generates 53 bit resolution doubles in the half-open interval [0, 1)
143 class MTRand53 : public MTRand_int32 {
144 public:
145  MTRand53() : MTRand_int32() {}
146  MTRand53(unsigned long seed) : MTRand_int32(seed) {}
147  MTRand53(const unsigned long* seed, int size) : MTRand_int32(seed, size) {}
148  ~MTRand53() {}
149  double operator()() {
150  return (static_cast<double>(rand_int32() >> 5) * 67108864. +
151  static_cast<double>(rand_int32() >> 6)) * (1. / 9007199254740992.); }
152 private:
153  MTRand53(const MTRand53&); // copy constructor not defined
154  void operator=(const MTRand53&); // assignment operator not defined
155 };
156 
157 #endif // MTRAND_H
Definition: mtrand.h:143
Definition: mtrand.h:115
Definition: mtrand.h:51
Definition: mtrand.h:129
Definition: mtrand.h:101