<random>
Definiert Funktionen zum Generieren von Zufallszahlen und erlaubt die Erstellung gleichförmiger verteilter Zufallszahlen.
#include <random>
Zusammenfassung
Ein Zufallszahlengenerator ist ein Objekt, bei dem eine Sequenz von Pseudo-Zufallswerten erzeugt wird. Ein Generator, der Werte produziert, die in einem bestimmten Bereich gleichförmig verteilt sind, ist ein Uniform Random Number-Generator (URNG). Auf eine Vorlagenklasse, die als URNG funktionieren soll, wird als Modul verwiesen, wenn die Klasse bestimmte gemeinsame Merkmale aufweist, die später in diesem Artikel diskutiert werden. Ein URNG kann mit einer Verteilung kombiniert werden - was im Normalfall auch geschieht -, indem der URNG als Argument an den operator() des Verteilers übergeben wird, um Werte zu produzieren, die in einer von der Verteilung definierten Art und Weise verteilt werden.
Diese Links führen zu den Hauptabschnitten dieses Artikels:
Codebeispiele
Kategorisierte Auflistung
Module und Verteilungen
Hinweise
Einfache Tipps
Hier erhalten Sie einige Tipps, die Sie beachten sollten, wenn Sie <random> verwenden:
Für die meisten Zwecke produzieren URNGs Rohbits, die durch Verteilungen geformt werden müssen. (Eine wichtige Ausnahme ist std::shuffle(), da es einen URNG direkt verwendet.)
Eine einzelne Instanziierung eines URNG oder einer Verteilung kann nicht gleichzeitig sicher aufgerufen werden, da die Ausführung eines URNG oder einer Verteilung ein Änderungsvorgang ist. Weitere Informationen finden Sie unter Threadsicherheit in der C++-Standardbibliothek.
Voreingestellte Typdefinitionen einiger Module sind verfügbar. Dies ist der bevorzugte Weg zur Erstellung eines URNG, wenn ein Modul verwendet wird.
Die hilfreichste Paarung für die meisten Anwendungen ist das mt19937-Modul mit uniform_int_distribution, wie später in diesem Artikel im Codebeispiel gezeigt.
Der <random>-Header enthält mehrere Optionen zur Auswahl, von denen jede der veralteten C-Laufzeitfunktion rand() vorzuziehen ist. Informationen über die Nachteile von rand() und die Behebung dieser Schwachpunkte durch <random> erhalten Sie in diesem Video.
Beispiele
Im folgenden Codebeispiel wird veranschaulicht, wie einige Zufallszahlen (in diesem Fall fünf) mit einem Generator erstellt werden, der mit einem nicht-deterministischen Startwert generiert wurde.
#include <random>
#include <iostream>
using namespace std;
int main()
{
random_device rd; // non-deterministic generator
mt19937 gen(rd()); // to seed mersenne twister.
// replace the call to rd() with a
// constant value to get repeatable
// results.
for (int i = 0; i < 5; ++i) {
cout << gen() << " "; // print the raw output of the generator.
}
cout << endl;
}
Ausgabe:
Obwohl es sich dabei um hochwertige Zufallszahlen handelt und diese bei jeder einzelnen Ausführung dieses Programms unterschiedlich sind, liegen sie nicht unbedingt in einem nützlichen Bereich. Verwenden Sie zum Steuern des Bereichs eine gleichmäßige Verteilung, wie im folgenden Code dargestellt:
#include <random>
#include <iostream>
using namespace std;
int main()
{
random_device rd; // non-deterministic generator
mt19937 gen(rd()); // to seed mersenne twister.
uniform_int_distribution<> dist(1,6); // distribute results between 1 and 6 inclusive.
for (int i = 0; i < 5; ++i) {
cout << dist(gen) << " "; // pass the generator to the distribution.
}
cout << endl;
}
Ausgabe:
Im nächsten Codebeispiel werden realistischere Anwendungsfälle mit gleichmäßig verteilten Zufallszahlengeneratoren dargestellt, die die Inhalte eines Vektors und eines Arrays mischen.
// cl.exe /EHsc /nologo /W4 /MTd
#include <algorithm>
#include <array>
#include <iostream>
#include <random>
#include <string>
#include <vector>
#include <functional> // ref()
using namespace std;
template <typename C> void print(const C& c) {
for (const auto& e : c) {
cout << e << " ";
}
cout << endl;
}
template <class URNG>
void test(URNG& urng) {
// Uniform distribution used with a vector
// Distribution is [-5, 5] inclusive
uniform_int_distribution<int> dist(-5, 5);
vector<int> v;
for (int i = 0; i < 20; ++i) {
v.push_back(dist(urng));
}
cout << "Randomized vector: ";
print(v);
// Shuffle an array
// (Notice that shuffle() takes a URNG, not a distribution)
array<string, 26> arr = { { "H", "He", "Li", "Be", "B", "C", "N", "O", "F",
"Ne", "Na", "Mg", "Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc",
"Ti", "V", "Cr", "Mn", "Fe" } };
shuffle(arr.begin(), arr.end(), urng);
cout << "Randomized array: ";
print(arr);
cout << "--" << endl;
}
int main()
{
// First run: non-seedable, non-deterministic URNG random_device
// Slower but crypto-secure and non-repeatable.
random_device rd;
cout << "Using random_device URNG:" << endl;
test(rd);
// Second run: simple integer seed, repeatable results
cout << "Using constant-seed mersenne twister URNG:" << endl;
mt19937 engine1(12345);
test(engine1);
// Third run: random_device as a seed, different each run
// (Desirable for most purposes)
cout << "Using non-deterministic-seed mersenne twister URNG:" << endl;
mt19937 engine2(rd());
test(engine2);
// Fourth run: "warm-up" sequence as a seed, different each run
// (Advanced uses, allows more than 32 bits of randomness)
cout << "Using non-deterministic-seed \"warm-up\" sequence mersenne twister URNG:" << endl;
array<unsigned int, mt19937::state_size> seed_data;
generate_n(seed_data.begin(), seed_data.size(), ref(rd));
seed_seq seq(begin(seed_data), end(seed_data));
mt19937 engine3(seq);
test(engine3);
}
Beispielausgabe und Codehinweise
Dieser Code zeigt zwei verschiedene Randomisierungen – Randomisierungen eines Vektors aus Ganzzahlen und Mischung eines Arrays indizierter Daten – mit einer Testvorlagenfunktion. Der erste Aufruf der Testfunktion verwendet den kryptografisch sicheren, nicht-deterministischen, nicht startwert fähigen, nicht wiederholbaren random_device-URNG. Für den zweiten Testlauf wird das mersenne_twister_engine als URNG mit einem deterministischen konstanten 32-Bit-Startwert verwendet, was bedeutet, dass die Ergebnisse wiederholbar sind. Der dritte Testlauf startet das mersenne_twister_engine mit einem nicht-deterministischen 32-Bit-Ergebnis aus random_device. Der vierte Testlauf baut darauf auf, indem er eine mit random_device-Ergebnissen gefüllte Startwertsequenz verwendet, die mehr als 32-Bit nicht-deterministische Zufallszahlen ausgibt (die aber immer noch kryptografisch sicher sind). Weitere Informationen dazu erhalten Sie im Folgenden.
[Zum Anfang der Seite wechseln]
Kategorisierte Auflistung
Uniform Random Number-Generatoren
URNGs werden oft anhand folgender Eigenschaften beschrieben:
Periodenlänge: Anzahl von Iterationen, die für eine Wiederholung der generierten Zahlensequenz erforderlich sind. Je länger, desto besser.
Leistung: Geschwindigkeit und Speicherplatzbedarf der Generierung von Zahlen. Je kürzer, desto besser.
Qualität: Ähnlichkeit der generierten Sequenz mit wirklich zufälligen Zahlen. Dies wird häufig als "Zufallscharakter" bezeichnet.
In den folgenden Abschnitten werden die Uniform Random Number-Generatoren (URNGs) im <random>-Header aufgelistet.
[Zum Anfang der Seite wechseln]
Nicht-deterministischer Generator
Generiert eine nicht-deterministische und kryptografisch sichere Zufallssequenz mithilfe eines externen Geräts. Wird normalerweise zur Ausstattung eines Moduls mit einem Startwert verwendet. Geringe Leistung, sehr hohe Qualität. Weitere Informationen finden Sie unter Hinweise. |
[Zum Anfang der Seite wechseln]
Modultypdefinitionen mit voreingestellten Parametern
Zur Instanzierung von Modulen und Moduladaptern. Weitere Informationen finden Sie unter Module und Verteilungen.
Name |
Beschreibung |
|---|---|
default_random_engine |
Typdefinition für das Standardmodul. |
knuth_b |
Knuth-Modul. |
minstd_rand0 |
Minimal Standard Engine 1988 (Lewis, Goodman und Miller 1969). |
minstd_rand |
Aktualisierte Minimal Standard Engine minstd_rand0 (Park, Miller und Stockmeyer 1993). |
mt19937 |
32-Bit-Mersenne-Twistermodul (Matsumoto und Nishimura, 1998). |
mt19937_64 |
64-Bit-Mersenne-Twistermodul (Matsumoto und Nishimura, 2000). |
ranlux24 |
24-Bit-RANLUX-Modul (Martin Lüscher und Fred James, 1994). |
ranlux24_base |
Wird als Grundlage für ranlux24 verwendet. |
ranlux48 |
48-Bit-RANLUX-Modul (Martin Lüscher und Fred James, 1994). |
ranlux48_base |
Wird als Grundlage für ranlux48 verwendet. |
[Zum Anfang der Seite wechseln]
Modulvorlagen
Modulvorlagen werden als eigenständige URNGs verwendet oder als Basismodule an Moduladapter übergeben. Diese werden normalerweise mit einer vorangestellten Modultypdefinition instanziert und an eine Verteilung übergeben. Weitere Informationen erhalten Sie im Abschnitt Module und Verteilungen.
Generiert eine zufällige Sequenz mithilfe des linearen Kongruenzalgorithmus. Sehr stark vereinfacht und niedrigste Qualität. |
|
Generiert mithilfe des Mersenne-Twisteralgorithmus eine Zufallssequenz. Am komplexesten und mit der höchsten Qualität, außer für die Klasse random_device. Sehr schnelle Leistung. |
|
Generiert eine zufällige Sequenz mithilfe des Algorithmus "subtract with carry". Eine Verbesserung gegenüber linear_congruential_engine, aber von viel geringerer Qualität und Leistung als mersenne_twister_engine. |
[Zum Anfang der Seite wechseln]
Moduladaptervorlagen
Moduladapter sind Vorlagen, die andere (Basis-)Module anpassen. Diese werden normalerweise mit einer vorangestellten Modultypdefinition instanziert und an eine Verteilung übergeben. Weitere Informationen erhalten Sie im Abschnitt Module und Verteilungen.
Generiert eine zufällige Sequenz, indem die vom Basismodul zurückgegebenen Werte verworfen werden. |
|
Generiert eine zufällige Sequenz mit einer angegebenen Anzahl von Bits, indem Bits aus vom Basismodul zurückgegebenen Werten erneut verpackt werden. |
|
Generiert eine zufällige Sequenz durch Neupositionieren der Werte, die von ihrem Basismodul zurückgegeben werden. |
[Zum Anfang des Abschnitts wechseln]
[Zum Anfang der Seite wechseln]
Zufallszahlverteilungen
In den folgenden Abschnitten werden die Verteilungen im <random>-Header aufgelistet. Verteilungen sind ein Nachverarbeitungsmechanismus, der normalerweise URNS-Ausgaben als Eingaben verwendet und die Ausgabe mithilfe einer Funktion mit definierter statistischer Wahrscheinlichkeitsdichte verteilt. Weitere Informationen erhalten Sie im Abschnitt Module und Verteilungen.
[Zum Anfang der Seite wechseln]
Gleichförmige Verteilungen.
Produziert eine gleichförmige Ganzzahlwertverteilung über einen Bereich im geschlossenen Intervall [a, b] (inklusiv-inklusiv). |
|
Produziert eine gleichförmige (Gleitkomma-)Echtwerteverteilung über einen Bereich im geschlossenen Intervall [a, b) (inklusiv-exklusiv). |
|
Produziert eine gleiche (Gleitkomma-)Echtwerteverteilung mit vorgegebener Genauigkeit über [0, 1) (inklusiv-exklusiv). |
[Zum Anfang des Abschnitts wechseln]
Bernoulli-Verteilungen
Produziert eine Bernoulli-Verteilung von bool-Werten. |
|
Produziert eine binomiale Verteilung von Ganzzahlwerten. |
|
Produziert eine geometrische Verteilung von Ganzzahlwerten. |
|
Produziert eine negative binomiale Verteilung von Ganzzahlwerten. |
[Zum Anfang des Abschnitts wechseln]
Normalverteilungen
Produziert eine Couch-Verteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine Chi-Quadrat-Verteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine F-Verteilung (auch als Sender-F-Verteilung oder Fisher-Snedecor-Verteilung bekannt) von (Gleitkomma-)Echtwerten. |
|
Produziert eine Lognormalverteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine (Gaußsche) Normalverteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine Student-t-Verteilung von (Gleitkomma-)Echtwerten. |
[Zum Anfang des Abschnitts wechseln]
Poisson-Verteilungen
Produziert eine exponentielle Verteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine Extremwertverteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine Gammaverteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine Poisson-Verteilung von Ganzzahlwerten. |
|
Produziert eine Weibull-Verteilung von (Gleitkomma-)Echtwerten. |
[Zum Anfang des Abschnitts wechseln]
Sampling-Verteilungen
Produziert eine diskrete Ganzzahlverteilung. |
|
Produziert eine stückweise konstante Verteilung von (Gleitkomma-)Echtwerten. |
|
Produziert eine stückweise lineare Verteilung von (Gleitkomma-)Echtwerten. |
[Zum Anfang des Abschnitts wechseln]
[Zum Anfang der Seite wechseln]
Hilfsfunktionen
In diesem Abschnitt werden die allgemeinen Hilfsfunktionen im <random>-Header aufgelistet.
Generiert eine nicht-gewichtete verschlüsselte Startwertsequenz. Wird verwendet, um Replikationen von Zufallsvariablenstreams zu vermeiden. Hilfreich, wenn viele URNGs durch Module instanziert werden. |
Operatoren
In diesem Abschnitt werden die Operation im <random>-Header aufgelistet.
operator== |
Testet, ob der URNG links vom Operator gleich dem Modul rechts vom Operator ist. |
operator!= |
Testet, ob der URNG links vom Operator ungleich dem Modul rechts vom Operator ist. |
operator<< |
Schreibt Zustandsinformationen in einen Stream. |
operator>> |
Extrahiert Zustandsinformationen aus einem Stream. |
[Zum Anfang der Seite wechseln]
Module und Verteilungen
Informationen zu jeder dieser in <random> definierten Vorlagenklassenkategorien finden Sie in den folgenden Abschnitten: Beide dieser Vorlagenklassenkategorien akzeptieren einen Typ als Argument und verwenden allgemeine Namen eines Vorlagenparameters, um die Eigenschaften des Typs, die als tatsächlicher Argumenttyp zulässig sind, wie folgt zu beschreiben:
IntType zeigt short, int, long, long long, unsigned short, unsigned int, unsigned long oder unsigned long long an.
UIntType zeigt unsigned short, unsigned int, unsigned long oder unsigned long long an.
RealType zeigt float, double oder long double an.
Module
Module und Moduladapter sind Vorlagen, mit deren Parametern der erstellte Generator angepasst wird.
Ein Modul ist eine Klasse oder Vorlagenklasse, deren Instanzen (Generatoren) als Quelle von Zufallszahlen fungieren, die gleichmäßig zwischen einem Mindest- und einen Höchstwert verteilt werden. Ein Moduladapter gibt eine Sequenz von Werten aus, die verschiedene Zufallscharaktereigenschaften haben, indem er von einem anderen Zufallswertemodul produzierte Werte übernimmt und einen bestimmtem Algorithmus an diese Werte übergibt.
Jedes Modul und jeder Moduladapter haben die folgenden Member:
typedef numeric-type result_type ist der vom operator() des Generators zurückgegebene Typ. Der numeric-type wird als Vorlagenparameter bei der Instanzierung übergeben.
result_type operator() gibt Werte zurück, die gleichmäßig zwischen min() und max() verteilt werden.
result_type min() gibt den vom operator() des Generators zurückgegeben Mindestwert zurück. Moduladapter verwenden das min()-Ergebnis des Basismoduls.
result_type max() gibt den vom operator() des Generators zurückgegeben Höchstwert zurück. Wenn result_type ein Integraltyp (Ganzzahlwerttyp) ist, ist max() der Höchstwert, der tatsächlich zurückgegeben werden kann (inklusiv). Wenn result_type ein Gleitkommatyp (Echtwerttyp) ist, ist max() der kleinste Wert, der größer als alle Werte ist, die zurückgegeben werden können (nicht-inklusiv). Moduladapter verwenden das max()-Ergebnis des Basismoduls.
void seed(result_type s) startet den Generator mit dem Startwert s. Für Module lautet die Signatur zur Unterstützung von Standardparametern void seed(result_type s = default_seed) (Moduladapter definieren einen separaten void seed(), siehe nächsten Unterabschnitt).
template <class Seq> void seed(Seq& q) startet den Generator mithilfe einer seed_seq Seq.
Ein expliziter Konstruktor mit dem Argument result_type x, mit dem ein Generator erstellt wird, der mit Startwerten versehen ist, als wäre seed(x) aufgerufen worden.
Ein expliziter Konstruktor mit dem Argument seed_seq& seq, mit dem ein Generator erstellt wird, der mit Startwerten versehen ist, als wäre seed(seq) aufgerufen worden.
void discard(unsigned long long count) ruft operator() effektiv mit der Häufigkeit count auf und bewertet jeden Wert.
Moduladapter unterstützen zusätzlich diese Member (Engine ist der erste Vorlagenparameter eines Moduladapters, der den Typ des Basismoduls bezeichnet):
Ein Standardkonstruktor zur Initialisierung des Generators genau wie durch den Standardkonstruktor des Basismoduls.
Ein expliziter Konstruktor mit dem Argument const Engine& eng. Dieser dient zur Unterstützung einer Kopienkonstruktion mithilfe des Basismoduls.
Ein expliziter Konstruktor mit dem Argument Engine&& eng. Dieser dient zur Unterstützung einer Verschiebungskonstruktion mithilfe des Basismoduls.
void seed(), der den Generator mit dem Standardstartwert des Basismoduls initialisiert.
const Engine& base()-Eigenschaftsfunktion, die das Basismodul zurückgibt, das zur Konstruktion des Generators verwendet wurde.
Jedes Modul besitzt einen Zustand, mit dem die Sequenz der Werte bestimmt wird, die durch nachfolgende Aufrufe von operator() generiert werden. Die Zustände von zwei Generatoren, die von Modulen desselben Typs instanziert wurden, können mithilfe von operator== und operator!= verglichen werden. Wenn die beiden Zustände als gleich verglichen werden, generieren Sie dieselbe Sequenz von Werten. Der Zustand eines Objekts kann als Sequenz von 32-Bit-Werten ohne Vorzeichen zu einem Stream gespeichert werden, indem die operator<< des Generators verwendet werden. Der Zustand wird durch das Speichern nicht geändert. Ein gespeicherter Zustand kann mithilfe von operator>> in den Generator eingelesen werden, der von einem Modul desselben Typs instanziert wurde.
[Zum Anfang der Seite wechseln]
Verteilungen
Die Verteilung ist eine Klasse oder eine Vorlagenklasse, deren Instanzen einen Stream gleichmäßig verteilter Zufallszahlen transformieren, die aus einem Modul in einen Stream von Zufallszahlen mit einer bestimmten Verteilung bezogen werden. Jede Verteilung verfügt über die folgenden Member:
typedef numeric-type result_type ist der vom operator() der Verteilung zurückgegebene Typ. Der numeric-type wird als Vorlagenparameter bei der Instanzierung übergeben.
template <class URNG> result_type operator()(URNG& gen) gibt Werte zurück, die entsprechend der Definition der Verteilung verteilt werden, indem gen als Quelle für gleichmäßig verteilte Zufallswerte und die gespeicherten Parameter der Verteilung verwendet wird.
template <class URNG> result_type operator()(URNG& gen, param_type p) gibt die Werte zurück, die in Übereinstimmung mit der Definition der Verteilung mithilfe von gen als Quelle für gleichmäßig verteilte Zufallswerte und die Parameterstruktur p verteilt werden.
typedef unspecified-type param_type ist das Paket von Parametern, die optional an operator() übergeben werden, und wird anstelle der gespeicherten Parameter verwendet, um dessen Rückgabewert zu generieren.
Ein const param&-Konstruktor initialisiert die gespeicherten Parameter aus dem Argument.
param_type param() const ruft die gespeicherten Parameter ab.
void param(const param_type&) legt die gespeicherten Parameter aus dem Argument fest.
result_type min() gibt den vom operator() der Verteilung zurückgegeben Mindestwert zurück.
result_type max() gibt den vom operator() der Verteilung zurückgegebenen Höchstwert zurück. Wenn result_type ein Integraltyp (Ganzzahlwerttyp) ist, ist max() der Höchstwert, der tatsächlich zurückgegeben werden kann (inklusiv). Wenn result_type ein Gleitkommatyp (Echtwerttyp) ist, ist max() der kleinste Wert, der größer als alle Werte ist, die zurückgegeben werden können (nicht-inklusiv).
void reset() verwirft alle zwischengespeicherten Werte, damit das Ergebnis des folgenden Aufrufs von operator() nicht von Werten abhängig ist, die vor dem Aufruf aus dem Modul bezogen wurden.
Eine Parameterstruktur ist ein Objekt, in dem alle für eine Verteilung erforderlichen Parameter gespeichert werden. Sie enthält folgende Informationen:
typedef distribution-type distribution_type ist der Typ der Verteilung.
Mindestens ein Konstruktor, der die gleichen Parameterlisten akzeptiert, wie von den Verteilungskonstruktoren akzeptiert werden.
Die gleichen Parameterzugriffsfunktionen wie bei der Verteilung.
Gleichheits- und Ungleichheitsvergleichsoperatoren.
Weitere Informationen erhalten Sie in den entsprechenden Unterthemen unter diesem Thema, auf die zuvor in diesem Artikel verlinkt wurde.
[Zum Anfang der Seite wechseln]
Hinweise
Dies sind zwei höchst hilfereiche URNGs in Visual Studio – mt19937 und random_device – wie in der Vergleichstabelle gezeigt:
URNG |
Schnell? |
Kryptografisch sicher? |
Startwertfähig? |
Deterministisch? |
|---|---|---|---|---|
mt19937 |
Ja |
Nein |
Ja |
Ja* |
random_device |
Nein |
Ja |
Nein |
Nein |
* Wenn mit einem bekannten Startwert ausgestattet.
Obwohl der ISO C++-Standard nicht erfordert, dass random_device kryptografisch sicher ist, wird es in Visual Studio implementiert, um kryptografische Sicherheit herzustellen. (Der Begriff „kryptografisch sicher“ drückt keine Garantie aus, sondern bezeichnet ein Mindest-Entropieniveau – und damit ein Vorhersagbarkeitsniveau –, das ein bestimmter Randomisierungsalgorithmus aufweist. Weitere Informationen finden Sie im Wikipedia-Artikel Cryptographically secure pseudorandom number generator Kryptographisch sicherer Zufallszahlengenerator, in englischer Sprache).) Da der ISO C++-Standard dies nicht erfordert, können andere Plattformen random_device als einfachen Zufallszahlengenerator (kryptografisch nicht sicher) implementieren, der nur als Stammwertequelle für einen anderen Generator geeignet ist. Lesen Sie die Dokumentation für diese Plattformen, wenn Sie random_device plattformübergreifend verwenden.
random_device-Ergebnisse sind per Definition nicht reproduzierbar, und ein Nebeneffekt ist, dass er eventuell deutlich langsamer läuft als andere URNGs. Die meisten Anwendungen, für die keine kryptografische Sicherheit erforderlich sind, verwenden mt19937 oder ein ähnliches Modul, obwohl Sie es vielleicht mit einem Aufruf von random_device starten möchten, wie im Codebeispiel gezeigt.
[Zum Anfang der Seite wechseln]