Namespaces
Variants

std:: mersenne_twister_engine

From cppreference.net
C++
Numerics library
Pseudo-random number generation
Random number distributions
Uniform distributions
(C++11)
(C++11)
(C++11)
Bernoulli distributions
(C++11)
(C++11)
(C++11)
(C++11)
Poisson distributions
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Normal distributions
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Sampling distributions
(C++11)
(C++11)
(C++11)
std::mersenne_twister_engine
Definiert in Header <random>
template <

class UIntType, std:: size_t w, std:: size_t n, std:: size_t m, std:: size_t r,
UIntType a, std:: size_t u, UIntType d, std:: size_t s,
UIntType b, std:: size_t t, UIntType c, std:: size_t l, UIntType f

> class mersenne_twister_engine ;
(seit C++11)

mersenne_twister_engine ist eine Zufallszahlen-Engine basierend auf dem Mersenne-Twister -Algorithmus. Sie erzeugt hochwertige, jedoch nicht kryptografisch sichere, vorzeichenlose Ganzzahl-Zufallszahlen des Typs UIntType im Intervall [0, 2 w
) .

Inhaltsverzeichnis

Template-Parameter

UIntType - Der vom Generator erzeugte Ergebnistyp. Das Verhalten ist undefiniert, wenn dies nicht einer von unsigned short , unsigned int , unsigned long , oder unsigned long long ist.
w - die Zweierpotenz, die den Wertebereich der vom Engine erzeugten Werte bestimmt
n - der Grad der Rekursion
m - das mittlere Wort, ein Offset, der in der den Zustand definierenden Rekursionsbeziehung verwendet wird
r - die Anzahl der Bits der unteren Bitmaske, auch bekannt als Twist-Wert
a - die bedingte XOR-Maske, d.h. die Koeffizienten der rationalen Normalform der Twist-Matrix
u, d, s, b, t, c, l - die 1. te bis 7. te Komponente der Bit-Scrambling (Tempering)-Matrix
f - der Initialisierungsmultiplikator

Wenn eine der folgenden Einschränkungen verletzt wird, ist das Programm fehlerhaft:

  • m liegt in [ 1 , n ] .
  • Die folgenden Ausdrücke sind alle true :
  • Gegeben ( 1u << w ) - 1u als w1 , sind die folgenden Ausdrücke alle true :
  • a <= w1
  • b <= w1
  • c <= w1
  • d <= w1
  • f <= w1
**Anmerkung:** Der gesamte Inhalt befindet sich innerhalb von ` ` Tags, die als Code-Blöcke behandelt werden sollen. Gemäß den Anweisungen wurde daher kein Text übersetzt, da es sich um C++-Code handelt, der unverändert bleiben muss.

Generatoreigenschaften

Die Größe der Zustände von mersenne_twister_engine beträgt n , wobei jeder aus einer Sequenz X von n Werten des Typs result_type besteht. X j steht für den j mod n -ten Wert (beginnend bei 0) von X .

Gegeben die folgenden bitweisen Operationsnotationen:

Der Übergangsalgorithmus von mersenne_twister_engine ( TA(x i ) ) ist wie folgt definiert:

  1. Verkette die oberen w - r Bits von X i-n mit den unteren r Bits von X i+1-n , um einen vorzeichenlosen Ganzzahlwert Y zu erhalten.
  2. Sei y gleich a·(Y bitand 1) , und setze X i auf X i+m−n xor (Y rshift 1) xor y .

Der Generierungsalgorithmus von mersenne_twister_engine ( GA(x i ) ) ist wie folgt definiert:

  1. Sei z 1 gleich X i xor ((X i rshift u) bitand d) .
  2. Sei z 2 gleich X i xor (((X i lshift s) mod 2 w
    ) bitand b)     .
  3. Sei z 3 gleich X i xor (((X i lshift t) mod 2 w
    ) bitand c)     .
  4. Sei z 4 gleich z 3 xor (z 3 rshift l) .
  5. Liefere z 4 als Ergebnis (d.h. GA(x i )=z 4 ).

Vordefinierte Spezialisierungen

Die folgenden Spezialisierungen definieren die Zufallszahlen-Engine mit zwei häufig verwendeten Parametersätzen:

Definiert im Header <random>
Typ Definition
mt19937 (C++11)

std :: mersenne_twister_engine < std:: uint_fast32_t ,
32 , 624 , 397 , 31 ,
0x9908b0df , 11 ,
0xffffffff , 7 ,
0x9d2c5680 , 15 ,
0xefc60000 , 18 , 1812433253 >
32-Bit Mersenne Twister von Matsumoto und Nishimura, 1998

mt19937_64 (C++11)

std :: mersenne_twister_engine < std:: uint_fast64_t ,
64 , 312 , 156 , 31 ,
0xb5026f5aa96619e9 , 29 ,
0x5555555555555555 , 17 ,
0x71d67fffeda60000 , 37 ,
0xfff7eee000000000 , 43 ,
6364136223846793005 >
64-Bit Mersenne Twister von Matsumoto und Nishimura, 2000

Verschachtelte Typen

Typ Definition
result_type UIntType

Datenmitglieder

constexpr size_t Wortgröße
[static]
w
(öffentliche statische Elementkonstante)
constexpr size_t Zustandsgröße
[static]
n
(öffentliche statische Elementkonstante)
constexpr size_t Schiebeweite
[static]
m
(öffentliche statische Elementkonstante)
constexpr size_t Maskenbits
[static]
r
(öffentliche statische Elementkonstante)
constexpr UIntType XOR-Maske
[static]
a
(öffentliche statische Elementkonstante)
constexpr size_t Temperierung_u
[static]
u
(öffentliche statische Elementkonstante)
constexpr UIntType Temperierung_d
[static]
d
(öffentliche statische Elementkonstante)
constexpr size_t Temperierung_s
[static]
s
(öffentliche statische Elementkonstante)
constexpr UIntType Temperierung_b
[static]
b
(öffentliche statische Elementkonstante)
constexpr size_t Temperierung_t
[static]
t
(öffentliche statische Elementkonstante)
constexpr UIntType Temperierung_c
[static]
c
(öffentliche statische Elementkonstante)
constexpr size_t Temperierung_l
[static]
l
(öffentliche statische Elementkonstante)
constexpr UIntType Initialisierungsmultiplikator
[static]
f
(öffentliche statische Elementkonstante)
constexpr UIntType Standardstartwert
[static]
5489u
(öffentliche statische Elementkonstante)

Memberfunktionen

Konstruktion und Initialisierung
konstruiert die Engine
(öffentliche Elementfunktion)
setzt den aktuellen Zustand der Engine
(öffentliche Elementfunktion)
Generierung
bewegt den Zustand der Engine vor und gibt den generierten Wert zurück
(öffentliche Elementfunktion)
bewegt den Zustand der Engine um einen bestimmten Betrag vor
(öffentliche Elementfunktion)
Eigenschaften
[static]
ermittelt den kleinstmöglichen Wert im Ausgabebereich
(öffentliche statische Elementfunktion)
[static]
ermittelt den größtmöglichen Wert im Ausgabebereich
(öffentliche statische Elementfunktion)

Nicht-Member-Funktionen

(C++11) (C++11) (removed in C++20)
vergleicht die internen Zustände zweier Pseudozufallszahlengeneratoren
(Funktion)
(C++11)
führt Stream-Eingabe und -Ausgabe auf Pseudozufallszahlengenerator durch
(Funktionstemplate)

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel