std::mersenne_twister_engine

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Numerik-Bibliothek

Allgemeine mathematische Funktionen
Mathematische Spezialfunktionen (C++17)
Mathematische Konstanten (C++20)
Grundlegende lineare Algebra-Algorithmen (C++26)
Datenparallele Typen (SIMD) (C++26)
Gleitkomma-Umgebung (C++11)
Komplexe Zahlen
Numerische Arrays (valarray)
Pseudozufallszahlengenerierung
Bit-Manipulation (C++20)
Faktoroperationen
gcd (C++17)	lcm (C++17)
Interpolationen
midpoint (C++20)	lerp (C++20)
Sättigungsarithmetik
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generische numerische Operationen
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference    partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)

 

Pseudozufallszahlengenerierung

Gleichmäßige Zufallsbitgeneratoren   uniform_random_bit_generator (C++20) Zufallszahlengeneratoren linear_congruential_engine (C++11) mersenne_twister_engine (C++11) subtract_with_carry_engine (C++11) philox_engine (C++26) Zufallszahlengenerator-Adapter discard_block_engine (C++11) independent_bits_engine (C++11) shuffle_order_engine (C++11) Vordefinierte Zufallszahlengeneratoren Nicht-deterministische Zufallszahlen random_device (C++11) Dienstprogramme generate_canonical (C++11) seed_seq (C++11) Zufallszahlengenerierungsalgorithmen ranges::generate_random (C++26) C-Bibliothek für Zufallszahlen rand    srand    RAND_MAX

Zufallszahlengenerierungsverteilungen Gleichmäßige Verteilungen uniform_int_distribution (C++11) uniform_real_distribution (C++11) generate_canonical (C++11) Bernoulli-Verteilungen bernoulli_distribution (C++11) binomial_distribution (C++11) negative_binomial_distribution (C++11) geometric_distribution (C++11) Poisson-Verteilungen poisson_distribution (C++11) exponential_distribution (C++11) gamma_distribution (C++11) weibull_distribution (C++11) extreme_value_distribution (C++11) Normalverteilungen normal_distribution (C++11) lognormal_distribution (C++11) chi_squared_distribution (C++11) cauchy_distribution (C++11) fisher_f_distribution (C++11) student_t_distribution (C++11) Stichprobenverteilungen discrete_distribution (C++11) piecewise_constant_distribution (C++11) piecewise_linear_distribution (C++11)

 

std::mersenne_twister_engine

Memberfunktionen

mersenne_twister_engine::mersenne_twister_engine

mersenne_twister_engine::seed

Generierung

mersenne_twister_engine::operator()

mersenne_twister_engine::discard

Eigenschaften des Generators

mersenne_twister_engine::min

mersenne_twister_engine::max

Nicht-Member-Funktionen

operator==operator!= (C++11)(C++11)(bis C++20)

operator<<operator>> (C++11)(C++11)

 

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 Zufallszahlenerzeugungs-Engine, die auf dem Mersenne-Twister-Algorithmus basiert. Sie erzeugt qualitativ hochwertige, aber nicht kryptographisch sichere, vorzeichenlose Ganzzahl-Zufallszahlen vom Typ UIntType im Intervall \(\scriptsize {[0,2^w)}\)[0, 2w
).

Template-Parameter

UIntType	-	Der vom Generator erzeugte Ergebnistyp. Das Verhalten ist undefiniert, wenn dies nicht einer der folgenden Typen ist: unsigned short, unsigned int, unsigned long oder unsigned long long.
w	-	die Potenz von zwei, die den Wertebereich bestimmt, der von der Engine erzeugt wird
n	-	der Grad der Rekurrenz
m	-	das mittlere Wort, ein Offset, der in der Rekurrenzrelation für den Zustand 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-Twist-Matrix
u, d, s, b, t, c, l	-	die 1. bis 7. Komponente der Bit-Scrambling-Matrix (Tempering)
f	-	der Initialisierungsmultiplikator

Wenn eine der folgenden Einschränkungen verletzt wird, ist das Programm fehlerhaft (ill-formed).

• m liegt in [1, n].
• Die folgenden Ausdrücke sind alle true

• w >= 3
• w >= r
• w >= u
• w >= s
• w >= t
• w >= l
• w <= std::numeric_limits<UIntType>::digits

• Gegeben (1u << w) - 1u als w1, sind die folgenden Ausdrücke alle true

• a <= w1
• b <= w1
• c <= w1
• d <= w1
• f <= w1

Generatoreigenschaften

Die Größe der Zustände von mersenne_twister_engine ist n, wobei jeder Zustand aus einer Sequenz X von n Werten vom Typ result_type besteht. \(\scriptsize X_j\)Xj steht für den \(\scriptsize j\mod n\)j mod n-ten Wert (beginnend bei 0) von X.

Gegeben die folgenden Notationen für bitweise Operationen:

• \(\scriptsize \mathsf{bitand}\)bitand, integriertes bitweises AND.
• \(\scriptsize \mathsf{xor}\)xor, integriertes bitweises XOR.
• \(\scriptsize \mathsf{lshift}\)lshift, integriertes bitweises Linksshift.
• \(\scriptsize \mathsf{rshift}\)rshift, integriertes bitweises Rechtsshift.

Der Übergangsalgorithmus von mersenne_twister_engine (\(\scriptsize TA(x_i)\)TA(xi)) ist wie folgt definiert:

1. Verketten Sie die oberen w - r Bits von \(\scriptsize X_{i-n}\)Xi-n mit den unteren r Bits von \(\scriptsize X_{i+1-n}\)Xi+1-n, um einen vorzeichenlosen Ganzzahlwert Y zu erhalten.
2. Setze y auf \(\scriptsize a \cdot (Y\ \mathsf{bitand}\ 1)\)a·(Y bitand 1) und setze \(\scriptsize X_i\)Xi auf \(\scriptsize X_{i+m−n}\ \mathsf{xor}\ (Y\ \mathsf{rshift}\ 1)\ \mathsf{xor}\ y\)Xi+m−n xor (Y rshift 1) xor y.

Der Generierungsalgorithmus von mersenne_twister_engine (\(\scriptsize GA(x_i)\)GA(xi)) ist wie folgt definiert:

1. Setze \(\scriptsize z_1\)z1 auf \(\scriptsize X_i\ \mathsf{xor}\ ((X_i\ \mathsf{rshift}\ u)\ \mathsf{bitand}\ d)\)Xi xor ((Xi rshift u) bitand d).
2. Setze \(\scriptsize z_2\)z2 auf \(\scriptsize z_1\ \mathsf{xor}\ (((z_1\ \mathsf{lshift}\ s)\mod 2^w)\ \mathsf{bitand}\ b)\)Xi xor (((Xi lshift s) mod 2w
   ) bitand b).
3. Setze \(\scriptsize z_3\)z3 auf \(\scriptsize z_2\ \mathsf{xor}\ (((z_2\ \mathsf{lshift}\ t)\mod 2^w)\ \mathsf{bitand}\ c)\)Xi xor (((Xi lshift t) mod 2w
   ) bitand c).
4. Setze \(\scriptsize z_4\)z4 auf \(\scriptsize z_3\ \mathsf{xor}\ (z_3\ \mathsf{rshift}\ l)\)z3 xor (z3 rshift l).
5. Gib \(\scriptsize z_4\)z4 als Ergebnis zurück (d.h. \(\scriptsize GA(x_i)=z_4\)GA(xi)=z4).

Vordefinierte Spezialisierungen

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

Definiert in 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

Datenelemente

constexpr size_t word_size [static]	w (öffentliche statische Member-Konstante)
constexpr size_t state_size [static]	n (öffentliche statische Member-Konstante)
constexpr size_t shift_size [static]	m (öffentliche statische Member-Konstante)
constexpr size_t mask_bits [static]	r (öffentliche statische Member-Konstante)
constexpr UIntType xor_mask [static]	a (öffentliche statische Member-Konstante)
constexpr size_t tempering_u [static]	u (öffentliche statische Member-Konstante)
constexpr UIntType tempering_d [static]	d (öffentliche statische Member-Konstante)
constexpr size_t tempering_s [static]	s (öffentliche statische Member-Konstante)
constexpr UIntType tempering_b [static]	b (öffentliche statische Member-Konstante)
constexpr size_t tempering_t [static]	t (öffentliche statische Member-Konstante)
constexpr UIntType tempering_c [static]	c (öffentliche statische Member-Konstante)
constexpr size_t tempering_l [static]	l (öffentliche statische Member-Konstante)
constexpr UIntType initialization_multiplier [static]	f (öffentliche statische Member-Konstante)
constexpr UIntType default_seed [static]	5489u (öffentliche statische Member-Konstante)

Memberfunktionen

Konstruktion und Initialisierung
(Konstruktor)	konstruiert die Engine (public member function) [[Bearbeiten]]
seed	setzt den aktuellen Zustand der Engine (public member function) [[Bearbeiten]]
Generierung
operator()	verschiebt den Zustand der Engine und gibt den generierten Wert zurück (public member function) [[Bearbeiten]]
discard	verschiebt den Zustand der Engine um einen angegebenen Betrag (public member function) [[Bearbeiten]]
Eigenschaften des Generators
min [static]	liefert den kleinstmöglichen Wert im Ausgabebereich (public static member function) [[Bearbeiten]]
max [static]	liefert den größtmöglichen Wert im Ausgabebereich (public static member function) [[Bearbeiten]]

Nicht-Memberfunktionen

operator==operator!= (C++11)(C++11)(entfernt in C++20)	vergleicht die internen Zustände zweier Pseudozufallszahlengeneratoren (function)
operator<<operator>> (C++11)	führt Stream-Ein- und -Ausgabe auf Pseudo-Zufallszahlengeneratoren durch (function template)