La biblioteca de números aleatorios proporciona clases que generan números aleatorios y pseudoaleatorios. Estas clases incluyen:

  • Generadores de bits aleatorios uniformes (URBG), que incluyen motores de números aleatorios, que son generadores de números pseudoaleatorios que generan secuencias enteras con una distribución uniforme, y true generadores de números aleatorios si están disponibles;
  • Distribuciones de números aleatorios (por ejemplo, distribuciones uniformes, normales o de Poisson) que convierten la salida de URBG en varias distribuciones estadísticas.

Las URBG y las distribuciones están diseñadas para usarse juntas para producir valores aleatorios. Todos los motores de números aleatorios se pueden sembrar, serializar y deserializar específicamente para su uso con simuladores repetibles.

Generadores de bits aleatorios uniformes

A generador uniforme de bits aleatorios es un objeto de función que devuelve valores enteros sin signo de modo que cada valor en el rango de resultados posibles tiene (idealmente) la misma probabilidad de ser devuelto.

Todos los generadores de bits aleatorios uniformes cumplen con los requisitos de UniformRandomBitGenerator. C ++ 20 también define un UniformRandomBitGenerator concepto.

Definido en el encabezado
UniformeAleatorioBitGenerador(C ++ 20) especifica que un tipo califica como un generador de bits aleatorios uniforme
(concepto)

Motores de números aleatorios

Los motores de números aleatorios generan números pseudoaleatorios utilizando datos semilla como fuente de entropía. Varias clases diferentes de algoritmos de generación de números pseudoaleatorios se implementan como plantillas que se pueden personalizar.

La elección de qué motor utilizar implica una serie de compensaciones: el motor congruencial lineal es moderadamente rápido y tiene un requisito de almacenamiento muy pequeño para el estado. Los generadores de Fibonacci retrasados ​​son muy rápidos incluso en procesadores sin conjuntos de instrucciones aritméticas avanzadas, a expensas de un mayor almacenamiento de estado y, a veces, características espectrales menos deseables. El tornado de Mersenne es más lento y tiene mayores requisitos de almacenamiento de estado, pero con los parámetros correctos tiene la secuencia no repetitiva más larga con las características espectrales más deseables (para una definición dada de deseable).

Definido en el encabezado
motor_congruencial lineal(C ++ 11) implementos congruencial lineal algoritmo
(plantilla de clase)
mersenne_twister_engine(C ++ 11) implementos Tornado de Mersenne algoritmo
(plantilla de clase)
restar_con_carry_engine(C ++ 11) implementa una resta-con-acarreo ( Fibonacci retrasado) algoritmo
(plantilla de clase)

Adaptadores de motor de números aleatorios

Los adaptadores de motores de números aleatorios generan números pseudoaleatorios utilizando otro motor de números aleatorios como fuente de entropía. Generalmente se utilizan para alterar las características espectrales del motor subyacente.

Definido en el encabezado
discard_block_engine(C ++ 11) descarta parte de la salida de un motor de números aleatorios
(plantilla de clase)
motor_bits_independientes(C ++ 11) empaqueta la salida de un motor de números aleatorios en bloques de un número específico de bits
(plantilla de clase)
shuffle_order_engine(C ++ 11) entrega la salida de un motor de números aleatorios en un orden diferente
(plantilla de clase)

Generadores de números aleatorios predefinidos

Varios algoritmos populares específicos están predefinidos.

Definido en el encabezado
Escribe Definición
minstd_rand0(C ++ 11) std::linear_congruential_engine<std::uint_fast32_t, 16807, 0, 2147483647>

Descubierto en 1969 por Lewis, Goodman y Miller, adoptado como “estándar mínimo” en 1988 por Park y Miller.
minstd_rand(C ++ 11) std::linear_congruential_engine<std::uint_fast32_t, 48271, 0, 2147483647>

Más nuevo “Estándar mínimo”, recomendado por Park, Miller y Stockmeyer en 1993.
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 de 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 de Matsumoto y Nishimura, 2000.
ranlux24_base(C ++ 11) std::subtract_with_carry_engine<std::uint_fast32_t, 24, 10, 24>
ranlux48_base(C ++ 11) std::subtract_with_carry_engine<std::uint_fast64_t, 48, 5, 12>
ranlux24(C ++ 11) std::discard_block_engine<std::ranlux24_base, 223, 23>

Generador RANLUX de 24 bits de Martin Lüscher y Fred James, 1994.
ranlux48(C ++ 11) std::discard_block_engine<std::ranlux48_base, 389, 11>

Generador RANLUX de 48 bits de Martin Lüscher y Fred James, 1994.
knuth_b(C ++ 11) std::shuffle_order_engine<std::minstd_rand0, 256>
default_random_engine(C ++ 11) definido por la implementación

Números aleatorios no deterministas

std::random_device es un generador de bits aleatorios uniforme no determinista, aunque se permiten implementaciones para implementar std::random_device utilizando un motor de números pseudoaleatorios si no hay soporte para la generación de números aleatorios no deterministas.

dispositivo_aleatorio(C ++ 11) generador de números aleatorios no determinista que utiliza una fuente de entropía de hardware
(clase)

Distribuciones de números aleatorios

Una distribución de números aleatorios posprocesa la salida de un URBG de tal manera que la salida resultante se distribuye de acuerdo con una función de densidad de probabilidad estadística definida.

Las distribuciones de números aleatorios satisfacen RandomNumberDistribution.

Definido en el encabezado
Distribuciones uniformes
uniform_int_distribution(C ++ 11) produce valores enteros distribuidos uniformemente en un rango
(plantilla de clase)
uniform_real_distribution(C ++ 11) produce valores reales distribuidos uniformemente en un rango
(plantilla de clase)
Distribuciones de Bernoulli
bernoulli_distribution(C ++ 11) produce bool valores en un Distribución de Bernoulli.
(clase)
Distribución binomial(C ++ 11) produce valores enteros en un Distribución binomial.
(plantilla de clase)
distribución_binomial_negativa(C ++ 11) produce valores enteros en un distribución binomial negativa.
(plantilla de clase)
distribución_geométrica(C ++ 11) produce valores enteros en un distribución geométrica.
(plantilla de clase)
Distribuciones de Poisson
distribución de veneno(C ++ 11) produce valores enteros en un distribución de veneno.
(plantilla de clase)
distribución exponencial(C ++ 11) produce valores reales en un distribución exponencial.
(plantilla de clase)
distribución_gamma(C ++ 11) produce valores reales en un distribución gamma.
(plantilla de clase)
distribución_weibull(C ++ 11) produce valores reales en un Distribución de Weibull.
(plantilla de clase)
extreme_value_distribution(C ++ 11) produce valores reales en un distribución de valor extremo.
(plantilla de clase)
Distribuciones normales
distribución normal(C ++ 11) produce valores reales en un distribución normal estándar (gaussiana).
(plantilla de clase)
distribución_lognormal(C ++ 11) produce valores reales en un distribución lognormal.
(plantilla de clase)
chi_squared_distribution(C ++ 11) produce valores reales en un distribución chi-cuadrado.
(plantilla de clase)
cauchy_distribution(C ++ 11) produce valores reales en un Distribución de Cauchy.
(plantilla de clase)
Fisher_f_distribution(C ++ 11) produce valores reales en un Distribución F de Fisher.
(plantilla de clase)
student_t_distribution(C ++ 11) produce valores reales en un Distribución t de Student.
(plantilla de clase)
Distribuciones de muestreo
distribución_discreta(C ++ 11) produce números enteros aleatorios en una distribución discreta.
(plantilla de clase)
piecewise_constant_distribution(C ++ 11) produce valores reales distribuidos en subintervalos constantes.
(plantilla de clase)
distribución_lineal_por piezas(C ++ 11) produce valores reales distribuidos en subintervalos definidos.
(plantilla de clase)

Utilidades

Definido en el encabezado
generate_canonical(C ++ 11) distribuye uniformemente valores reales de precisión dada en [0, 1)
(function template)
seed_seq(C++11) general-purpose bias-eliminating scrambled seed sequence generator
(class)

C random library

In addition to the engines and distributions described above, the functions and constants from the C random library are also available though not recommended:

Defined in header
rand generates a pseudo-random number
(function)
srand seeds pseudo-random number generator
(function)
RAND_MAX maximum possible value generated by std::rand
(macro constant)

Example

#include#include#include#include#include#includeintmain()// Seed with a real random value, if available
    std::random_device r;// Choose a random mean between 1 and 6
    std::default_random_engine e1(r());
    std::uniform_int_distribution<int>uniform_dist(1,6);int mean =uniform_dist(e1);
    std::cout <<"Randomly-chosen mean: "<< mean <<'n';// Generate a normal distribution around that mean
    std::seed_seq seed2r(),r(),r(),r(),r(),r(),r(),r(); 
    std::mt19937 e2(seed2);
    std::normal_distribution<>normal_dist(mean,2);
 
    std::map<int,int> hist;for(int n =0; n <10000;++n)++hist[std::round(normal_dist(e2))];
    std::cout <"Distribución normal alrededor"< significar <":norte";por(auto pag : hist)
        std::cout < std::reparado < std::precisión(1)< std::setw(2)< pag.primero <''< std::string(pag.segundo/200,'*')<'norte';

Salida posible:

Randomly-chosen mean:4
Normal distribution around 4:-4-3-2-10*1***2******3********4*********5********6******7***8*9101112

Ver también