Das generieren von Zufallszahlen in C++11: wie generieren, wie funktioniert es?

Die Frage ist viel zu breit für eine vollständige Antwort, aber lassen Sie mich cherry-pick ein paar interessante Punkte:

Warum "gleich wahrscheinlich"

Angenommen, Sie haben einen einfachen Zufallszahlengenerator, generieren Sie die zahlen 0, 1, ..., 10 mit jeweils gleicher Wahrscheinlichkeit (betrachten Sie dies als die klassische rand()). Jetzt willst du eine zufällige Zahl im Bereich von 0, 1, 2, die jeweils mit gleicher Wahrscheinlichkeit auf. Ihre reflexartige Reaktion wäre, zu nehmen rand() % 3. Aber warten Sie, die Reste 0 und 1 häufiger auftreten als der Rest 2, so ist dies nicht richtig!!!!

Dies ist der Grund, warum wir brauchen richtige Distributionen, die eine Quelle der uniform zufällige Ganzzahlen und biegen Sie in die von uns gewünschte Verteilung, wie Uniform[0,2] im Beispiel. Am besten lassen Sie diese zu einer guten Bibliothek!

Motoren

Damit das Herz des ganzen die Zufälligkeit ist eine gute pseudo-random number generator, generiert eine Sequenz von zahlen, die gleichmäßig verteilt über einen bestimmten Intervall, und die idealerweise über einen sehr langen Zeitraum. Die standard-Implementierung von rand() ist nicht oft der beste, und so ist es gut, eine Wahl. Linear-congruential und der Mersenne-twister sind zwei gute Möglichkeiten (LG ist tatsächlich oft von rand() zu); wieder, es ist gut, lassen Sie die Bibliothek kümmern.

, Wie es funktioniert

Einfach: richten Sie zuerst einen Motor und bepflanzen es. Die Samen vollständig bestimmt, die gesamte Sequenz der "zufälligen" zahlen, so ist a) eine andere (z.B. von /dev/urandom) jeder Zeit, und b) speichern Sie die Samen, wenn Sie es wünschen, wieder eine Folge von zufälligen Entscheidungen.

#include <random>

typedef std::mt19937 MyRNG;  //the Mersenne Twister with a popular choice of parameters
uint32_t seed_val;           //populate somehow

MyRNG rng;                   //e.g. keep one global instance (per thread)

void initialize()
{
  rng.seed(seed_val);
}

Nun können wir Verteilungen erstellen:

std::uniform_int_distribution<uint32_t> uint_dist;         //by default range [0, MAX]
std::uniform_int_distribution<uint32_t> uint_dist10(0,10); //range [0,10]
std::normal_distribution<double> normal_dist(mean, stddeviation);  //N(mean, stddeviation)

...Und die Verwendung der engine zu erstellen Zufallszahlen!

while (true)
{
  std::cout << uint_dist(rng) << " "
            << uint_dist10(rng) << " "
            << normal_dist(rng) << std::endl;

}

Parallelität

Einen weiteren wichtigen Grund zu bevorzugen <random> über die traditionellen rand() ist, dass es jetzt sehr klar und offensichtlich, wie man random number generation threadsicher: Entweder jeder thread mit seinem eigenen, lokalen thread-engine, gesetzt auf eine thread-lokale Saatgut, oder synchronisieren Sie den Zugriff auf das engine-Objekt.

Misc

• Eine interessanter Artikel auf TR1 zufällig auf codeguru.
• Wikipedia hat eine gute Zusammenfassung (danke an @Justin).
• Im Prinzip jeder Motor sollte typedef ein result_type, welches ist das richtige integral-Art zu verwenden, für die Samen. Ich glaube, ich hatte einen Kinderwagen, Umsetzung, sobald das Zwang mich zu zwingen, das Saatgut für std::mt19937 zu uint32_t auf x64, schließlich sollte dies behoben werden, und man kann sagen MyRNG::result_type seed_val und damit der Motor sehr leicht austauschbar.