-
Notifications
You must be signed in to change notification settings - Fork 2
/
randomc.h
180 lines (170 loc) · 6.75 KB
/
randomc.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
/***************************** RANDOMC.H *********************** 2001-10-24 AF *
*
* This file contains class declarations for the C++ library of uniform
* random number generators.
*
* Overview of classes:
* ====================
*
* class TRandomMersenne:
* Random number generator of type Mersenne twister.
* Source file mersenne.cpp
*
* class TRandomMotherOfAll:
* Random number generator of type Mother-of-All (Multiply with carry).
* Source file mother.cpp
*
* class TRanrotBGenerator:
* Random number generator of type RANROT-B.
* Source file ranrotb.cpp
*
* class TRanrotWGenerator:
* Random number generator of type RANROT-W.
* Source file ranrotw.cpp
*
* class TRandomMotRot:
* Combination of Mother-of-All and RANROT-W generators.
* Source file ranmoro.cpp and motrot.asm.
* Coded in assembly language for improved speed.
* Must link in RANDOMAO.LIB or RANDOMAM.LIB.
*
*
* Member functions (methods):
* ===========================
*
* All these classes have identical member functions:
*
* Constructor(uint32 seed):
* The seed can be any integer. Usually the time is used as seed.
* Executing a program twice with the same seed will give the same sequence of
* random numbers. A different seed will give a different sequence.
*
* void RandomInit(uint32 seed);
* Re-initializes the random number generator with a new seed.
*
* void RandomInitByArray(uint32 seeds[], int length);
* In TRandomMersenne only: Use this function if you want to initialize with
* a seed with more than 32 bits. All bits in the seeds[] array will influence
* the sequence of random numbers generated. length is the number of entries
* in the seeds[] array.
*
* double Random();
* Gives a floating point random number in the interval 0 <= x < 1.
* The resolution is 32 bits in TRanrotBGenerator, TRandomMotherOfAll and
* TRandomMersenne. 52 or 63 bits in TRanrotWGenerator. 63 bits in
* TRandomMotRot.
*
* int IRandom(int min, int max);
* Gives an integer random number in the interval min <= x <= max.
* (max-min < MAXINT).
* The resolution is the same as for Random().
*
* uint32 BRandom();
* Gives 32 random bits.
* Only available in the classes TRanrotWGenerator and TRandomMersenne.
*
*
* Example:
* ========
* The file EX-RAN.CPP contains an example of how to generate random numbers.
*
*
* Further documentation:
* ======================
* The file randomc.htm contains further documentation on these random number
* generators.
*
* © 1997 - 2004 Agner Fog.
* GNU General Public License www.gnu.org/copyleft/gpl.html
*******************************************************************************/
#ifndef RANDOMC_H
#define RANDOMC_H
#include <math.h>
#include <assert.h>
#include <stdio.h>
/* Define 32 bit signed and unsigned integers. */
/* Change these definitions, if necessary, on 64 bit computers. */
typedef signed long int32;
typedef unsigned long uint32;
class TRandomMersenne { /* encapsulate random number generator */
#if 0 /* define constants for MT11213A (32 bit constants cannot be defined as enum in 16-bit compilers) */
#define MERS_N 351
#define MERS_M 175
#define MERS_R 19
#define MERS_U 11
#define MERS_S 7
#define MERS_T 15
#define MERS_L 17
#define MERS_A 0xE4BD75F5
#define MERS_B 0x655E5280
#define MERS_C 0xFFD58000
#else /* or constants for MT19937 */
#define MERS_N 624
#define MERS_M 397
#define MERS_R 31
#define MERS_U 11
#define MERS_S 7
#define MERS_T 15
#define MERS_L 18
#define MERS_A 0x9908B0DF
#define MERS_B 0x9D2C5680
#define MERS_C 0xEFC60000
#endif
public:
TRandomMersenne(uint32 seed) { /* constructor */
RandomInit(seed);}
void RandomInit(uint32 seed); /* re-seed */
void RandomInitByArray(uint32 seeds[], int length); /* seed by more than 32 bits */
int IRandom(int min, int max); /* output random integer */
double Random(); /* output random float */
uint32 BRandom(); /* output random bits */
private:
uint32 mt[MERS_N]; /* state vector */
int mti; /* index into mt */
enum TArch {LITTLEENDIAN, BIGENDIAN, NONIEEE};
TArch Architecture; /* conversion to float depends on computer architecture */
};
class TRanrotBGenerator { /* encapsulate random number generator */
enum constants { /* define parameters */
KK = 17, JJ = 10, R1 = 13, R2 = 9};
public:
void RandomInit(uint32 seed); /* initialization */
int IRandom(int min, int max); /* get integer random number in desired interval */
double Random(); /* get floating point random number */
TRanrotBGenerator(uint32 seed); /* constructor */
protected:
int p1, p2; /* indexes into buffer */
uint32 randbuffer[KK]; /* history buffer */
uint32 randbufcopy[KK*2]; /* used for self-test */
enum TArch {LITTLEENDIAN, BIGENDIAN, NONIEEE};
TArch Architecture; // conversion to float depends on computer architecture */
};
class TRanrotWGenerator { /* encapsulate random number generator */
enum constants { /* define parameters */
KK = 17, JJ = 10, R1 = 19, R2 = 27};
public:
void RandomInit(uint32 seed); /* initialization */
int IRandom(int min, int max); /* get integer random number in desired interval */
long double Random(); /* get floating point random number */
uint32 BRandom(); /* output random bits */
TRanrotWGenerator(uint32 seed); /* constructor */
protected:
int p1, p2; /* indexes into buffer */
union { /* used for conversion to float */
long double randp1;
uint32 randbits[3];};
uint32 randbuffer[KK][2]; /* history buffer */
uint32 randbufcopy[KK*2][2]; /* used for self-test */
enum TArch {LITTLEENDIAN, BIGENDIAN, NONIEEE, EXTENDEDPRECISIONLITTLEENDIAN};
TArch Architecture; /* conversion to float depends on computer architecture */
};
class TRandomMotherOfAll { /* encapsulate random number generator */
public:
void RandomInit(uint32 seed); /* initialization */
int IRandom(int min, int max); /* get integer random number in desired interval */
double Random(); /* get floating point random number */
TRandomMotherOfAll(uint32 seed); /* constructor */
protected:
double x[5]; /* history buffer */
};
#endif