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 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
|
/***************************** randomc.h **********************************
* Author: Agner Fog
* Date created: 1997
* Last modified: 2011-08-05
* Project: randomc.h
* Source URL: www.agner.org/random
*
* Description:
* This header file contains class declarations and other definitions for the
* randomc class library of uniform random number generators in C++ language.
*
* 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 - 2011 Agner Fog.
* GNU General Public License www.gnu.org/copyleft/gpl.html
*******************************************************************************/
#ifndef RANDOMC_H
#define RANDOMC_H
#include <stdio.h>
#ifdef __INTEL_COMPILER
#include <mathimf.h> // Intel math function library
#else
#include <math.h> // default math function linrary
#endif
// Define 32 bit signed and unsigned integers.
// Change these definitions, if necessary, on 64 bit computers
#if defined(_WIN16) || defined(__MSDOS__) || defined(_MSDOS) // 16 bit system
typedef long int int32; // 32 bit signed integer
typedef unsigned long int uint32; // 32 bit unsigned integer
#else
typedef int int32; // 32 bit signed integer
typedef unsigned int uint32; // 32 bit unsigned integer
#endif
/***********************************************************************
System-specific user interface functions
***********************************************************************/
void EndOfProgram(void); // system-specific exit code (userintf.cpp)
void FatalError(const char * ErrorText); // system-specific error reporting (userintf.cpp)
/***********************************************************************
Different random number generator classes
***********************************************************************/
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 {LITTLE_ENDIAN1, BIG_ENDIAN1, 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 {LITTLE_ENDIAN1, BIG_ENDIAN1, 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 {LITTLE_ENDIAN1, BIG_ENDIAN1, 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
|