std:: philox_engine

Definido en el encabezado <random>
template < class UIntType, std:: size_t w, std:: size_t n, std:: size_t r, UIntType... consts > class philox_engine ;		(desde C++26)

std::philox_engine es un motor de números aleatorios basado en contador.

Contenidos 1 Parámetros de plantilla 2 Propiedades del generador 2.1 Generación de valores aleatorios 2.2 Actualización de la secuencia de salida 3 Especializaciones predefinidas 4 Tipos anidados 5 Miembros de datos 6 Funciones miembro 6.1 Construcción e inicialización 6.2 Generación 6.3 Características 7 Funciones no miembro 8 Notas 9 Ejemplo

Parámetros de plantilla

UIntType	-	El tipo de resultado generado por el generador. El efecto es indefinido si este no es uno de unsigned short , unsigned int , unsigned long , o unsigned long long .
w	-	el tamaño de palabra en bits
n	-	el número de palabras
r	-	el número de rondas
consts	-	la secuencia de multiplicadores y constantes de ronda utilizados para generar números aleatorios

Si cualquiera de los siguientes valores no es true , el programa está mal formado:

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

Propiedades del generador

En la siguiente descripción, sea \(\scriptsize Q_i \) Q i el i -ésimo elemento de la secuencia Q , donde el subíndice comienza desde cero.

El tamaño de los estados de philox_engine es \(\scriptsize O(n)\) O(n) , cada uno de ellos consiste en cuatro partes:

• Una secuencia X de n valores enteros, donde cada valor está en [ ​ 0 ​ , 2 w
) .

• Esta secuencia representa un valor de contador de entero sin signo grande \(\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.

• Una secuencia K de n / 2 claves de tipo UIntType .
• Un búfer Y de n valores producidos de tipo UIntType .
• Un índice j en el búfer Y .

El algoritmo de transición de philox_engine ( \(\scriptsize TA(X_i) \) TA(X i ) ) se define de la siguiente manera:

• Si j no es n - 1 , incrementa j en 1 . ^[1]
• Si j es n - 1 , realiza las siguientes operaciones: ^[2]

1. Genera una nueva secuencia de n valores aleatorios (ver abajo) y los almacena en Y .
2. Incrementa el contador Z en 1 .
3. Restablece j a ​ 0 ​ .

El algoritmo de generación de philox_engine es \(\scriptsize GA(X_i)=Y_j \) GA(X i )=Y j .

1. ↑ En este caso, la llamada al algoritmo de siguiente generación devuelve el siguiente valor generado en el buffer.
2. ↑ En este caso, el buffer se actualiza, y la llamada al algoritmo de siguiente generación devuelve el primer valor en el nuevo buffer.

Generación de valores aleatorios

Los valores aleatorios se generan a partir de los siguientes parámetros:

• el número de rondas r
• la secuencia de contador actual X
• la secuencia de clave K
• la secuencia multiplicadora M
• la secuencia de constantes de ronda C

Las secuencias M y C se forman a partir de los valores del paquete de parámetros de plantilla consts , que representa las constantes \(\scriptsize M_k \) M k y \(\scriptsize C_k \) C k como [ \(\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 ] .

Los números aleatorios se generan mediante el siguiente proceso:

1. Inicializa la secuencia de salida S con los elementos de X .
2. Actualiza los elementos de S durante r rondas.
3. Reemplaza los valores en el búfer Y con los valores en S .

Actualización de la secuencia de salida

Para cada ronda de actualización, una secuencia intermedia V se inicializa con los elementos de S en un orden específico:

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

Dadas las siguientes notaciones de operación:

• \(\scriptsize \mathsf{xor} \) xor , incorporado XOR bit a bit .
• \(\scriptsize \mathsf{mullo} \) mullo , calcula la mitad baja de la multiplicación modular y se define como \(\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 , calcula la mitad alta de la multiplicación y se define como \(\scriptsize \mathsf{mulhi}(a,b,w)=\left\lfloor (a \cdot b)/2^w \right\rfloor \) mulhi(a,b,w)=⌊(a⋅b)/2 w
  ⌋ .

Sea q el número de ronda actual (comenzando desde cero), para cada entero k en [ ​ 0 ​ , n / 2 ) , los elementos de la secuencia de salida S se actualizan de la siguiente manera:

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

Especializaciones predefinidas

Las siguientes especializaciones definen el motor de números aleatorios con dos conjuntos de parámetros de uso común:

Definido en el encabezado <random>
Tipo	Definición
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 >

Tipos anidados

Tipo	Definición
result_type	UIntType

Miembros de datos

constexpr std::size_t word_size [static]	w (constante de miembro público estático)
constexpr std::size_t word_count [static]	n (constante de miembro público estático)
constexpr std::size_t round_count [static]	r (constante de miembro público estático)
constexpr std:: array < result_type, word_count / 2 > multipliers [static]	la secuencia de multiplicadores M (constante de miembro público estático)
constexpr std:: array < result_type, word_count / 2 > round_consts [static]	la secuencia de constantes de ronda C (constante de miembro público estático)
constexpr std::uint_least32_t default_seed [static]	20111115u (constante de miembro público estático)

Funciones miembro

Construcción y Inicialización
(constructor)	construye el motor (función miembro pública)
seed	establece el estado actual del motor (función miembro pública)
set_counter	establece el contador actual del motor (función miembro pública)
Generación
operator()	avanza el estado del motor y devuelve el valor generado (función miembro pública)
discard	avanza el estado del motor en una cantidad especificada (función miembro pública)
Características
min [static]	obtiene el valor más pequeño posible en el rango de salida (función miembro estática pública)
max [static]	obtiene el valor más grande posible en el rango de salida (función miembro estática pública)

Funciones no miembro

operator== (C++26)	compara los estados internos de dos motores de números pseudoaleatorios (función)
operator<< operator>> (C++26)	realiza entrada y salida de flujo en el motor de números pseudoaleatorios (plantilla de función)

Notas

Macro de prueba de características	Valor	Estándar	Característica
__cpp_lib_philox_engine	202406L	(C++26)	std::philox_engine

Ejemplo

Esta sección está incompleta Razón: sin ejemplo