Boost generatore di numeri casuali

Question

Qualcuno ha un generatore di numeri casuali di boost preferito e puoi spiegare un po 'su come implementarlo in codice. Sto cercando di convincere il mersenne twister a lavorare e mi stavo chiedendo se qualcuno avesse preferenze verso uno degli altri.

Answer 1

Questo codice è adattato dal manuale spinta a http://www.boost.org/doc/libs/1_42_0/libs/random/index.html:

#include <iostream> 
#include "boost/random.hpp" 
#include "boost/generator_iterator.hpp" 
using namespace std; 

int main() { 
     typedef boost::mt19937 RNGType; 
     RNGType rng; 
     boost::uniform_int<> one_to_six(1, 6); 
     boost::variate_generator< RNGType, boost::uniform_int<> > 
        dice(rng, one_to_six); 
     for (int i = 0; i < 6; i++) { 
      int n = dice(); 
      cout << n << endl; 
    } 
} 

Per spiegare le punte:

• mt19937 è il generatore twister Mersenne, che genera i numeri casuali grezzi. Qui viene usato un typedef in modo da poter cambiare facilmente il tipo di generatore di numeri casuali.

• rng è un'istanza del generatore di torsione.

• one_to_six è un'istanza di una distribuzione . Questo specifica i numeri che vogliamo generare e la distribuzione che seguono. Qui vogliamo 1 a 6, distribuiti uniformemente.

• dice è la cosa che prende i numeri grezzi e la distribuzione e crea per noi i numeri che effettivamente vogliamo.

• dice() è una chiamata alla operator() per l'oggetto dice, che ottiene il numero casuale successivo la distribuzione, simulando una casuale dadi laterale sei facce.

Così com'è, questo codice produce la stessa sequenza di dadi ogni volta. Puoi randomizzare il generatore nel suo costruttore:

RNGType rng(time(0)); 

o utilizzando il suo membro seed().

Answer 2

Non esiste un RNG valido per tutti. A volte le proprietà statistiche sono importanti, a volte crittografiche, a volte velocità grezza.

Answer 3

Ho trovato questo link che offre una buona panoramica delle proprietà di diversi generatori di numeri casuali. Ho copiato la tabella dal link qui sopra per comodità:

 
+-----------------------+-------------------+-----------------------------+------------------------+ 
|  generator  | length of cycle | approx. memory requirements | approx. relative speed | 
+-----------------------+-------------------+-----------------------------+------------------------+ 
| minstd_rand   | 2^31-2   | sizeof(int32_t)    |      40 | 
| rand48    | 2^48-1   | sizeof(uint64_t)   |      80 | 
| lrand48 (C library) | 2^48-1   | -       |      20 | 
| ecuyer1988   | approx. 2^61  | 2*sizeof(int32_t)   |      20 | 
| kreutzer1986   | ?     | 1368*sizeof(uint32_t)  |      60 | 
| hellekalek1995  | 2^31-1   | sizeof(int32_t)    |      3 | 
| mt11213b    | 2^11213-1   | 352*sizeof(uint32_t)  |     100 | 
| mt19937    | 2^19937-1   | 625*sizeof(uint32_t)  |     100 | 
| lagged_fibonacci607 | approx. 2^32000 | 607*sizeof(double)   |     150 | 
| lagged_fibonacci1279 | approx. 2^67000 | 1279*sizeof(double)   |     150 | 
| lagged_fibonacci2281 | approx. 2^120000 | 2281*sizeof(double)   |     150 | 
| lagged_fibonacci3217 | approx. 2^170000 | 3217*sizeof(double)   |     150 | 
| lagged_fibonacci4423 | approx. 2^230000 | 4423*sizeof(double)   |     150 | 
| lagged_fibonacci9689 | approx. 2^510000 | 9689*sizeof(double)   |     150 | 
| lagged_fibonacci19937 | approx. 2^1050000 | 19937*sizeof(double)  |     150 | 
| lagged_fibonacci23209 | approx. 2^1200000 | 23209*sizeof(double)  |     140 | 
| lagged_fibonacci44497 | approx. 2^2300000 | 44497*sizeof(double)  |      60 | 
+-----------------------+-------------------+-----------------------------+------------------------+ 

durata del ciclo: lunghezza della sequenza di numeri casuali prima del suo inizio di ripetere