Documentation - LibraryRandom

Reference Manual

Generated by Doxygen 1.6.3

Sun Dec 4 13:06:32 2011

Contents

1 Namespace Index 1

1.1 Namespace List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

2 Class Index 3

2.1 Class Hierarchy . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

3 Class Index 5

3.1 Class List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

4 File Index 7

4.1 File List . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7

5 Namespace Documentation 9

5.1 RNG Namespace Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

5.1.1 Detailed Description . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

5.1.2 Function Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

5.1.2.1 swap . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

6 Class Documentation 11

6.1 RNG::BoxMuller Class Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11


6.1.2 Constructor & Destructor Documentation . . . . . . . . . . . . . . . . . . . . . . 14

6.1.2.1 BoxMuller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

6.1.2.2 BoxMuller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

6.1.3 Member Function Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . 14

6.1.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

6.2 RNG::Distribution Class Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16



6.2.2.1 Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

ii CONTENTS

6.2.2.2 Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18


6.2.3.1 Bernoulli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18

6.2.3.2 Binomial . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6.2.3.3 Chisquare . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6.2.3.4 Equilikely . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

6.2.3.5 Erlang . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

6.2.3.6 Exponential . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

6.2.3.7 Geometric . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.2.3.8 Lognormal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

6.2.3.9 Normal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6.2.3.10 Pascal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

6.2.3.11 Poisson . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

6.2.3.12 Student . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

6.2.3.13 Uniform . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

6.3 RNG::MersenneTwisterDouble Class Reference . . . . . . . . . . . . . . . . . . . . . . . 25



6.3.2.1 MersenneTwisterDouble . . . . . . . . . . . . . . . . . . . . . . . . . . 27



6.3.2.4 ∼MersenneTwisterDouble . . . . . . . . . . . . . . . . . . . . . . . . . 27


6.3.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

6.4 RNG::MersenneTwisterDouble53 Class Reference . . . . . . . . . . . . . . . . . . . . . 29



6.4.2.1 MersenneTwisterDouble53 . . . . . . . . . . . . . . . . . . . . . . . . 31



6.4.2.4 ∼MersenneTwisterDouble53 . . . . . . . . . . . . . . . . . . . . . . . 31


6.4.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

6.5 RNG::MersenneTwisterDoubleClosed Class Reference . . . . . . . . . . . . . . . . . . . 33



Generated on Sun Dec 4 13:06:32 2011 by Doxygen

CONTENTS iii

6.5.2.1 MersenneTwisterDoubleClosed . . . . . . . . . . . . . . . . . . . . . . 35



6.5.2.4 ∼MersenneTwisterDoubleClosed . . . . . . . . . . . . . . . . . . . . . 35


6.5.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

6.6 RNG::MersenneTwisterDoubleOpened Class Reference . . . . . . . . . . . . . . . . . . . 37



6.6.2.1 MersenneTwisterDoubleOpened . . . . . . . . . . . . . . . . . . . . . 39



6.6.2.4 ∼MersenneTwisterDoubleOpened . . . . . . . . . . . . . . . . . . . . 39


6.6.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

6.7 RNG::MersenneTwisterInt32 Class Reference . . . . . . . . . . . . . . . . . . . . . . . . 41



6.7.2.1 MersenneTwisterInt32 . . . . . . . . . . . . . . . . . . . . . . . . . . . 42



6.7.2.4 ∼MersenneTwisterInt32 . . . . . . . . . . . . . . . . . . . . . . . . . . 42


6.7.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

6.7.3.2 rand_int32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6.7.3.3 Seed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

6.7.3.4 Seed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44

6.8 RNG::R250Base Class Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45



6.8.2.1 R250Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6.8.2.2 R250Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46


6.8.3.1 myrand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6.8.3.2 mysrand . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46

6.8.3.3 r250_init . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47


iv CONTENTS

6.8.4 Member Data Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

6.8.4.1 r250_buffer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47

6.8.4.2 r250_index . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

6.8.4.3 seed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

6.9 RNG::R250Double Class Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49



6.9.2.1 R250Double . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6.9.2.2 R250Double . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51


6.9.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6.10 RNG::R250Int Class Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52



6.10.2.1 R250Int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

6.10.2.2 R250Int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54


6.10.3.1 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54

6.10.3.2 operator() . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55

6.11 RNG::RandomNumberGenerator Class Reference . . . . . . . . . . . . . . . . . . . . . . 56



6.11.2.1 RandomNumberGenerator . . . . . . . . . . . . . . . . . . . . . . . . 57

6.11.2.2 RandomNumberGenerator . . . . . . . . . . . . . . . . . . . . . . . . 57

6.11.2.3 ∼RandomNumberGenerator . . . . . . . . . . . . . . . . . . . . . . . 57


6.11.3.1 ClockRandomSeed . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

6.11.3.2 GetDouble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6.11.3.3 GetDouble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6.11.3.4 GetDouble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

6.11.3.5 GetInt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

6.11.3.6 GetInt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

6.11.3.7 GetInt . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

6.11.3.8 InitSeed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6.11.3.9 Random . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60

6.11.3.10 Seed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61


CONTENTS v

7 File Documentation 63

7.1 RandomNumberGenerator.cxx File Reference . . . . . . . . . . . . . . . . . . . . . . . . 63

7.2 RandomNumberGenerator.cxx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64

7.3 RandomNumberGenerator.h File Reference . . . . . . . . . . . . . . . . . . . . . . . . . 72

7.4 RandomNumberGenerator.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73

7.5 Sys-LibraryRandom.cpp File Reference . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

7.5.1 Function Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

7.5.1.1 main . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

7.6 Sys-LibraryRandom.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79


Chapter 1

Namespace Index

1.1 Namespace List

Here is a list of all namespaces with brief descriptions:

RNG . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

Chapter 2

Class Index

2.1 Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

RNG::MersenneTwisterInt32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41RNG::MersenneTwisterDouble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25RNG::MersenneTwisterDouble53 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29RNG::MersenneTwisterDoubleClosed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33RNG::MersenneTwisterDoubleOpened . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

RNG::R250Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45RNG::R250Double . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49RNG::R250Int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

RNG::RandomNumberGenerator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56RNG::BoxMuller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11RNG::Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16

Chapter 3

Class Index

3.1 Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

RNG::BoxMuller . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11RNG::Distribution . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16RNG::MersenneTwisterDouble . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25RNG::MersenneTwisterDouble53 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29RNG::MersenneTwisterDoubleClosed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33RNG::MersenneTwisterDoubleOpened . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37RNG::MersenneTwisterInt32 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41RNG::R250Base . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45RNG::R250Double . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49RNG::R250Int . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52RNG::RandomNumberGenerator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56

6 Class Index


Chapter 4

File Index

4.1 File List

Here is a list of all files with brief descriptions:

RandomNumberGenerator.cxx . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63RandomNumberGenerator.h . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72Sys-LibraryRandom.cpp . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 78

8 File Index


Chapter 5

Namespace Documentation

5.1 RNG Namespace Reference

Classes

• class RandomNumberGenerator• class MersenneTwisterInt32• class MersenneTwisterDouble• class MersenneTwisterDoubleClosed• class MersenneTwisterDoubleOpened• class MersenneTwisterDouble53• class R250Base• class R250Int• class R250Double• class BoxMuller• class Distribution

Functions

• template<typename T >

void swap (T &a, T &b)

5.1.1 Detailed Description

Namespace RandomNumberGenerator

RNG - RandomNumberGenerator Namespace para os algoritmos de geracao de numeros pseudo-aleatóriosem suas diversas implementacoes.

5.1.2 Function Documentation

5.1.2.1 template<typename T > void RNG::swap (T & a, T & b) [inline]

Definition at line 686 of file RandomNumberGenerator.h.

10 Namespace Documentation

00686 { T temp(a); a = b; b = temp; };

Here is the caller graph for this function:

RNG::swap

RNG::Distribution::Equilikely

RNG::Distribution::Uniform


Chapter 6

Class Documentation

6.1 RNG::BoxMuller Class Reference

#include <RandomNumberGenerator.h>

12 Class Documentation

Inheritance diagram for RNG::BoxMuller:

RNG::BoxMuller

+ BoxMuller()+ BoxMuller()+ operator()()

RNG::RandomNumberGenerator

- _seed

+ RandomNumberGenerator()+ RandomNumberGenerator()+ InitSeed()+ ClockRandomSeed()+ Seed()+ GetInt()+ GetInt()+ GetInt()+ GetDouble()+ Random()+ GetDouble()+ GetDouble()+ ~RandomNumberGenerator()


6.1 RNG::BoxMuller Class Reference 13

Collaboration diagram for RNG::BoxMuller:

RNG::BoxMuller



- _seed


Public Member Functions

• BoxMuller ()• BoxMuller (unsigned long seed)• double operator() (double Mean, double StandardDev)


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo a distribuição Box-Muller ou Forma Polar da Transformação Box-Muller, caracterizado como um método simples de geraçãode números aleatórios em distribução normal através de números aleatórios uniformemente distrbuídos,ou seja, o algoritmo converte sequências de distribuição uniforme U(0,1) em sequências com distribuiçãogaussiana N(0,1).




6.1.2 Constructor & Destructor Documentation

6.1.2.1 RNG::BoxMuller::BoxMuller () [inline]

Método construtor da classe de geracao de numeros aleatórios


00542 : RandomNumberGenerator() {};

6.1.2.2 RNG::BoxMuller::BoxMuller (unsigned long seed) [inline]

Método construtor que recebe uma semente inicial


00547 : RandomNumberGenerator(seed) {};

6.1.3 Member Function Documentation

6.1.3.1 double RNG::BoxMuller::operator() (double Mean, double StandardDev)

Overload do operador () fazendo com que o objeto criado tenha um aspecto de objeto-função. Esse métodoretorna números pseudo-aleatório reais distribuídos dentro intervalo compreendido entre 0 e 1. Parâmetros: Mean - Média , StandardDev - Desvio Padrão

Classe para geração de números pseudo-aleatórios que tem como principal algoritmo a distribuição Box-Muller ou Forma Polar da Transformação Box-Muller, caracterizado como um método simples de geraçãode números aleatórios em distribução normal através de números aleatórios uniformemente distrbuídos,ou seja, o algoritmo converte sequências de distribuição uniforme U(0,1) em sequências com distribuiçãogaussiana N(0,1). Overload do operador () fazendo com que o objeto criado tenha um aspecto de objeto-função. Esse método retorna números pseudo-aleatório reais distribuídos dentro intervalo compreendidoentre 0 e 1.

Definition at line 448 of file RandomNumberGenerator.cxx.

00454 {00455 float x1, x2, w, y1;00456 static float y2;00457 static bool use_last = false;0045800459 //Verifica se o valor usado deve ser o da última chamada00460 if (use_last)00461 {00462 y1 = y2;00463 use_last = false;00464 }00465 else00466 {0046700468 //Calculo da localização do número dentro do intervalo passado00469 do00470 {00471 x1 = 2.0 * GetDouble() - 1.0;00472 x2 = 2.0 * GetDouble() - 1.0;00473 w = x1 * x1 + x2 * x2;00474 }00475 while ( w >= 1.0 );


6.1 RNG::BoxMuller Class Reference 15

0047600477 w = sqrt( (-2.0 * log( w ) ) / w );00478 y1 = x1 * w;00479 y2 = x2 * w;00480 use_last = true;

The documentation for this class was generated from the following files:

• RandomNumberGenerator.h• RandomNumberGenerator.cxx



6.2 RNG::Distribution Class Reference


Inheritance diagram for RNG::Distribution:

RNG::Distribution

+ Distribution()+ Distribution()+ Bernoulli()+ Binomial()+ Equilikely()+ Geometric()+ Pascal()+ Poisson()+ Uniform()+ Exponential()+ Erlang()+ Normal()+ Lognormal()+ Chisquare()+ Student()


- _seed



6.2 RNG::Distribution Class Reference 17

Collaboration diagram for RNG::Distribution:

RNG::Distribution



- _seed



• Distribution ()• Distribution (unsigned long seed)• long Bernoulli (double probability=0.5)• long Binomial (unsigned long limit_experiment, double probability=0.5)• long Equilikely (long a, long b)• unsigned long Geometric (double probability=0.5)• long Pascal (unsigned long limit_experiment, double probability=0.5)• long Poisson (double mean)• double Uniform (double a, double b)• double Exponential (double mean=0.5)• double Erlang (long limit_experiment, double base)• double Normal (double Mean, double StandarDev)• double Lognormal (double a, double b)



• double Chisquare (unsigned long limit_experiment)• double Student (unsigned long limit_experiment)


Classe para geração de números pseudo-aleatórios que possui em seu núcleo um gerador com distribuiçãouniforme - no caso específico dessa classe usaremos a ancestral RandomNumberGenerator para gerar essadistribuição uniforme e a partir desse ’motor’ iremos gerar os demais tipos de distribuição. Com issoteremos para a classe Distribuition 6 distribuições discretas :

Generator Range (x) Mean Variance

Bernoulli(p) x = 0,1 p p∗(1-p) Binomial(n, p) x = 0,...,n n∗p n∗p∗(1-p) Equilikely(a, b) x = a,...,b (a+b)/2((b-a+1)∗(b-a+1)-1)/12 Geometric(p) x = 0,... p/(1-p) p/((1-p)∗(1-p)) Pascal(n, p) x = 0,... n∗p/(1-p)n∗p/((1-p)∗(1-p)) Poisson(m) x = 0,... m m

E sete distribuições contínuas :

Uniform(a, b) a < x < b (a + b)/2 (b - a)∗(b - a)/12 Exponential(m) x > 0 m m∗m Erlang(n, b) x > 0 n∗bn∗b∗b Normal(m, s) all x m s∗s Lognormal(a, b) x > 0 (ver abaixo) Chisquare(n) x > 0 n 2∗n Student(n)all x 0 (n > 1) n/(n - 2) (n > 2)

Para a Lognormal(a, b), sua média e sua variância serão dadas por:

mean = exp(a + 0.5∗b∗b) variance = (exp(b∗b) - 1) ∗ exp(2∗a + b∗b)



6.2.2.1 RNG::Distribution::Distribution () [inline]



00597 : RandomNumberGenerator() {};

6.2.2.2 RNG::Distribution::Distribution (unsigned long seed) [inline]



00602 : RandomNumberGenerator(seed) {};


6.2.3.1 long RNG::Distribution::Bernoulli (double probability = 0.5)

Método que retorna 1 com probabilidade p ou 0 com probabilidade (1-p). Para isso p deverá estar com-preendido no intervalo aberto 0.0 e 1.0 - (0.0, 1.0) Adotamos aqui 0.5 como 50% de chance do númerorandômico ser maior ou menor que o número internamente escolhido pelo método.



Classe para geração de números pseudo-aleatórios que possui em seu núcleo um gerador com distribuiçãouniforme - no caso específico dessa classe usaremos a ancestral RandomNumberGenerator para gerar essadistribuição uniforme e a partir desse ’motor’ iremos gerar os demais tipos de distribuição. Com issoMétodo que retorna 1 com probabilidade p ou 0 com probabilidade (1-p). Para isso ’p’ deverá estar com-preendido no intervalo aberto 0.0 e 1.0 - (0.0, 1.0)


Here is the call graph for this function:

RNG::Distribution::Bernoulli RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble


RNG::Distribution::Bernoulli RNG::Distribution::Binomial

6.2.3.2 long RNG::Distribution::Binomial (unsigned long limit_experiment, double probability =0.5)

Método que retorna um inteiro distribuído de forma binomial entre 0 e limit Nota : use limit > 0 e 0.0 <probabilidade < 1.0


00507 : use limit > 0 e 0.0 < probabilidade < 1.000508 */00509 long Distribution::Binomial (unsigned long limit_experiment, double probability)


RNG::Distribution::Binomial RNG::Distribution::Bernoulli RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble

6.2.3.3 double RNG::Distribution::Chisquare (unsigned long limit_experiment)

Método que retorna um número real com distribuição Chi-square. Nota: use limit_experiment > 0


00633 : use limit_experiment > 000634 **/00635 double Distribution::Chisquare(unsigned long limit_experiment)00636 {00637 unsigned long i;00638 double z, x = 0.0;0063900640 for (i = 0; i < limit_experiment; i++)00641 {00642 z = Normal(0.0, 1.0);




RNG::Distribution::Chisquare RNG::Distribution::Normal RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble


RNG::Distribution::Chisquare RNG::Distribution::Student

6.2.3.4 long RNG::Distribution::Equilikely (long a, long b)

Método que retorna um inteiro eqüitativamente distribuído compreendido no intervalo semi-aberto (a,b].




RNG::RandomNumberGenerator::Random

RNG::swap

RNG::RandomNumberGenerator::GetDouble

6.2.3.5 double RNG::Distribution::Erlang (long limit_experiment, double base)

Método que retorna um número real positivo com distribuição de Erlang. Nota: use limit_experiment > 0e base > 0.0


00585 : use limit_experiment > 0 e base > 0.000586 **/00587 double Distribution::Erlang(long limit_experiment, double base)00588 {


RNG::Distribution::Erlang RNG::Distribution::Exponential RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble

6.2.3.6 double RNG::Distribution::Exponential (double mean = 0.5)

Método que retorna um número real positivo exponencialmente distribuído. Nota: use mean > 0.0


00576 : use mean > 0.0




RNG::Distribution::Exponential RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble


RNG::Distribution::Exponential

RNG::Distribution::Erlang

RNG::Distribution::Poisson

6.2.3.7 unsigned long RNG::Distribution::Geometric (double probability = 0.5)

Método que retorna um inteiro não negativo geometricamente distribuído. Nota: use 0.0 < p < 1.0


00528 : use 0.0 < p < 1.0


RNG::Distribution::Geometric RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble


RNG::Distribution::Geometric RNG::Distribution::Pascal

6.2.3.8 double RNG::Distribution::Lognormal (double a, double b)

Método que retorna um número real com distribuição lognormal. Nota: use b > 0.0


00624 : use b > 0.0


RNG::Distribution::Lognormal RNG::Distribution::Normal RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble



6.2.3.9 double RNG::Distribution::Normal (double Mean, double StandarDev)

Método que retorna um número real com distribuição normal (gaussiana). Nota: use StandardDev > 0.0


00597 : use StandardDev > 0.000598 **/00599 double Distribution::Normal(double Mean, double StandarDev)00600 {00601 const double p0 = 0.322232431088; const double q0 = 0.099348462606;00602 const double p1 = 1.0; const double q1 = 0.588581570495;00603 const double p2 = 0.342242088547; const double q2 = 0.531103462366;00604 const double p3 = 0.204231210245e-1; const double q3 = 0.103537752850;00605 const double p4 = 0.453642210148e-4; const double q4 = 0.385607006340e-2;00606 double u, t, p, q, z;0060700608 u = Random();0060900610 if (u < 0.5) t = sqrt(-2.0 * log(u));00611 else t = sqrt(-2.0 * log(1.0 - u));0061200613 p = p0 + t * (p1 + t * (p2 + t * (p3 + t * p4)));00614 q = q0 + t * (q1 + t * (q2 + t * (q3 + t * q4)));00615


RNG::Distribution::Normal RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble


RNG::Distribution::Normal

RNG::Distribution::Chisquare

RNG::Distribution::Student

RNG::Distribution::Lognormal

6.2.3.10 long RNG::Distribution::Pascal (unsigned long limit_experiment, double probability =0.5)

Método que retorna um inteiro não negativo com distribuição de Pascal. Nota: use n > 0 e 0.0 < p < 1.0


00537 : use n > 0 e 0.0 < p < 1.000538 **/00539 long Distribution::Pascal(unsigned long limit_experiment, double probability)


RNG::Distribution::Pascal RNG::Distribution::Geometric RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble



6.2.3.11 long RNG::Distribution::Poisson (double mean)

Método que retorna um inteiro não negativo com distribuição de Poisson. Nota: use mean > 0


00548 : use mean > 000549 **/00550 long Distribution::Poisson(double mean)00551 {00552 double t = 0.0;00553 long x = 0;0055400555 while (t < mean)00556 {00557 t += Exponential(1.0);


RNG::Distribution::Poisson RNG::Distribution::Exponential RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble

6.2.3.12 double RNG::Distribution::Student (unsigned long limit_experiment)

Método que retorna um número real com distribuição Student-t. Nota: use limit_experiment > 0


00651 : use limit_experiment > 0




RNG::Distribution::Normal RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble

6.2.3.13 double RNG::Distribution::Uniform (double a, double b)

Método que retorna um número real uniformemente distribuído entre a e b. Nota: use a < b.


00566 : use a < b.00567 **/




RNG::swap




6.3 RNG::MersenneTwisterDouble Class Reference 25

6.3 RNG::MersenneTwisterDouble Class Reference


Inheritance diagram for RNG::MersenneTwisterDouble:

RNG::MersenneTwisterDouble

+ MersenneTwisterDouble()+ MersenneTwisterDouble()+ MersenneTwisterDouble()+ operator()()+ ~MersenneTwisterDouble()- MersenneTwisterDouble()- operator=()

RNG::MersenneTwisterInt32

- n- m- state- p- init

+ MersenneTwisterInt32()+ MersenneTwisterInt32()+ MersenneTwisterInt32()+ Seed()+ Seed()+ operator()()+ ~MersenneTwisterInt32()# rand_int32()- twiddle()- gen_state()- MersenneTwisterInt32()- operator=()



Collaboration diagram for RNG::MersenneTwisterDouble:







• MersenneTwisterDouble ()• MersenneTwisterDouble (unsigned long seed)• MersenneTwisterDouble (const unsigned long ∗seed, int size)• double operator() ()• ∼MersenneTwisterDouble ()


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’Mersenne TwisterPseudo-random Number Generator’ que possui periodicidade de 2∧19937-1. A classe abaixo retornanúmeros em ponto flutuante no intervalo semi-aberto [0,1).



6.3 RNG::MersenneTwisterDouble Class Reference 27


6.3.2.1 RNG::MersenneTwisterDouble::MersenneTwisterDouble () [inline]

Método construtor da classe de geracao de numeros aleatorios


00210 : MersenneTwisterInt32() {};

6.3.2.2 RNG::MersenneTwisterDouble::MersenneTwisterDouble (unsigned long seed)[inline]

Método construtor que recebe um chave de 32 bits como semente


00215 : MersenneTwisterInt32(seed) {};

6.3.2.3 RNG::MersenneTwisterDouble::MersenneTwisterDouble (const unsigned long ∗ seed, intsize) [inline]

Método construtor que recebe um array inteiro de 32 bits e o tamanho do array como semente de geraçãode números


00222 : MersenneTwisterInt32(seed, size) {};

6.3.2.4 RNG::MersenneTwisterDouble::∼MersenneTwisterDouble () [inline]

Método destrutor da classe responsável por desalocar qualquer recurso previamente alocado retornando omesmo ao sistema .


00235 {};


6.3.3.1 double RNG::MersenneTwisterDouble::operator() () [inline]

Overload do operador () fazendo com que o objeto criado tenha um aspecto de objeto-função.

Reimplemented from RNG::MersenneTwisterInt32.


00229 { return static_cast<double>(rand_int32()) * (1. / 4294967296.); } // divisão por 2^32




RNG::MersenneTwisterDouble::operator() RNG::MersenneTwisterInt32::rand_int32

The documentation for this class was generated from the following file:

• RandomNumberGenerator.h


6.4 RNG::MersenneTwisterDouble53 Class Reference 29

6.4 RNG::MersenneTwisterDouble53 Class Reference


Inheritance diagram for RNG::MersenneTwisterDouble53:

RNG::MersenneTwisterDouble53

+ MersenneTwisterDouble53()+ MersenneTwisterDouble53()+ MersenneTwisterDouble53()+ operator()()+ ~MersenneTwisterDouble53()- MersenneTwisterDouble53()- operator=()






Collaboration diagram for RNG::MersenneTwisterDouble53:







• MersenneTwisterDouble53 ()• MersenneTwisterDouble53 (unsigned long seed)• MersenneTwisterDouble53 (const unsigned long ∗seed, int size)• double operator() ()• ∼MersenneTwisterDouble53 ()


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’Mersenne TwisterPseudo-random Number Generator’ que possui periodicidade de 2∧19937-1. A classe abaixo retornanúmeros em ponto flutuante com uma resolução de até 53 bits no intervalo semi-aberto [0,1) .



6.4 RNG::MersenneTwisterDouble53 Class Reference 31


6.4.2.1 RNG::MersenneTwisterDouble53::MersenneTwisterDouble53 () [inline]




6.4.2.2 RNG::MersenneTwisterDouble53::MersenneTwisterDouble53 (unsigned long seed)[inline]

Método construtor que recebe uma chave de 32 bits como semente



6.4.2.3 RNG::MersenneTwisterDouble53::MersenneTwisterDouble53 (const unsigned long ∗ seed,int size) [inline]




6.4.2.4 RNG::MersenneTwisterDouble53::∼MersenneTwisterDouble53 () [inline]



00404 {};


6.4.3.1 double RNG::MersenneTwisterDouble53::operator() () [inline]




00395 {00396 return (static_cast<double>(rand_int32() >> 5) * 67108864. +00397 static_cast<double>(rand_int32() >> 6)) * (1. / 9007199254740992.

);00398 }




RNG::MersenneTwisterDouble53::operator() RNG::MersenneTwisterInt32::rand_int32




6.5 RNG::MersenneTwisterDoubleClosed Class Reference 33

6.5 RNG::MersenneTwisterDoubleClosed Class Reference


Inheritance diagram for RNG::MersenneTwisterDoubleClosed:

RNG::MersenneTwisterDoubleClosed

+ MersenneTwisterDoubleClosed()+ MersenneTwisterDoubleClosed()+ MersenneTwisterDoubleClosed()+ operator()()+ ~MersenneTwisterDoubleClosed()- MersenneTwisterDoubleClosed()- operator=()






Collaboration diagram for RNG::MersenneTwisterDoubleClosed:







• MersenneTwisterDoubleClosed ()• MersenneTwisterDoubleClosed (unsigned long seed)• MersenneTwisterDoubleClosed (const unsigned long ∗seed, int size)• double operator() ()• ∼MersenneTwisterDoubleClosed ()


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’Mersenne TwisterPseudo-random Number Generator’ que possui periodicidade de 2∧19937-1. A classe abaixo retornanúmeros em ponto flutuante no intervalo fechado [0,1].



6.5 RNG::MersenneTwisterDoubleClosed Class Reference 35


6.5.2.1 RNG::MersenneTwisterDoubleClosed::MersenneTwisterDoubleClosed () [inline]




6.5.2.2 RNG::MersenneTwisterDoubleClosed::MersenneTwisterDoubleClosed (unsigned longseed) [inline]




6.5.2.3 RNG::MersenneTwisterDoubleClosed::MersenneTwisterDoubleClosed (const unsignedlong ∗ seed, int size) [inline]




6.5.2.4 RNG::MersenneTwisterDoubleClosed::∼MersenneTwisterDoubleClosed () [inline]



00290 {};


6.5.3.1 double RNG::MersenneTwisterDoubleClosed::operator() () [inline]




00284 { return static_cast<double>(rand_int32()) * (1. / 4294967295.); } // divisão por 2^32 - 1




RNG::MersenneTwisterDoubleClosed::operator() RNG::MersenneTwisterInt32::rand_int32




6.6 RNG::MersenneTwisterDoubleOpened Class Reference 37

6.6 RNG::MersenneTwisterDoubleOpened Class Reference


Inheritance diagram for RNG::MersenneTwisterDoubleOpened:

RNG::MersenneTwisterDoubleOpened

+ MersenneTwisterDoubleOpened()+ MersenneTwisterDoubleOpened()+ MersenneTwisterDoubleOpened()+ operator()()+ ~MersenneTwisterDoubleOpened()- MersenneTwisterDoubleOpened()- operator=()






Collaboration diagram for RNG::MersenneTwisterDoubleOpened:







• MersenneTwisterDoubleOpened ()• MersenneTwisterDoubleOpened (unsigned long seed)• MersenneTwisterDoubleOpened (const unsigned long ∗seed, int size)• double operator() ()• ∼MersenneTwisterDoubleOpened ()


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’Mersenne TwisterPseudo-random Number Generator’ que possui periodicidade de 2∧19937-1. A classe abaixo retornanúmeros em ponto flutuante no intervalo aberto (0,1).



6.6 RNG::MersenneTwisterDoubleOpened Class Reference 39


6.6.2.1 RNG::MersenneTwisterDoubleOpened::MersenneTwisterDoubleOpened () [inline]




6.6.2.2 RNG::MersenneTwisterDoubleOpened::MersenneTwisterDoubleOpened (unsigned longseed) [inline]




6.6.2.3 RNG::MersenneTwisterDoubleOpened::MersenneTwisterDoubleOpened (const unsignedlong ∗ seed, int size) [inline]




6.6.2.4 RNG::MersenneTwisterDoubleOpened::∼MersenneTwisterDoubleOpened () [inline]



00346 {};


6.6.3.1 double RNG::MersenneTwisterDoubleOpened::operator() () [inline]




00340 { return (static_cast<double>(rand_int32()) + .5) * (1. / 4294967296.); } // divisão por 2^32




RNG::MersenneTwisterDoubleOpened::operator() RNG::MersenneTwisterInt32::rand_int32




6.7 RNG::MersenneTwisterInt32 Class Reference 41

6.7 RNG::MersenneTwisterInt32 Class Reference


Inheritance diagram for RNG::MersenneTwisterInt32:













• MersenneTwisterInt32 ()• MersenneTwisterInt32 (unsigned long seed)• MersenneTwisterInt32 (const unsigned long ∗array, int size)• void Seed (unsigned long seed)• void Seed (const unsigned long ∗array, int size)• unsigned long operator() ()• virtual ∼MersenneTwisterInt32 ()

Protected Member Functions

• unsigned long rand_int32 ()


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’Mersenne TwisterPseudo-Random Number Generator’ que possui periodicidade de 2∧19937-1. A classe abaixo gera númeropseudo-aleatórios em formato inteiro sem sinal.





6.7.2.1 RNG::MersenneTwisterInt32::MersenneTwisterInt32 ()



6.7.2.2 RNG::MersenneTwisterInt32::MersenneTwisterInt32 (unsigned long seed)



00169 { if (!init) Seed(5489UL); init = true; };00170


RNG::MersenneTwisterInt32::MersenneTwisterInt32 RNG::MersenneTwisterInt32::Seed

6.7.2.3 RNG::MersenneTwisterInt32::MersenneTwisterInt32 (const unsigned long ∗ array, intsize)

Método construtor que recebe um array inteiro de 32 bits e o tamanho do array como semente de geração denúmeros. Um bom exemplo para uso com esse método seria : unsigned long init_seed[4]={0x123, 0x234,0x345, 0x456}, length=4; MersenneTwisterInt32 mt(init_seed, length);




RNG::MersenneTwisterInt32::MersenneTwisterInt32 RNG::MersenneTwisterInt32::Seed

6.7.2.4 RNG::MersenneTwisterInt32::∼MersenneTwisterInt32 () [virtual]


Metodo destrutor da classe



6.7.3.1 unsigned long RNG::MersenneTwisterInt32::operator() () [inline]



6.7 RNG::MersenneTwisterInt32 Class Reference 43

Reimplemented in RNG::MersenneTwisterDouble, RNG::MersenneTwisterDoubleClosed,RNG::MersenneTwisterDoubleOpened, and RNG::MersenneTwisterDouble53.


00186 { return rand_int32(); }


RNG::MersenneTwisterInt32::operator() RNG::MersenneTwisterInt32::rand_int32

6.7.3.2 unsigned long RNG::MersenneTwisterInt32::rand_int32 () [protected]

Método que gera um inteiro randômico de 32 bits


00253 {00254 //Caso seja necessario um novo estado para o vetor de estados00255 if (p == n) gen_state();0025600257 //O método gen_state() é dividido para ser inline, porque ele só é00258 //chamado uma vez a cada 624 chamadas de outro modo ele se tornaria muito00259 //grande para ser implementado como método inline.00260 unsigned long x = state[p++];


RNG::MersenneTwisterInt32::rand_int32

RNG::MersenneTwisterDouble53::operator()

RNG::MersenneTwisterDoubleOpened::operator()

RNG::MersenneTwisterDoubleClosed::operator()

RNG::MersenneTwisterDouble::operator()

RNG::MersenneTwisterInt32::operator()

6.7.3.3 void RNG::MersenneTwisterInt32::Seed (const unsigned long ∗ array, int size)

Geração de semente através de um array de inteiros de 32 bits


00211 {00212 Seed(19650218UL);00213 int i = 1, j = 0;0021400215 for (int k = ((n > size) ? n : size); k; --k)00216 {00217 state[i] = (state[i] ^ ((state[i - 1] ^ (state[i - 1] >> 30)) * 1664525UL))00218 + array[j] + j; // non linear



0021900220 state[i] &= 0xFFFFFFFFUL; // Para máquinas com mais de 32 bits0022100222 ++j; j %= size;00223 if ((++i) == n) { state[0] = state[n - 1]; i = 1; }00224 }0022500226 for (int k = n - 1; k; --k)00227 {00228 state[i] = (state[i] ^ ((state[i - 1] ^ (state[i - 1] >> 30))00229 * 1566083941UL)) - i;00230 state[i] &= 0xFFFFFFFFUL; // Para máquinas com mais de 32 bits00231 if ((++i) == n) { state[0] = state[n - 1]; i = 1; }00232 }0023300234 // O estado zero recebe 1 - assumindo um inicio de array não-nulo

6.7.3.4 void RNG::MersenneTwisterInt32::Seed (unsigned long seed)

Geração de semente através de um inteiro de 32 bits


00192 {00193 // Para máquinas com mais de 32 bits00194 state[0] = seed & 0xFFFFFFFFUL;0019500196 // Looping que obtem a nova semente para geração de números00197 for (int i = 1; i < n; ++i)00198 {00199 state[i] = 1812433253UL * (state[i - 1] ^ (state[i - 1] >> 30)) + i;00200 state[i] &= 0xFFFFFFFFUL; // Para máquinas com mais de 32 bits


RNG::MersenneTwisterInt32::Seed RNG::MersenneTwisterInt32::MersenneTwisterInt32




6.8 RNG::R250Base Class Reference 45

6.8 RNG::R250Base Class Reference


Inheritance diagram for RNG::R250Base:

RNG::R250Base

+ r250_index+ r250_buffer+ seed

+ R250Base()+ R250Base()+ r250_init()+ myrand()+ mysrand()

RNG::R250Double

+ R250Double()+ R250Double()+ operator()()

RNG::R250Int

+ R250Int()+ R250Int()+ operator()()+ operator()()


• R250Base ()• R250Base (unsigned long seed)• void r250_init (unsigned long seed)

Static Public Member Functions

• static unsigned myrand ()• static void mysrand (unsigned newseed)

Static Public Attributes

• static int r250_index = 0



• static unsigned int r250_buffer [250]• static unsigned long seed = 1


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’R250’ que possuiperiodicidade de 2∧250-1. A classe abaixo serve como base para as demais classes que usarão o algoritmoR250.



6.8.2.1 RNG::R250Base::R250Base () [inline]



00435 {};

6.8.2.2 RNG::R250Base::R250Base (unsigned long seed) [inline]

Método construtor que recebe uma chave como semente


00440 { r250_init(seed); }


RNG::R250Base::R250Base RNG::R250Base::r250_init


6.8.3.1 unsigned RNG::R250Base::myrand () [inline, static]

Método que retorna um número pseudo aleatório no intervalo entre 0 e 32768 Produzindo a seguinte se-quencia de números randômicos : 346, 130, 10982, 1090... (9996 numbers skipped) ...23369, 2020, 5703,12762, 10828, 16252, 28648, 27041, 23444, 6604...

Método que retorna um número pseudo-aleatório no intervalo entre 0 e 32768.


6.8.3.2 void RNG::R250Base::mysrand (unsigned newseed) [inline, static]

Inicializa a semente de geração rândomica usando o método de congruência linear

Inicializa a semente de geração usando o método de congruência linear



6.8 RNG::R250Base Class Reference 47

6.8.3.3 void RNG::R250Base::r250_init (unsigned long seed)

Inicializa o gerador de números aleatórios.


00329 {00330 int j, k;00331 unsigned int mask;00332 unsigned int msb;0033300334 mysrand(seed);00335 r250_index = 0;0033600337 for (j = 0; j < 250; j++) /* Fill the r250 buffer with 15-bit values */00338 r250_buffer[j] = myrand();0033900340 for (j = 0; j < 250; j++) /* Set some of the MS bits to 1 */00341 if (myrand() > 16384) r250_buffer[j] |= 0x8000;0034200343 msb = 0x8000; /* To turn on the diagonal bit */00344 mask = 0xffff; /* To turn off the leftmost bits */0034500346 for (j = 0; j < 16; j++)00347 {00348 k = 11 * j + 3; /* Select a word to operate on */00349 r250_buffer[k] &= mask; /* Turn off bits left of the diagonal */


RNG::R250Base::r250_init RNG::R250Base::R250Base

6.8.4 Member Data Documentation

6.8.4.1 unsigned int RNG::R250Base::r250_buffer [static]

Initial value:

{15301,57764,10921,56345,19316,43154,54727,49252,32360,49582,26124,25833,34404,11030,26232,13965,16051,63635,55860,5184,15931,39782,16845,11371,38624,10328,9139,1684,48668,59388,13297,1364,56028,15687,63279,27771,5277,44628,31973,46977,16327,23408,36065,52272,33610,61549,58364,3472,21367,56357,56345,54035,7712,55884,39774,10241,50164,47995,1718,46887,47892,6010,29575,54972,30458,21966,54449,10387,4492,644,57031,41607,61820,54588,40849,54052,59875,43128,50370,44691,286,12071,3574,61384,15592,45677,9711,23022,35256,45493,48913,146,9053,5881,36635,43280,53464,8529,34344,64955,38266,12730,101,16208,12607,58921,22036,8221,31337,11984,20290,26734,19552,48,31940,43448,34762,53344,60664,12809,57318,17436,44730,19375,30,17425,14117,5416,23853,55783,57995,32074,26526,2192,11447,11,53446,35152,64610,64883,26899,25357,7667,3577,39414,51161,4,58427,57342,58557,53233,1066,29237,36808,19370,17493,37568,3,61468,38876,17586,64937,21716,56472,58160,44955,55221,63880,1,32200,62066,22911,24090,10438,40783,36364,14999,2489,43284,9898,39612,9245,593,34857,41054,30162,65497,53340,27209,45417,37497,4612,58397,52910,56313,62716,22377,40310,15190,34471,64005,18090,11326,50839,62901,59284,5580,15231,9467,13161,



58500,7259,317,50968,2962,23006,32280,6994,18751,5148,52739,49370,51892,18552,52264,54031,2804,17360,1919,19639,2323,9448,43821,11022,45500,31509,49180,35598,38883,19754,987,11521,55494,38056,20664,2629,50986,31009,54043,59743

}


6.8.4.2 int RNG::R250Base::r250_index = 0 [static]


6.8.4.3 unsigned long RNG::R250Base::seed = 1 [static]





6.9 RNG::R250Double Class Reference 49

6.9 RNG::R250Double Class Reference


Inheritance diagram for RNG::R250Double:

RNG::R250Double


RNG::R250Base





Collaboration diagram for RNG::R250Double:

RNG::R250Double


RNG::R250Base




• R250Double ()

• R250Double (unsigned long seed)

• double operator() ()


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’R250’ que possuiperiodicidade de 2∧250-1. A classe abaixo retorna um número pseudo-aleatório real de precisão dupla nointervalo compreendido entre 0 e 1.



6.9 RNG::R250Double Class Reference 51


6.9.2.1 RNG::R250Double::R250Double () [inline]



00512 : R250Base() {};

6.9.2.2 RNG::R250Double::R250Double (unsigned long seed) [inline]



00517 : R250Base(seed) {};


6.9.3.1 double RNG::R250Double::operator() ()

Overload do operador () fazendo com que o objeto criado tenha um aspecto de objeto-função. Esse métodoretorna números pseudo-aleatório reais distribuídos dentro intervalo compreendido entre 0 e 1.


00420 {00421 register int j;00422 register unsigned int new_rand;0042300424 // Verifica limites de salto - Wrap pointer around00425 if (r250_index >= 147) j = r250_index - 147;00426 else j = r250_index + 103;0042700428 new_rand = r250_buffer[r250_index] ^= r250_buffer[j];0042900430 //Incrementa o ponteiro para o próximo salto dentro do vetor de sementes





6.10 RNG::R250Int Class Reference


Inheritance diagram for RNG::R250Int:

RNG::R250Int


RNG::R250Base




6.10 RNG::R250Int Class Reference 53

Collaboration diagram for RNG::R250Int:

RNG::R250Int


RNG::R250Base




• R250Int ()• R250Int (unsigned long seed)• unsigned int operator() ()• unsigned int operator() (unsigned int maximum_limit)


Classe para geração de números pseudo-aleatórios que tem como principal algoritmo o ’R250’ que possuiperiodicidade de 2∧250-1. A classe abaixo retorna um número pseudo-aleatório inteiro sem sinal uni-formemente distribuído no intervalo compreendido entre 0 e 65535.





6.10.2.1 RNG::R250Int::R250Int () [inline]



00476 : R250Base() {};

6.10.2.2 RNG::R250Int::R250Int (unsigned long seed) [inline]



00481 : R250Base(seed) {};


6.10.3.1 unsigned int RNG::R250Int::operator() (unsigned int maximum_limit)

Overload do operador () fazendo com que o objeto criado tenha um aspecto de objeto-função. Retorna umdeterminado número k inteiro sem sinal uniformmente distribuído dentro do intervalo compreendido entre0 e maximum_limit.

Overload do operador () fazendo com que o objeto criado tenha um aspecto de objeto-função. Retorna umdeterminado número k inteiro sem sinal uniformmente distribuído dentro do intervalo compreendido entre0 e limit.


00385 {00386 register int j;00387 register unsigned int new_rand, limit;00388 unsigned int n = maximum_limit;0038900390 // LImitede geração de números00391 limit = (65535U/n)*n;0039200393 do00394 {00395 //Usando o operador que retorna numeros entre 0 e 6553500396 new_rand = operator ()();0039700398 // Verifica limites de salto - Wrap pointer around00399 if (r250_index >= 147) j = r250_index - 147;00400 else j = r250_index + 103;0040100402 new_rand = r250_buffer[r250_index] ^= r250_buffer[j];0040300404 //Incrementa o ponteiro para o próximo salto dentro do vetor de sementes00405 if (r250_index >= 249) r250_index = 0;00406 else r250_index++;00407


6.10 RNG::R250Int Class Reference 55

6.10.3.2 unsigned int RNG::R250Int::operator() ()

Overload do operador () fazendo com que o objeto criado tenha um aspecto de objeto-função. Esse métodoretorna números pseudo-aleatório inteiros sem sinal uniformemente distribuídos dentro intervalo com-preendido entre 0 e 65535.


00362 {00363 register int j;00364 register unsigned int new_rand;0036500366 // Verifica limites de salto - Wrap pointer around00367 if (r250_index >= 147) j = r250_index - 147;00368 else j = r250_index + 103;0036900370 new_rand = r250_buffer[r250_index] ^= r250_buffer[j];0037100372 //Incrementa o ponteiro para o próximo salto dentro do vetor de sementes





6.11 RNG::RandomNumberGenerator Class Reference


Inheritance diagram for RNG::RandomNumberGenerator:


- _seed


RNG::BoxMuller


RNG::Distribution



• RandomNumberGenerator ()• RandomNumberGenerator (unsigned long seed)• void InitSeed (unsigned int seed=0)• unsigned int ClockRandomSeed (unsigned int myseed=0)• unsigned int Seed (void)• unsigned int GetInt (void)• unsigned int GetInt (unsigned int maximum_limit)• unsigned int GetInt (unsigned int minimum_limit, unsigned int maximum_limit)• double GetDouble (void)


6.11 RNG::RandomNumberGenerator Class Reference 57

• double Random (void)• double GetDouble (double maximum_limit)• double GetDouble (double minimum_limit, double maximum_limit)• virtual ∼RandomNumberGenerator ()


Classe para geracao de numeros pseudo-aleatorios que tem como principal algoritmo o ’Linear Congruen-tial Generator’ [ou Gerador de Congruência Linear] da funcao rand() existente na biblioteca padrão.



6.11.2.1 RNG::RandomNumberGenerator::RandomNumberGenerator ()


Construtor da classe de geração de números aleatórios


6.11.2.2 RNG::RandomNumberGenerator::RandomNumberGenerator (unsigned long seed)[inline]

Método construtor que recebe como parâmetro uma semente incial


00042 { InitSeed(seed); };


RNG::RandomNumberGenerator::RandomNumberGenerator RNG::RandomNumberGenerator::InitSeed

6.11.2.3 RNG::RandomNumberGenerator::∼RandomNumberGenerator () [virtual]


Metodo destrutor da classe



6.11.3.1 unsigned int RNG::RandomNumberGenerator::ClockRandomSeed (unsigned int myseed= 0)

Método que retorna uma semente aleatória para geração de números baseada no clock/relógio interno local.



Método que retorna uma semente aleatoria baseada no clock interno


00039 {00040 /*Estrutura responsavel pelo armazenamento do horario local*/00041 /*utilizado na geracao da semente randômica*/00042 struct tm myTM;00043 double divisor = 1;0004400045 //Semente baseada no tempo é sugerida se a fornecida for nula00046 if (myseed == 0) return (time(0)*rand());0004700048 /*Caso a semente inicial fornecida seja nula então usaremos a estrutura de*/00049 /*tempo local para geração da semente*/00050 mktime(&myTM);0005100052 /*Se a semente fornecida não for nula entao uma semente baseada no algoritmo00053 *de divisao abaixo é fornecida*/00054 if ((myseed%2) == 0)00055 {00056 divisor = myseed + 0.13579;00057 return (unsigned int)((myTM.tm_min*rand()*time(0))/divisor);00058 }00059 else


RNG::RandomNumberGenerator::ClockRandomSeed main

6.11.3.2 double RNG::RandomNumberGenerator::GetDouble (double minimum_limit, doublemaximum_limit)

Método que retorna um número pseudo-aleatório em ponto flutuante entre minimum_limit e maximum_-limit

Método que retorna um número entre minimum_limit e maximum_limit ...


00122 {00123 //Criando alias para melhorar a legibilidade do programa00124 double min = minimum_limit;00125 double max = maximum_limit;0012600127 //Verificando se os limites estão corretamente colocados

6.11.3.3 double RNG::RandomNumberGenerator::GetDouble (double maximum_limit)

Método que retorna um número pseudo-aleatório em ponto flutuante entre 0.0 e maximum_limit

Método que retorna um número entre 0 e maximum_limit ...




6.11.3.4 double RNG::RandomNumberGenerator::GetDouble (void)

Método que retorna um número pseudo-aleatório em ponto flutuante entre 0 e 0.99999 ...

Método que retorna um número entre 0 e 0.99999 ...




main


RNG::Distribution::Bernoulli



RNG::Distribution::Geometric



RNG::Distribution::Binomial



RNG::Distribution::Pascal




6.11.3.5 unsigned int RNG::RandomNumberGenerator::GetInt (unsigned int minimum_limit,unsigned int maximum_limit)

Método que retorna um número pseudo-aleatóro em formato inteiro sem sinal entre minimum_limit emaximum_limit

Metodo que retorna um número entre minimum_limit e maximum_limit


00089 {00090 //Criando alias para melhorar a legibilidade do programa00091 int min = minimum_limit;00092 int max = maximum_limit;0009300094 //Verificando se os limites estão corretamente colocados

6.11.3.6 unsigned int RNG::RandomNumberGenerator::GetInt (unsigned int maximum_limit)

Método que retorna um número pseudo-aleatório em formato inteiro sem sinal entre 0 e maximum_limit

Metodo que retorna um número entre 0 e maximum_limit


00074 { return rand(); }00075

6.11.3.7 unsigned int RNG::RandomNumberGenerator::GetInt (void)

Metodo que retorna um numero pseudo-aleatorio em formato inteiro sem sinal entre 0 e 32767.

Metodo que retorna um número gerado pseudo-aleatoriamente




00069 { return _seed; }

6.11.3.8 void RNG::RandomNumberGenerator::InitSeed (unsigned int seed = 0)

Metodo que executa atribuicao inicial na semente interna de geracao de numeros aleatorios. Caso essasemente nao seja modificada entre a geracao de sequencias numericas entao os mesmos numero seraoretornados.

Método que inicia a semente de geração de número aleatórios


00024 { _seed = time(0); }00025


RNG::RandomNumberGenerator::InitSeed

main

RNG::RandomNumberGenerator::RandomNumberGenerator

6.11.3.9 double RNG::RandomNumberGenerator::Random (void) [inline]

Apenas um alias para o método GetDouble. Dessa forma podemos interpretar o método como um geradorde números pseudo-aleatórios que retorna elementos uniformemente distribuídos no intervalo aberto (0.0 ,1.0)


00092 { return GetDouble(); }


RNG::RandomNumberGenerator::Random RNG::RandomNumberGenerator::GetDouble



RNG::Distribution::Bernoulli



RNG::Distribution::Geometric



RNG::Distribution::Binomial



RNG::Distribution::Pascal






6.11.3.10 unsigned int RNG::RandomNumberGenerator::Seed (void)

Método que retorna a semente de geração de numeros aleatorios armazenada na variavel de estado.

Método que retorna o valor da semente armazenada na variavel de estado





Chapter 7

File Documentation

7.1 RandomNumberGenerator.cxx File Reference

#include "RandomNumberGenerator.h"

#include <ctime>

#include <cmath>

#include <cstdlib>

Include dependency graph for RandomNumberGenerator.cxx:

RandomNumberGenerator.cxx

ctime cmath cstdlib

This graph shows which files directly or indirectly include this file:

RandomNumberGenerator.cxx

Namespaces

• namespace RNG

64 File Documentation

7.2 RandomNumberGenerator.cxx

00001 /*00002 * RandomNumberGenerator.cxx00003 *00004 * Created on: 21/10/200900005 * Author: Michel Alves dos Santos00006 */0000700008 #include "RandomNumberGenerator.h"0000900013 namespace RNG00014 {0001500016 //----------------------------------------------------------------------------//00017 // Implementação dos métodos da classe RandomNumberGenerator baseada na função00018 // rand() da biblioteca padrão que usa o método Linear Congruential Generator00019 //----------------------------------------------------------------------------//0002000024 RandomNumberGenerator::RandomNumberGenerator() { _seed = time(0); }0002500029 void RandomNumberGenerator::InitSeed(unsigned int seed)00030 {00031 _seed = (seed)?(seed):((unsigned)(time(NULL)));00032 srand( _seed );00033 }0003400038 unsigned int RandomNumberGenerator::ClockRandomSeed(unsigned int myseed)00039 {00040 /*Estrutura responsavel pelo armazenamento do horario local*/00041 /*utilizado na geracao da semente randômica*/00042 struct tm myTM;00043 double divisor = 1;0004400045 //Semente baseada no tempo é sugerida se a fornecida for nula00046 if (myseed == 0) return (time(0)*rand());0004700048 /*Caso a semente inicial fornecida seja nula então usaremos a estrutura de*/00049 /*tempo local para geração da semente*/00050 mktime(&myTM);0005100052 /*Se a semente fornecida não for nula entao uma semente baseada no algoritmo00053 *de divisao abaixo é fornecida*/00054 if ((myseed%2) == 0)00055 {00056 divisor = myseed + 0.13579;00057 return (unsigned int)((myTM.tm_min*rand()*time(0))/divisor);00058 }00059 else00060 {00061 divisor = myseed + 0.02468;00062 return (unsigned int)((myTM.tm_min*rand()*time(0))/(divisor/2));00063 }00064 }0006500069 unsigned int RandomNumberGenerator::Seed(void) { return _seed; }0007000074 unsigned int RandomNumberGenerator::GetInt(void){ return rand(); }0007500079 unsigned int RNG::RandomNumberGenerator::GetInt(unsigned int maximum_limit)00080 {00081 return (int)(maximum_limit*rand()/(RAND_MAX + 1.0));00082 }0008300087 unsigned int RNG::RandomNumberGenerator::GetInt(unsigned int minimum_limit,00088 unsigned int maximum_limi

t)


7.2 RandomNumberGenerator.cxx 65

00089 {00090 //Criando alias para melhorar a legibilidade do programa00091 int min = minimum_limit;00092 int max = maximum_limit;0009300094 //Verificando se os limites estão corretamente colocados00095 if (min > max) RNG::swap(min,max);0009600097 //Retornando um número gerado dentro dos limites impostos00098 return (int)((max - min + 1)*rand()/(RAND_MAX + 1.0)) + min;00099 }0010000104 double RNG::RandomNumberGenerator::GetDouble(void)00105 {00106 return rand()/(double(RAND_MAX) + 1);00107 }0010800112 double RNG::RandomNumberGenerator::GetDouble(double maximum_limit)00113 {00114 return this->GetDouble()*maximum_limit;00115 }0011600120 double RNG::RandomNumberGenerator::GetDouble(double minimum_limit,00121 double maximum_limit)00122 {00123 //Criando alias para melhorar a legibilidade do programa00124 double min = minimum_limit;00125 double max = maximum_limit;0012600127 //Verificando se os limites estão corretamente colocados00128 if (min > max) RNG::swap(min,max);0012900130 //Retornando um número gerado dentro dos limites impostos00131 return GetDouble()*(max - min) + min;00132 }0013300137 RandomNumberGenerator::~RandomNumberGenerator() {}0013800139 //----------------------------------------------------------------------------//00140 // Classe para geração de números pseudo-aleatórios que tem como principal00141 // algoritmo o ’Mersenne Twister Pseudo-random Number Generator’ que possui00142 // periodicidade de 2^19937-1.00143 //----------------------------------------------------------------------------//0014400145 // Inicializando os membros estáticos privados00146 unsigned long MersenneTwisterInt32::state[n] = {0x0UL};00147 int MersenneTwisterInt32::p = 0;00148 bool MersenneTwisterInt32::init = false;0014900153 inline void MersenneTwisterInt32::gen_state()00154 {00155 for (int i = 0; i < (n - m); ++i)00156 state[i] = state[i + m] ^ twiddle(state[i], state[i + 1]);0015700158 for (int i = n - m; i < (n - 1); ++i)00159 state[i] = state[i + m - n] ^ twiddle(state[i], state[i + 1]);0016000161 state[n - 1] = state[m - 1] ^ twiddle(state[n - 1], state[0]);00162 p = 0; // reinicia a posicao00163 }0016400168 MersenneTwisterInt32::MersenneTwisterInt32()00169 { if (!init) Seed(5489UL); init = true; };0017000174 MersenneTwisterInt32::MersenneTwisterInt32(unsigned long seed)00175 {00176 Seed(seed); init = true;



00177 }0017800183 MersenneTwisterInt32::MersenneTwisterInt32(const unsigned long *array, int size)00184 {00185 Seed(array, size); init = true;00186 }0018700191 void MersenneTwisterInt32::Seed(unsigned long seed)00192 {00193 // Para máquinas com mais de 32 bits00194 state[0] = seed & 0xFFFFFFFFUL;0019500196 // Looping que obtem a nova semente para geração de números00197 for (int i = 1; i < n; ++i)00198 {00199 state[i] = 1812433253UL * (state[i - 1] ^ (state[i - 1] >> 30)) + i;00200 state[i] &= 0xFFFFFFFFUL; // Para máquinas com mais de 32 bits00201 }0020200203 // Força gen_state() a ser chamada para um novo número aleatório00204 p = n;00205 }0020600210 void MersenneTwisterInt32::Seed(const unsigned long* array, int size)00211 {00212 Seed(19650218UL);00213 int i = 1, j = 0;0021400215 for (int k = ((n > size) ? n : size); k; --k)00216 {00217 state[i] = (state[i] ^ ((state[i - 1] ^ (state[i - 1] >> 30)) * 1664525UL))00218 + array[j] + j; // non linear0021900220 state[i] &= 0xFFFFFFFFUL; // Para máquinas com mais de 32 bits0022100222 ++j; j %= size;00223 if ((++i) == n) { state[0] = state[n - 1]; i = 1; }00224 }0022500226 for (int k = n - 1; k; --k)00227 {00228 state[i] = (state[i] ^ ((state[i - 1] ^ (state[i - 1] >> 30))00229 * 1566083941UL)) - i;00230 state[i] &= 0xFFFFFFFFUL; // Para máquinas com mais de 32 bits00231 if ((++i) == n) { state[0] = state[n - 1]; i = 1; }00232 }0023300234 // O estado zero recebe 1 - assumindo um inicio de array não-nulo00235 state[0] = 0x80000000UL;0023600237 // Força gen_state() a ser chamada para um novo número aleatório00238 p = n;00239 }0024000244 unsigned long MersenneTwisterInt32::twiddle(unsigned long u, unsigned long v)00245 {00246 return (((u & 0x80000000UL) | (v & 0x7FFFFFFFUL)) >> 1)^ ((v & 1UL) ? 0x9908B0D

FUL : 0x0UL);00247 }0024800252 unsigned long MersenneTwisterInt32::rand_int32()00253 {00254 //Caso seja necessario um novo estado para o vetor de estados00255 if (p == n) gen_state();0025600257 //O método gen_state() é dividido para ser inline, porque ele só é00258 //chamado uma vez a cada 624 chamadas de outro modo ele se tornaria muito



00259 //grande para ser implementado como método inline.00260 unsigned long x = state[p++];00261 x ^= (x >> 11);00262 x ^= (x << 7) & 0x9D2C5680UL;00263 x ^= (x << 15) & 0xEFC60000UL;00264 return x ^ (x >> 18);00265 }0026600270 MersenneTwisterInt32::~MersenneTwisterInt32(){};0027100272 //----------------------------------------------------------------------------//00273 // Classes para geração de números pseudo-aleatórios que tem como principal00274 // algoritmo o ’R250’ que possui periodicidade de 2^250-1.00275 //----------------------------------------------------------------------------//0027600277 // Inicializando os membros estáticos da classe00278 int R250Base::r250_index = 0;00279 unsigned long R250Base::seed = 1;00280 unsigned int R250Base::r250_buffer[250] = {00281 15301,57764,10921,56345,19316,43154,54727,49252,32360,49582,00282 26124,25833,34404,11030,26232,13965,16051,63635,55860,5184,00283 15931,39782,16845,11371,38624,10328,9139,1684,48668,59388,00284 13297,1364,56028,15687,63279,27771,5277,44628,31973,46977,00285 16327,23408,36065,52272,33610,61549,58364,3472,21367,56357,00286 56345,54035,7712,55884,39774,10241,50164,47995,1718,46887,00287 47892,6010,29575,54972,30458,21966,54449,10387,4492,644,00288 57031,41607,61820,54588,40849,54052,59875,43128,50370,44691,00289 286,12071,3574,61384,15592,45677,9711,23022,35256,45493,00290 48913,146,9053,5881,36635,43280,53464,8529,34344,64955,00291 38266,12730,101,16208,12607,58921,22036,8221,31337,11984,00292 20290,26734,19552,48,31940,43448,34762,53344,60664,12809,00293 57318,17436,44730,19375,30,17425,14117,5416,23853,55783,00294 57995,32074,26526,2192,11447,11,53446,35152,64610,64883,00295 26899,25357,7667,3577,39414,51161,4,58427,57342,58557,00296 53233,1066,29237,36808,19370,17493,37568,3,61468,38876,00297 17586,64937,21716,56472,58160,44955,55221,63880,1,32200,00298 62066,22911,24090,10438,40783,36364,14999,2489,43284,9898,00299 39612,9245,593,34857,41054,30162,65497,53340,27209,45417,00300 37497,4612,58397,52910,56313,62716,22377,40310,15190,34471,00301 64005,18090,11326,50839,62901,59284,5580,15231,9467,13161,00302 58500,7259,317,50968,2962,23006,32280,6994,18751,5148,00303 52739,49370,51892,18552,52264,54031,2804,17360,1919,19639,00304 2323,9448,43821,11022,45500,31509,49180,35598,38883,19754,00305 987,11521,55494,38056,20664,2629,50986,31009,54043,5974300306 };0030700311 inline unsigned R250Base::myrand()00312 {00313 seed = seed*0x015a4e35L + 1;00314 return (seed>>16)&0x7fff;00315 }0031600320 inline void R250Base::mysrand(unsigned newseed)00321 {00322 seed = newseed;00323 }0032400328 void R250Base::r250_init(unsigned long seed)00329 {00330 int j, k;00331 unsigned int mask;00332 unsigned int msb;0033300334 mysrand(seed);00335 r250_index = 0;0033600337 for (j = 0; j < 250; j++) /* Fill the r250 buffer with 15-bit values */



00338 r250_buffer[j] = myrand();0033900340 for (j = 0; j < 250; j++) /* Set some of the MS bits to 1 */00341 if (myrand() > 16384) r250_buffer[j] |= 0x8000;0034200343 msb = 0x8000; /* To turn on the diagonal bit */00344 mask = 0xffff; /* To turn off the leftmost bits */0034500346 for (j = 0; j < 16; j++)00347 {00348 k = 11 * j + 3; /* Select a word to operate on */00349 r250_buffer[k] &= mask; /* Turn off bits left of the diagonal */00350 r250_buffer[k] |= msb; /* Turn on the diagonal bit */00351 mask >>= 1;00352 msb >>= 1;00353 }00354 }0035500361 unsigned int R250Int::operator ()()00362 {00363 register int j;00364 register unsigned int new_rand;0036500366 // Verifica limites de salto - Wrap pointer around00367 if (r250_index >= 147) j = r250_index - 147;00368 else j = r250_index + 103;0036900370 new_rand = r250_buffer[r250_index] ^= r250_buffer[j];0037100372 //Incrementa o ponteiro para o próximo salto dentro do vetor de sementes00373 if (r250_index >= 249) r250_index = 0;00374 else r250_index++;0037500376 return new_rand;00377 }0037800384 unsigned int R250Int::operator ()(unsigned int maximum_limit)00385 {00386 register int j;00387 register unsigned int new_rand, limit;00388 unsigned int n = maximum_limit;0038900390 // LImitede geração de números00391 limit = (65535U/n)*n;0039200393 do00394 {00395 //Usando o operador que retorna numeros entre 0 e 6553500396 new_rand = operator ()();0039700398 // Verifica limites de salto - Wrap pointer around00399 if (r250_index >= 147) j = r250_index - 147;00400 else j = r250_index + 103;0040100402 new_rand = r250_buffer[r250_index] ^= r250_buffer[j];0040300404 //Incrementa o ponteiro para o próximo salto dentro do vetor de sementes00405 if (r250_index >= 249) r250_index = 0;00406 else r250_index++;0040700408 } while(new_rand >= limit);0040900410 // Retorno da função ...00411 return new_rand%n;00412 }0041300419 double R250Double::operator ()()



00420 {00421 register int j;00422 register unsigned int new_rand;0042300424 // Verifica limites de salto - Wrap pointer around00425 if (r250_index >= 147) j = r250_index - 147;00426 else j = r250_index + 103;0042700428 new_rand = r250_buffer[r250_index] ^= r250_buffer[j];0042900430 //Incrementa o ponteiro para o próximo salto dentro do vetor de sementes00431 if (r250_index >= 249) r250_index = 0;00432 else r250_index++;0043300434 return new_rand / 65536.; // Retorna um numero entre [0.0 até 1.0)00435 }0043600437 //----------------------------------------------------------------------------//00446 //----------------------------------------------------------------------------//0044700453 double BoxMuller::operator ()(double Mean, double StandardDev)00454 {00455 float x1, x2, w, y1;00456 static float y2;00457 static bool use_last = false;0045800459 //Verifica se o valor usado deve ser o da última chamada00460 if (use_last)00461 {00462 y1 = y2;00463 use_last = false;00464 }00465 else00466 {0046700468 //Calculo da localização do número dentro do intervalo passado00469 do00470 {00471 x1 = 2.0 * GetDouble() - 1.0;00472 x2 = 2.0 * GetDouble() - 1.0;00473 w = x1 * x1 + x2 * x2;00474 }00475 while ( w >= 1.0 );0047600477 w = sqrt( (-2.0 * log( w ) ) / w );00478 y1 = x1 * w;00479 y2 = x2 * w;00480 use_last = true;00481 }0048200483 //Retorno do número transformado ...00484 return( Mean + y1 * StandardDev );00485 }0048600487 //----------------------------------------------------------------------------//00494 //----------------------------------------------------------------------------//0049500500 long Distribution::Bernoulli(double probability)00501 {00502 return ((Random() < (1.0 - probability)) ? 0 : 1);00503 }0050400509 long Distribution::Binomial (unsigned long limit_experiment, double probability)00510 {00511 unsigned long i, x = 0;00512 for (i = 0; i < limit_experiment; i++) x += Bernoulli(probability);00513 return (x);



00514 }0051500520 long Distribution::Equilikely (long a, long b)00521 {00522 if (a > b) swap(a,b); // Verificando se o intervalo foi fornecido corretamente00523 return (a + (long)((b - a + 1) * Random()));00524 }0052500530 unsigned long Distribution::Geometric(double probability)00531 {00532 return ((long) (log(1.0 - Random()) / log(probability)));00533 }0053400539 long Distribution::Pascal(unsigned long limit_experiment, double probability)00540 {00541 unsigned long i, x = 0;00542 for (i = 0; i < limit_experiment; i++) x += Geometric(probability);00543 return (x);00544 }0054500550 long Distribution::Poisson(double mean)00551 {00552 double t = 0.0;00553 long x = 0;0055400555 while (t < mean)00556 {00557 t += Exponential(1.0);00558 x++;00559 }0056000561 return (x - 1);00562 }0056300568 double Distribution::Uniform(double a, double b)00569 {00570 if (a > b) swap(a,b);00571 return (a + (b - a) * Random());00572 }0057300578 double Distribution::Exponential(double mean)00579 {00580 return (-mean * log(1.0 - Random()));00581 }0058200587 double Distribution::Erlang(long limit_experiment, double base)00588 {00589 long i;00590 double x = 0.0;00591 for (i = 0; i < limit_experiment; i++) x += Exponential(base);00592 return (x);00593 }0059400599 double Distribution::Normal(double Mean, double StandarDev)00600 {00601 const double p0 = 0.322232431088; const double q0 = 0.099348462606;00602 const double p1 = 1.0; const double q1 = 0.588581570495;00603 const double p2 = 0.342242088547; const double q2 = 0.531103462366;00604 const double p3 = 0.204231210245e-1; const double q3 = 0.103537752850;00605 const double p4 = 0.453642210148e-4; const double q4 = 0.385607006340e-2;00606 double u, t, p, q, z;0060700608 u = Random();0060900610 if (u < 0.5) t = sqrt(-2.0 * log(u));00611 else t = sqrt(-2.0 * log(1.0 - u));00612



00613 p = p0 + t * (p1 + t * (p2 + t * (p3 + t * p4)));00614 q = q0 + t * (q1 + t * (q2 + t * (q3 + t * q4)));0061500616 if (u < 0.5) z = (p / q) - t;00617 else z = t - (p / q);0061800619 return (Mean + StandarDev * z);00620 }0062100626 double Distribution::Lognormal(double a, double b)00627 {00628 return (exp(a + b * Normal(0.0, 1.0)));00629 }0063000635 double Distribution::Chisquare(unsigned long limit_experiment)00636 {00637 unsigned long i;00638 double z, x = 0.0;0063900640 for (i = 0; i < limit_experiment; i++)00641 {00642 z = Normal(0.0, 1.0);00643 x += z * z;00644 }0064500646 return (x);00647 }0064800653 double Distribution::Student(unsigned long limit_experiment)00654 {00655 return (Normal(0.0, 1.0)/sqrt(Chisquare(limit_experiment)/limit_experiment));00656 }0065700658 }; //Fim do namespace RNG



7.3 RandomNumberGenerator.h File Reference

#include <ctime>

#include <cmath>

#include <cstdlib>

Include dependency graph for RandomNumberGenerator.h:

RandomNumberGenerator.h

ctime cmath cstdlib

This graph shows which files directly or indirectly include this file:

RandomNumberGenerator.h

Sys-LibraryRandom.cpp

Classes

• class RNG::RandomNumberGenerator• class RNG::MersenneTwisterInt32• class RNG::MersenneTwisterDouble• class RNG::MersenneTwisterDoubleClosed• class RNG::MersenneTwisterDoubleOpened• class RNG::MersenneTwisterDouble53• class RNG::R250Base• class RNG::R250Int• class RNG::R250Double• class RNG::BoxMuller• class RNG::Distribution

Namespaces

• namespace RNG

Functions

• template<typename T >

void RNG::swap (T &a, T &b)


7.4 RandomNumberGenerator.h 73

7.4 RandomNumberGenerator.h

00001 /*00002 * RandomNumberGenerator.h00003 *00004 * Created on: 21/10/200900005 * Author: Michel Alves dos Santos00006 */0000700008 #ifndef RANDOMNUMBERGENERATOR_H_00009 #define RANDOMNUMBERGENERATOR_H_0001000011 #include <ctime>00012 #include <cmath>00013 #include <cstdlib>0001400020 namespace RNG00021 {0002200029 class RandomNumberGenerator00030 {00031 unsigned int _seed; /*Armazena a semente de geração de números aleatórios*/00032 public:0003300037 RandomNumberGenerator();0003800042 RandomNumberGenerator(unsigned long seed) { InitSeed(seed); };0004300049 void InitSeed(unsigned int seed = 0);0005000055 unsigned int ClockRandomSeed(unsigned int myseed = 0);0005600061 unsigned int Seed(void);0006200067 unsigned int GetInt(void);0006800073 unsigned int GetInt(unsigned int maximum_limit);0007400079 unsigned int GetInt(unsigned int minimum_limit, unsigned int maximum_limit);0008000085 double GetDouble(void);0008600092 double Random(void) { return GetDouble(); }0009300098 double GetDouble(double maximum_limit);0009900104 double GetDouble(double minimum_limit, double maximum_limit);0010500110 virtual ~RandomNumberGenerator();00111 };001120011300121 class MersenneTwisterInt3200122 {00123 static const int n = 624, m = 397; // constantes em tempo de compilacao00124 static unsigned long state[n]; // Estado do vetor00125 static int p; // posição dentro do vetor de estados00126 static bool init; // true se a função init foi invocada0012700131 unsigned long twiddle(unsigned long u, unsigned long v);0013200136 void gen_state();0013700141 MersenneTwisterInt32(const MersenneTwisterInt32&); // Construtor de cópia00142 void operator=(const MersenneTwisterInt32&); // Operador de atribuição0014300144 protected:



0014500149 unsigned long rand_int32();0015000151 public:0015200156 MersenneTwisterInt32();0015700161 MersenneTwisterInt32(unsigned long seed);0016200170 MersenneTwisterInt32(const unsigned long* array, int size);0017100175 void Seed(unsigned long seed);0017600180 void Seed(const unsigned long* array, int size);0018100186 unsigned long operator()() { return rand_int32(); }0018700192 virtual ~MersenneTwisterInt32();00193 };001940019500203 class MersenneTwisterDouble : public MersenneTwisterInt3200204 {00205 public:0020600210 MersenneTwisterDouble() : MersenneTwisterInt32() {};0021100215 MersenneTwisterDouble(unsigned long seed) : MersenneTwisterInt32(seed) {};0021600221 MersenneTwisterDouble(const unsigned long* seed, int size)00222 : MersenneTwisterInt32(seed, size) {};0022300228 double operator()()00229 { return static_cast<double>(rand_int32()) * (1. / 4294967296.); } // divisão p

or 2^320023000235 ~MersenneTwisterDouble() {};0023600237 private:0023800242 MersenneTwisterDouble(const MersenneTwisterDouble&);0024300247 void operator=(const MersenneTwisterDouble&);00248 };002490025000258 class MersenneTwisterDoubleClosed : public MersenneTwisterInt3200259 {00260 public:00264 MersenneTwisterDoubleClosed() : MersenneTwisterInt32() {};0026500269 MersenneTwisterDoubleClosed(unsigned long seed)00270 : MersenneTwisterInt32(seed) {};0027100276 MersenneTwisterDoubleClosed(const unsigned long* seed, int size)00277 : MersenneTwisterInt32(seed, size) {};0027800283 double operator()()00284 { return static_cast<double>(rand_int32()) * (1. / 4294967295.); } // divisão p

or 2^32 - 10028500290 ~MersenneTwisterDoubleClosed() {};0029100292 private:0029300297 MersenneTwisterDoubleClosed(const MersenneTwisterDoubleClosed&);00298



00302 void operator=(const MersenneTwisterDoubleClosed&);00303 };003040030500313 class MersenneTwisterDoubleOpened : public MersenneTwisterInt3200314 {00315 public:0031600320 MersenneTwisterDoubleOpened() : MersenneTwisterInt32() {};0032100325 MersenneTwisterDoubleOpened(unsigned long seed)00326 : MersenneTwisterInt32(seed) {};0032700332 MersenneTwisterDoubleOpened(const unsigned long* seed, int size)00333 : MersenneTwisterInt32(seed, size) {};0033400339 double operator()()00340 { return (static_cast<double>(rand_int32()) + .5) * (1. / 4294967296.); } // di

visão por 2^320034100346 ~MersenneTwisterDoubleOpened() {};0034700348 private:0034900353 MersenneTwisterDoubleOpened(const MersenneTwisterDoubleOpened&);0035400358 void operator=(const MersenneTwisterDoubleOpened&);00359 };003600036100369 class MersenneTwisterDouble53 : public MersenneTwisterInt3200370 {00371 public:0037200376 MersenneTwisterDouble53() : MersenneTwisterInt32() {};0037700381 MersenneTwisterDouble53(unsigned long seed) : MersenneTwisterInt32(seed) {};0038200387 MersenneTwisterDouble53(const unsigned long* seed, int size)00388 : MersenneTwisterInt32(seed, size) {};0038900394 double operator()()00395 {00396 return (static_cast<double>(rand_int32() >> 5) * 67108864. +00397 static_cast<double>(rand_int32() >> 6)) * (1. / 9007199254740992.

);00398 }0039900404 ~MersenneTwisterDouble53() {};0040500406 private:0040700411 MersenneTwisterDouble53(const MersenneTwisterDouble53&);0041200416 void operator=(const MersenneTwisterDouble53&);00417 };004180041900425 class R250Base00426 {00427 public:00428 static int r250_index; // Controla o índice da semente00429 static unsigned int r250_buffer[250]; // Array de sementes de randomização00430 static unsigned long seed; // Semente unidimensional0043100435 R250Base() {};00436



00440 R250Base(unsigned long seed) { r250_init(seed); }0044100448 static unsigned myrand();0044900454 static void mysrand(unsigned newseed);0045500459 void r250_init(unsigned long seed);0046000461 };0046200469 class R250Int : public R250Base00470 {00471 public:0047200476 R250Int() : R250Base() {};0047700481 R250Int(unsigned long seed) : R250Base(seed) {};0048200489 unsigned int operator()();0049000497 unsigned int operator()(unsigned int maximum_limit);00498 };0049900506 class R250Double : public R250Base00507 {00508 public:00512 R250Double() : R250Base() {};0051300517 R250Double(unsigned long seed) : R250Base(seed) {};0051800524 double operator()();00525 };0052600535 class BoxMuller : public RandomNumberGenerator00536 {00537 public :0053800542 BoxMuller() : RandomNumberGenerator() {};0054300547 BoxMuller(unsigned long seed) : RandomNumberGenerator(seed) {};0054800555 double operator()(double Mean, double StandardDev);00556 };0055700590 class Distribution : public RandomNumberGenerator00591 {00592 public :0059300597 Distribution () : RandomNumberGenerator() {};0059800602 Distribution(unsigned long seed) : RandomNumberGenerator(seed) {};0060300610 long Bernoulli (double probability = 0.5);0061100616 long Binomial (unsigned long limit_experiment, double probability = 0.5);0061700622 long Equilikely (long a, long b);0062300628 unsigned long Geometric(double probability = 0.5);0062900634 long Pascal(unsigned long limit_experiment, double probability = 0.5);0063500640 long Poisson(double mean);0064100646 double Uniform(double a, double b);0064700652 double Exponential(double mean = 0.5);



0065300658 double Erlang(long limit_experiment, double base);0065900664 double Normal(double Mean, double StandarDev);0066500670 double Lognormal(double a, double b);0067100676 double Chisquare(unsigned long limit_experiment);0067700682 double Student(unsigned long limit_experiment);00683 };0068400685 /*Função utilitária que executa a troca entre dois valores */00686 template <typename T> void swap(T& a, T& b) { T temp(a); a = b; b = temp; };00687 }00688 #endif /* RANDOMNUMBERGENERATOR_H_ */



7.5 Sys-LibraryRandom.cpp File Reference

#include <iostream>

#include "RandomNumberGenerator.h"

Include dependency graph for Sys-LibraryRandom.cpp:

Sys-LibraryRandom.cpp

iostream RandomNumberGenerator.h

ctime cmath cstdlib

Functions

• int main (int argc, char ∗argv[ ])

7.5.1 Function Documentation

7.5.1.1 int main (int argc, char ∗ argv[ ])

Função para testes com a biblioteca.

Definition at line 13 of file Sys-LibraryRandom.cpp.

00014 {00015 //Declarando um objeto00016 RNG::RandomNumberGenerator rng;0001700018 //Estabelecendo uma semente.00019 rng.InitSeed(rng.ClockRandomSeed());0002000021 //Executando método para obtençao de números aleatórios00022 std::cout << "[Números Aleatórios entre 0 e 1]" << std::endl;00023 for(int i = 0; i < 5; ++i) std::cout << rng.GetDouble() << "\t";0002400025 //Retorno da função de teste00026 return 0;00027 }


main

RNG::RandomNumberGenerator::ClockRandomSeed


RNG::RandomNumberGenerator::InitSeed


7.6 Sys-LibraryRandom.cpp 79

7.6 Sys-LibraryRandom.cpp

00001 //============================================================================00002 // Name : LibraryRandom00003 // Author : Michel Alves dos Santos00004 // Version : 1.0 beta00005 //============================================================================0000600007 #include <iostream>00008 #include "RandomNumberGenerator.h"0000900013 int main(int argc, char* argv[])00014 {00015 //Declarando um objeto00016 RNG::RandomNumberGenerator rng;0001700018 //Estabelecendo uma semente.00019 rng.InitSeed(rng.ClockRandomSeed());0002000021 //Executando método para obtençao de números aleatórios00022 std::cout << "[Números Aleatórios entre 0 e 1]" << std::endl;00023 for(int i = 0; i < 5; ++i) std::cout << rng.GetDouble() << "\t";0002400025 //Retorno da função de teste00026 return 0;00027 }


Index

∼MersenneTwisterDoubleRNG::MersenneTwisterDouble, 27

∼MersenneTwisterDouble53RNG::MersenneTwisterDouble53, 31

∼MersenneTwisterDoubleClosedRNG::MersenneTwisterDoubleClosed, 35

∼MersenneTwisterDoubleOpenedRNG::MersenneTwisterDoubleOpened, 39

∼MersenneTwisterInt32RNG::MersenneTwisterInt32, 42

∼RandomNumberGeneratorRNG::RandomNumberGenerator, 57

BernoulliRNG::Distribution, 18

BinomialRNG::Distribution, 19

BoxMullerRNG::BoxMuller, 14

ChisquareRNG::Distribution, 19

ClockRandomSeedRNG::RandomNumberGenerator, 57

DistributionRNG::Distribution, 18

EquilikelyRNG::Distribution, 20

ErlangRNG::Distribution, 20

ExponentialRNG::Distribution, 20

GeometricRNG::Distribution, 21

GetDoubleRNG::RandomNumberGenerator, 58

GetIntRNG::RandomNumberGenerator, 59

InitSeedRNG::RandomNumberGenerator, 60

Lognormal

RNG::Distribution, 21

mainSys-LibraryRandom.cpp, 78

MersenneTwisterDoubleRNG::MersenneTwisterDouble, 27

MersenneTwisterDouble53RNG::MersenneTwisterDouble53, 31

MersenneTwisterDoubleClosedRNG::MersenneTwisterDoubleClosed, 35

MersenneTwisterDoubleOpenedRNG::MersenneTwisterDoubleOpened, 39

MersenneTwisterInt32RNG::MersenneTwisterInt32, 42

myrandRNG::R250Base, 46

mysrandRNG::R250Base, 46

NormalRNG::Distribution, 21

operator()RNG::BoxMuller, 14RNG::MersenneTwisterDouble, 27RNG::MersenneTwisterDouble53, 31RNG::MersenneTwisterDoubleClosed, 35RNG::MersenneTwisterDoubleOpened, 39RNG::MersenneTwisterInt32, 42RNG::R250Double, 51RNG::R250Int, 54

PascalRNG::Distribution, 22

PoissonRNG::Distribution, 22

r250_bufferRNG::R250Base, 47

r250_indexRNG::R250Base, 48

r250_initRNG::R250Base, 46

R250BaseRNG::R250Base, 46

R250Double

INDEX 81

RNG::R250Double, 51R250Int

RNG::R250Int, 54rand_int32

RNG::MersenneTwisterInt32, 43Random

RNG::RandomNumberGenerator, 60RandomNumberGenerator

RNG::RandomNumberGenerator, 57RandomNumberGenerator.cxx, 63RandomNumberGenerator.h, 72RNG, 9

swap, 9RNG::BoxMuller, 11

BoxMuller, 14operator(), 14

RNG::Distribution, 16Bernoulli, 18Binomial, 19Chisquare, 19Distribution, 18Equilikely, 20Erlang, 20Exponential, 20Geometric, 21Lognormal, 21Normal, 21Pascal, 22Poisson, 22Student, 23Uniform, 23

RNG::MersenneTwisterDouble, 25∼MersenneTwisterDouble, 27MersenneTwisterDouble, 27operator(), 27

RNG::MersenneTwisterDouble53, 29∼MersenneTwisterDouble53, 31MersenneTwisterDouble53, 31operator(), 31

RNG::MersenneTwisterDoubleClosed, 33∼MersenneTwisterDoubleClosed, 35MersenneTwisterDoubleClosed, 35operator(), 35

RNG::MersenneTwisterDoubleOpened, 37∼MersenneTwisterDoubleOpened, 39MersenneTwisterDoubleOpened, 39operator(), 39

RNG::MersenneTwisterInt32, 41∼MersenneTwisterInt32, 42MersenneTwisterInt32, 42operator(), 42rand_int32, 43Seed, 43, 44

RNG::R250Base, 45

myrand, 46mysrand, 46r250_buffer, 47r250_index, 48r250_init, 46R250Base, 46seed, 48

RNG::R250Double, 49operator(), 51R250Double, 51

RNG::R250Int, 52operator(), 54R250Int, 54

RNG::RandomNumberGenerator, 56∼RandomNumberGenerator, 57ClockRandomSeed, 57GetDouble, 58GetInt, 59InitSeed, 60Random, 60RandomNumberGenerator, 57Seed, 60

SeedRNG::MersenneTwisterInt32, 43, 44RNG::RandomNumberGenerator, 60

seedRNG::R250Base, 48

StudentRNG::Distribution, 23

swapRNG, 9

Sys-LibraryRandom.cpp, 78main, 78

UniformRNG::Distribution, 23


Documentation - LibraryRandom

Education

Transcript of Documentation - LibraryRandom