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
Definido en el encabezado <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 ;
(desde C++11)

mersenne_twister_engine es un motor de números aleatorios basado en el algoritmo Mersenne Twister . Produce números aleatorios de tipo entero sin signo UIntType de alta calidad, pero no criptográficamente seguros, en el intervalo [0, 2 w
) .

Contenidos

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 - la potencia de dos que determina el rango de valores generados por el motor
n - el grado de recurrencia
m - la palabra media, un desplazamiento utilizado en la relación de recurrencia que define el estado
r - el número de bits de la máscara de bits inferior, también conocido como valor de torsión
a - la máscara xor condicional, es decir, los coeficientes de la matriz de torsión en forma normal racional
u, d, s, b, t, c, l - los componentes 1 er al 7 mo de la matriz de codificación de bits (tempering)
f - el multiplicador de inicialización

Si se viola cualquiera de las siguientes restricciones, el programa está mal formado:

  • m está en [ 1 , n ] .
  • Las siguientes expresiones son todas true :
  • Dado ( 1u << w ) - 1u como w1 , las siguientes expresiones son todas true :
  • a <= w1
  • b <= w1
  • c <= w1
  • d <= w1
  • f <= w1

Propiedades del generador

El tamaño de los estados de mersenne_twister_engine es n , cada uno de ellos consiste en una secuencia X de n valores de tipo result_type . X j representa el j mod n -ésimo valor (comenzando desde 0) de X .

Dadas las siguientes notaciones de operaciones bit a bit:

El algoritmo de transición de mersenne_twister_engine ( TA(x i ) ) se define como sigue:

  1. Concatenar los bits superiores w - r de X i-n con los bits inferiores r de X i+1-n para obtener un valor entero sin signo Y .
  2. Sea y igual a a·(Y bitand 1) , y establecer X i como X i+m−n xor (Y rshift 1) xor y .

El algoritmo de generación de mersenne_twister_engine ( GA(x i ) ) se define de la siguiente manera:

  1. Sea z 1 igual a X i xor ((X i rshift u) bitand d) .
  2. Sea z 2 igual a X i xor (((X i lshift s) mod 2 w
    ) bitand b)     .
  3. Sea z 3 igual a X i xor (((X i lshift t) mod 2 w
    ) bitand c)     .
  4. Sea z 4 igual a z 3 xor (z 3 rshift l) .
  5. Entregue z 4 como resultado (es decir, GA(x i )=z 4 ).

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
mt19937 (C++11)

std :: mersenne_twister_engine < std:: uint_fast32_t ,
32 , 624 , 397 , 31 ,
0x9908b0df , 11 ,
0xffffffff , 7 ,
0x9d2c5680 , 15 ,
0xefc60000 , 18 , 1812433253 >
Mersenne Twister de 32 bits por Matsumoto y 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 >
Mersenne Twister de 64 bits por Matsumoto y Nishimura, 2000

Tipos anidados

Tipo Definición
result_type UIntType

Miembros de datos

constexpr size_t word_size
[static]
w
(constante de miembro público estático)
constexpr size_t state_size
[static]
n
(constante de miembro público estático)
constexpr size_t shift_size
[static]
m
(constante de miembro público estático)
constexpr size_t mask_bits
[static]
r
(constante de miembro público estático)
constexpr UIntType xor_mask
[static]
a
(constante de miembro público estático)
constexpr size_t tempering_u
[static]
u
(constante de miembro público estático)
constexpr UIntType tempering_d
[static]
d
(constante de miembro público estático)
constexpr size_t tempering_s
[static]
s
(constante de miembro público estático)
constexpr UIntType tempering_b
[static]
b
(constante de miembro público estático)
constexpr size_t tempering_t
[static]
t
(constante de miembro público estático)
constexpr UIntType tempering_c
[static]
c
(constante de miembro público estático)
constexpr size_t tempering_l
[static]
l
(constante de miembro público estático)
constexpr UIntType initialization_multiplier
[static]
f
(constante de miembro público estático)
constexpr UIntType default_seed
[static]
5489u
(constante de miembro público estático)

Funciones miembro

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

Funciones no miembro

(C++11) (C++11) (removed in C++20)
compara los estados internos de dos motores de números pseudoaleatorios
(función)
(C++11)
realiza entrada y salida de flujo en el motor de números pseudoaleatorios
(plantilla de función)

Ejemplo

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