std:: philox_engine

Défini dans l'en-tête <random>
template < class UIntType, std:: size_t w, std:: size_t n, std:: size_t r, UIntType... consts > class philox_engine ;		(depuis C++26)

std::philox_engine est un générateur de nombres aléatoires basé sur un compteur.

Table des matières 1 Paramètres du modèle 2 Propriétés du générateur 2.1 Génération de valeurs aléatoires 2.2 Mise à jour de la séquence de sortie 3 Spécialisations prédéfinies 4 Types imbriqués 5 Membres de données 6 Fonctions membres 6.1 Construction et amorçage 6.2 Génération 6.3 Caractéristiques 7 Fonctions non membres 8 Notes 9 Exemple

Paramètres du modèle

UIntType	-	Le type de résultat généré par le générateur. L'effet est indéfini si ce n'est pas l'un des unsigned short , unsigned int , unsigned long , ou unsigned long long .
w	-	la taille du mot en bits
n	-	le nombre de mots
r	-	le nombre de tours
consts	-	la séquence de multiplicateurs et de constantes de tour utilisée pour générer des nombres aléatoires

Si l'une des valeurs suivantes n'est pas true , le programme est mal formé :

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

Propriétés du générateur

Dans la description suivante, soit \(\scriptsize Q_i \) Q i désigne le i ième élément de la séquence Q , où l'indice commence à zéro.

La taille des états du philox_engine est \(\scriptsize O(n)\) O(n) , chacun d'eux est constitué de quatre parties :

• Une séquence X de n valeurs entières, où chaque valeur est dans [ ​ 0 ​ , 2 w
) .

• Cette séquence représente une valeur de compteur entier non signé de grande taille \(\scriptsize Z=\sum_{j=0}^{n-1} X \cdot 2^{wj} \) Z=∑ n-1
  j=0 X⋅2 wj
  de \(\scriptsize n \cdot w \) n⋅w bits.

• Une séquence K de n / 2 clés de type UIntType .
• Un tampon Y de n valeurs produites de type UIntType .
• Un index j dans le tampon Y .

L' algorithme de transition de philox_engine ( \(\scriptsize TA(X_i) \) TA(X i ) ) est défini comme suit :

• Si j n'est pas n - 1 , incrémente j de 1 . ^[1]
• Si j est n - 1 , effectue les opérations suivantes : ^[2]

1. Génère une nouvelle séquence de n valeurs aléatoires (voir ci-dessous) et les stocke dans Y .
2. Incrémente le compteur Z de 1 .
3. Réinitialise j à ​ 0 ​ .

L' algorithme de génération de philox_engine est \(\scriptsize GA(X_i)=Y_j \) GA(X i )=Y j .

1. ↑ Dans ce cas, l'appel de l'algorithme de génération suivante retourne la prochaine valeur générée dans le tampon.
2. ↑ Dans ce cas, le tampon est actualisé, et l'appel de l'algorithme de génération suivante retourne la première valeur dans le nouveau tampon.

Génération de valeurs aléatoires

Les valeurs aléatoires sont générées à partir des paramètres suivants :

• le nombre de tours r
• la séquence de compteur actuelle X
• la séquence de clé K
• la séquence de multiplicateur M
• la séquence de constantes de tour C

Les séquences M et C sont formées à partir des valeurs du paramètre de modèle variadique consts , qui représente les constantes \(\scriptsize M_k \) M k et \(\scriptsize C_k \) C k sous la forme [ \(\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 ] .

Les nombres aléatoires sont générés par le processus suivant :

1. Initialise la séquence de sortie S avec les éléments de X .
2. Met à jour les éléments de S pendant r tours.
3. Remplace les valeurs dans le tampon Y par les valeurs dans S .

Mise à jour de la séquence de sortie

Pour chaque cycle de mise à jour, une séquence intermédiaire V est initialisée avec les éléments de S dans un ordre spécifié :

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	N/A
4	\(\scriptsize S_2 \) S 2	\(\scriptsize S_1 \) S 1	\(\scriptsize S_0 \) S 0	\(\scriptsize S_3 \) S 3

Étant données les notations d'opération suivantes :

• \(\scriptsize \mathsf{xor} \) xor , intégré XOR bit à bit .
• \(\scriptsize \mathsf{mullo} \) mullo , calcule la moitié inférieure de la multiplication modulaire et est défini comme \(\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 , calcule la moitié supérieure de la multiplication et est défini comme \(\scriptsize \mathsf{mulhi}(a,b,w)=\left\lfloor (a \cdot b)/2^w \right\rfloor \) mulhi(a,b,w)=⌊(a⋅b)/2 w
  ⌋ .

Soit q le numéro du tour actuel (commençant à zéro), pour chaque entier k dans [ ​ 0 ​ , n / 2 ) , les éléments de la séquence de sortie S sont mis à jour comme suit :

• \(\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)

Spécialisations prédéfinies

Les spécialisations suivantes définissent le moteur de nombres aléatoires avec deux ensembles de paramètres couramment utilisés :

Défini dans l'en-tête <random>
Type	Définition
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 >

Types imbriqués

Type	Définition
result_type	UIntType

Membres de données

constexpr std::size_t word_size [static]	w (constante de membre public static)
constexpr std::size_t word_count [static]	n (constante de membre public static)
constexpr std::size_t round_count [static]	r (constante de membre public static)
constexpr std:: array < result_type, word_count / 2 > multipliers [static]	la séquence de multiplicateurs M (constante de membre public static)
constexpr std:: array < result_type, word_count / 2 > round_consts [static]	la séquence de constantes de tour C (constante de membre public static)
constexpr std::uint_least32_t default_seed [static]	20111115u (constante de membre public static)

Fonctions membres

Construction et Initialisation
(constructor)	construit le moteur (fonction membre publique)
seed	définit l'état actuel du moteur (fonction membre publique)
set_counter	définit le compteur actuel du moteur (fonction membre publique)
Génération
operator()	fait avancer l'état du moteur et retourne la valeur générée (fonction membre publique)
discard	fait avancer l'état du moteur d'une quantité spécifiée (fonction membre publique)
Caractéristiques
min [static]	obtient la plus petite valeur possible dans la plage de sortie (fonction membre publique statique)
max [static]	obtient la plus grande valeur possible dans la plage de sortie (fonction membre publique statique)

Fonctions non membres

operator== (C++26)	compare les états internes de deux moteurs de nombres pseudo-aléatoires (fonction)
operator<< operator>> (C++26)	effectue des opérations d'entrée et de sortie sur flux pour un moteur de nombres pseudo-aléatoires (modèle de fonction)

Notes

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
__cpp_lib_philox_engine	202406L	(C++26)	std::philox_engine

Exemple

Cette section est incomplète Raison : aucun exemple