std:: philox_engine

Definiert im Header <random>
template < class UIntType, std:: size_t w, std:: size_t n, std:: size_t r, UIntType... consts > class philox_engine ;		(seit C++26)

std::philox_engine ist eine zählerbasierte Zufallszahlen-Engine.

Inhaltsverzeichnis 1 Template-Parameter 2 Generator-Eigenschaften 2.1 Erzeugen von Zufallswerten 2.2 Aktualisieren der Ausgabesequenz 3 Vordefinierte Spezialisierungen 4 Geschachtelte Typen 5 Datenmitglieder 6 Elementfunktionen 6.1 Konstruktion und Seeding 6.2 Generierung 6.3 Eigenschaften 7 Nicht-Elementfunktionen 8 Anmerkungen 9 Beispiel

Template-Parameter

UIntType	-	Der vom Generator erzeugte Ergebnistyp. Das Verhalten ist undefiniert, falls dies nicht einer der Typen unsigned short , unsigned int , unsigned long , oder unsigned long long ist.
w	-	die Wortgröße in Bits
n	-	die Wortanzahl
r	-	die Rundenzahl
consts	-	die Folge von Multiplikatoren und Rundungskonstanten zur Erzeugung von Zufallszahlen

Wenn einer der folgenden Werte nicht true ist, ist das Programm fehlerhaft:

• sizeof... ( consts ) == n
• n == 2 || n == 4
• 0 < r
• 0 < w && w <= std:: numeric_limits < UIntType > :: digits

Generatoreigenschaften

In der folgenden Beschreibung sei \(\scriptsize Q_i \) Q i das i te Element der Sequenz Q , wobei der Index bei null beginnt.

Die Größe der Zustände von philox_engine beträgt \(\scriptsize O(n)\) O(n) , jeder davon besteht aus vier Teilen:

• Eine Sequenz X von n ganzzahligen Werten, wobei jeder Wert im Bereich [ ​ 0 ​ , 2 w
) liegt.

• Diese Sequenz repräsentiert einen großen vorzeichenlosen Ganzzahl-Zählerwert \(\scriptsize Z=\sum_{j=0}^{n-1} X \cdot 2^{wj} \) Z=∑ n-1
  j=0 X⋅2 wj
  von \(\scriptsize n \cdot w \) n⋅w Bits.

• Eine Sequenz K von n / 2 Schlüsseln des Typs UIntType .
• Ein Puffer Y von n produzierten Werten des Typs UIntType .
• Ein Index j im Y -Puffer.

Der Übergangsalgorithmus von philox_engine ( \(\scriptsize TA(X_i) \) TA(X i ) ) ist wie folgt definiert:

• Wenn j nicht n - 1 ist, erhöht j um 1 . ^[1]
• Wenn j gleich n - 1 ist, führt die folgenden Operationen aus: ^[2]

1. Erzeugt eine neue Sequenz von n Zufallswerten (siehe unten) und speichert sie in Y .
2. Erhöht den Zähler Z um 1 .
3. Setzt j auf ​ 0 ​ zurück.

Der Generierungsalgorithmus von philox_engine ist \(\scriptsize GA(X_i)=Y_j \) GA(X i )=Y j .

1. ↑ In diesem Fall gibt der nächste Generierungsalgorithmus-Aufruf den nächsten generierten Wert im Buffer zurück.
2. ↑ In diesem Fall wird der Buffer aktualisiert, und der nächste Generierungsalgorithmus-Aufruf gibt den ersten Wert im neuen Buffer zurück.

Erzeugung von Zufallswerten

Zufällige Werte werden aus den folgenden Parametern generiert:

• die Anzahl der Runden r
• die aktuelle Zählersequenz X
• die Schlüsselfolge K
• die Multiplikatorfolge M
• die Rundkonstantenfolge C

Die Sequenzen M und C werden aus den Werten des Template-Parameterpacks consts gebildet, welches die \(\scriptsize M_k \) M k - und \(\scriptsize C_k \) C k -Konstanten als [ \(\scriptsize M_0 \) M 0 , \(\scriptsize C_0 \) C 0 , \(\scriptsize M_1 \) M 1 , \(\scriptsize C_1 \) C 1 ,... , ..., \(\scriptsize M_{n/2-1} \) M n/2-1 , \(\scriptsize C_{n/2-1} \) C n/2-1 ] darstellt.

Zufallszahlen werden durch den folgenden Prozess generiert:

1. Initialisiert die Ausgabesequenz S mit den Elementen von X .
2. Aktualisiert die Elemente von S für r Runden.
3. Ersetzt die Werte im Puffer Y durch die Werte in S .

Aktualisieren der Ausgabesequenz

Für jede Aktualisierungsrunde wird eine Zwischensequenz V mit den Elementen von S in einer bestimmten Reihenfolge initialisiert:

n	\(\scriptsize V_{0} \) V 0	\(\scriptsize V_{1} \) V 1	\(\scriptsize V_{2} \) V 2	\(\scriptsize V_{3} \) V 3
2	\(\scriptsize S_0 \) S 0	\(\scriptsize S_1 \) S 1	Nicht verfügbar
4	\(\scriptsize S_2 \) S 2	\(\scriptsize S_1 \) S 1	\(\scriptsize S_0 \) S 0	\(\scriptsize S_3 \) S 3

Gegeben sind die folgenden Operationsnotationen:

• \(\scriptsize \mathsf{xor} \) xor , eingebauter bitweiser XOR-Operator .
• \(\scriptsize \mathsf{mullo} \) mullo , berechnet die niederwertige Hälfte der modularen Multiplikation und ist definiert als \(\scriptsize \mathsf{mullo}(a,b,w)=(a \cdot b) \mod 2^w \) mullo(a,b,w)=(a⋅b) mod 2 w
  .
• \(\scriptsize \mathsf{mulhi} \) mulhi , berechnet die höherwertige Hälfte der Multiplikation und ist definiert als \(\scriptsize \mathsf{mulhi}(a,b,w)=\left\lfloor (a \cdot b)/2^w \right\rfloor \) mulhi(a,b,w)=⌊(a⋅b)/2 w
  ⌋ .

Sei q die aktuelle Rundenanzahl (beginnend bei null), für jede ganze Zahl k in [ ​ 0 ​ , n / 2 ) werden die Elemente der Ausgabesequenz S wie folgt aktualisiert:

• \(\scriptsize X_{2 \cdot k}=\mathsf{mulhi}(V_{2 \cdot k},M_k,w)\ \mathsf{xor}\ ((K_k+q \cdot C_k) \mod 2^w)\ \mathsf{xor}\ V_{2 \cdot k+1} \) X 2⋅k =mulhi(V 2⋅k ,M k ,w) xor ((K k +q⋅C k ) mod 2 w
  ) xor V 2⋅k+1
• \(\scriptsize X_{2 \cdot k+1}=\mathsf{mullo}(V_{2 \cdot k},M_k,w) \) X 2⋅k+1 =mullo(V 2⋅k ,M k ,w)

*Hinweis: Der mathematische Formeltext innerhalb der -Tags wurde gemäß den Anforderungen nicht übersetzt, da er als Code/Mathematik-Inhalt betrachtet wird. Die HTML-Struktur und alle Tags wurden unverändert beibehalten.*

Vordefinierte Spezialisierungen

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

Definiert im Header <random>
Typ	Definition
philox4x32 (C++26)	std :: philox_engine < std:: uint_fast32_t , 32 , 4 , 10 , 0xCD9E8D57 , 0x9E3779B9 , 0xD2511F53 , 0xBB67AE85 >
philox4x64 (C++26)	std :: philox_engine < std:: uint_fast64_t , 64 , 4 , 10 , 0xCA5A826395121157 , 0x9E3779B97F4A7C15 , 0xD2E7470EE14C6C93 , 0xBB67AE8584CAA73B >

Verschachtelte Typen

Typ	Definition
result_type	UIntType

Datenmitglieder

constexpr std::size_t word_size [static]	w (öffentliche statische Member-Konstante)
constexpr std::size_t word_count [static]	n (öffentliche statische Member-Konstante)
constexpr std::size_t round_count [static]	r (öffentliche statische Member-Konstante)
constexpr std:: array < result_type, word_count / 2 > multipliers [static]	die Multiplikatorsequenz M (öffentliche statische Member-Konstante)
constexpr std:: array < result_type, word_count / 2 > round_consts [static]	die Rundungs-Konstanten-Sequenz C (öffentliche statische Member-Konstante)
constexpr std::uint_least32_t default_seed [static]	20111115u (öffentliche statische Member-Konstante)

Memberfunktionen

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

Nicht-Member-Funktionen

operator== (C++26)	vergleicht die internen Zustände zweier Pseudozufallszahlengeneratoren (Funktion)
operator<< operator>> (C++26)	führt Stream-Eingabe und -Ausgabe auf Pseudozufallszahlengenerator durch (Funktionsschablone)

Hinweise

Feature-Test Makro	Wert	Std	Feature
__cpp_lib_philox_engine	202406L	(C++26)	std::philox_engine

Beispiel

Dieser Abschnitt ist unvollständig Grund: Kein Beispiel