<random>

Définit de nombreux générateurs de nombres aléatoires.

#include <random>

Notes

A Générateur de nombres aléatoires est un objet qui produit une séquence de valeurs pseudo-aléatoires.Un générateur qui produit des valeurs distribuées uniformément dans une plage spécifiée est une moteur.Un moteur peut être combiné avec une distribution, soit en passant le moteur en tant qu'argument à la distribution operator() ou à l'aide d'un variate_generator Class, pour produire des valeurs qui sont distribués d'une manière qui est définie par la distribution.

La plupart des générateurs de nombres aléatoires est des modèles dont les paramètres personnaliser le générateur.Les descriptions des générateurs qui prennent un type comme argument utilisent des noms de paramètre de modèle commun pour décrire les propriétés du type qui sont autorisées comme type d'argument réel, comme suit :

• IntTypeIndique un type intégral signé ou non signé.

• UIntTypeIndique un type intégral non signé.

• RealTypeIndique un type en virgule flottante.

Un moteur est une classe TR1 ou une classe de modèle dont les instances agissent en tant que source de nombres aléatoires uniformément distribués entre une valeur minimale et maximale.Un moteur peut être un moteur simple ou un moteur composé.Chaque moteur possède les membres suivants :

• typedef numeric-type result_typeest le type qui est retourné par le Générateur operator().

• result_type min()Retourne la valeur minimale qui est retournée par le Générateur operator().

• result_type max()Retourne la valeur maximale qui est retournée par le Générateur operator().Lorsque result_type est un type intégral, c'est la valeur maximale qui peut effectivement être retournée ; Lorsque result_type est un type en virgule flottante, c'est la plus petite valeur supérieure à toutes les valeurs qui peuvent être retournées.

• void seed()Le fonction seed initialise le moteur avec des valeurs initiales par défaut.

• template <class InIt> void seed(InIt& first, InIt last)La fonction de semences alimente le moteur en utilisant les valeurs de type unsigned long à partir de la séquence semi-ouvertes qui est indiquée par [first, last).Si la séquence n'est pas suffisamment long pour initialiser complètement le moteur, la fonction stocke la valeur last dans first et lève un objet de type std::invalid_argument.

  [!REMARQUE]

  Seuls des moteurs conservés pour la compatibilité TR1 incluent ce membre.

• result_type operator()()Renvoie les valeurs qui sont distribuées uniformément entre min() et max().

min, max, et result_type ne sont pas décrites en détail pour les moteurs qui suivent.

À partir de Visual Studio 2010, chaque moteur sauf ceux qui sont conservés pour la compatibilité TR1 inclut également les membres suivants :

• Un constructeur explicite avec l'argument result_type x0 qui crée un moteur ensemencé comme si l'appel à seed(x0).

• Un constructeur explicite avec l'argument seed_seq& seq qui crée un moteur ensemencé comme si l'appel à seed(seq).

• void seed(result_type x0)La fonction de semences alimente le moteur avec la valeur de départ x0.

• void seed(seed_seq& seq)La fonction de semences alimente le moteur avec les valeurs de semences de seq.

• void discard(unsigned long long count)appelle effectivement operator() décompte fois et les rejets de chaque valeur.

Chaque moteur a un état qui détermine la séquence de valeurs qui seront générés par les appels ultérieurs à operator().Les États de deux objets du même type peuvent être comparées à l'aide de operator== et operator!=.Si les deux États sont considérés comme égaux, les objets génère la même séquence de valeurs.L'état d'un objet peut être enregistré dans un flux de données comme une séquence de valeurs non signés 32 bits à l'aide de la operator<< de l'objet.L'état n'est pas modifiée en l'enregistrant.Un état enregistré pouvant être lu dans un objet du même type à l'aide de operator>>.

A moteur simple est un moteur qui génère des nombres aléatoires directement.Cette bibliothèque fournit une classe dont les objets sont des moteurs simples.Il fournit également des quatre modèles de classe qui peuvent être instanciés à l'aide de valeurs qui fournissent des paramètres pour l'algorithme qu'ils implémentent et neuf prédéfinis des instances de ces modèles de classe.Objets de ces types sont également des moteurs simples.

A moteur composé est un moteur qui obtient des nombres aléatoires à partir d'un ou plus simple des moteurs et génère un flux de nombres aléatoires uniformément distribués à l'aide de ces valeurs.Cette bibliothèque fournit des modèles de classe pour les deux moteurs composés.

A distribution est une classe TR1 ou modèle dont les instances transforment un flux de nombres aléatoires uniformément distribués obtenus à partir d'un moteur dans un flux de nombres aléatoires qui ont une distribution particulière.Chaque distribution possède les membres suivants :

• typedef numeric-type input_typeest le type qui doit être retourné par le moteur passé à operator().

• typedef numeric-type result_typeest le type qui est retourné par la distribution operator().

• void reset()rejette toutes les valeurs mises en cache, afin que le résultat de l'appel suivant à operator() ne dépend pas de toutes les valeurs obtenues à partir du moteur avant l'appel.

• template <class Engine> result_type operator()(Engine& eng)Renvoie les valeurs qui sont distribués en fonction de la définition de la distribution, à l'aide de eng en tant que source de valeurs aléatoires uniformément distribués et stockées package paramètre.

input_type, result_type, et reset ne sont pas décrites en détail pour les distributions qui suivent.

À partir de Visual Studio 2010, chaque distribution dispose également de :

• typedef unspecified-type param_typele package de paramètres est passé à operator() pour générer sa valeur de retour.

• A const param& constructeur initialise le package de paramètre stockées à partir de son argument.

• param_type param() constObtient le package paramètre stocké.

• void param(const param_type&)Définit le package de paramètre stockées à partir de son argument.

• template <class Engine> result_type operator()(Engine& eng, param_type par0)Renvoie les valeurs réparties conformément à la définition de la distribution, en tant que source de valeurs aléatoires uniformément distribués et le package de paramètre à l'aide d'eng par0.

Un package de paramètre est un objet qui stocke tous les paramètres nécessaires pour une distribution.Elle contient les éléments suivants :

• typedef distribution-type distribution_typeest le type de sa distribution.

• Un ou plusieurs constructeurs qui prennent le même paramètre indique que la prise de constructeurs de distribution.

• Le même paramètre-accès fonctionne comme la distribution.

• Opérateurs de comparaison d'égalité et d'inégalité.

La bibliothèque peut être construite comme une version contrôlée et une version non contrôlée.La version vérifiée utilise une macro similaire à la c assert macro pour tester les conditions de la mention Precondition dans les descriptions fonctionnelles.Pour utiliser la version vérifiée, définir soit la macro _RNG_CHECK ou la macro _DEBUG à une valeur numérique zéro dans tout le code qui utilise la bibliothèque.

Classes

bernoulli_distribution Class	Génère une loi de Bernoulli.
binomial_distribution Class	Génère une distribution binomiale.
cauchy_distribution Class	Génère une distribution de Cauchy.
chi_squared_distribution Class	Génère une distribution khi-deux.
discard_block Class	Génère une séquence aléatoire en ignorant les valeurs renvoyées par son moteur de base.Conservé pour compatibilité TR1.
discard_block_engine Class	Génère une séquence aléatoire en ignorant les valeurs renvoyées par son moteur de base.
discrete_distribution Class	Génère une distribution discrète entier.
exponential_distribution Class	Génère une distribution exponentielle.
extreme_value_distribution Class	Génère une distribution des valeurs extrêmes.
fisher_f_distribution Class	Génère une distribution f de Fisher.
gamma_distribution Class	Génère une loi gamma.
geometric_distribution Class	Génère une distribution géométrique.
independent_bits_engine Class	Génère une séquence aléatoire avec un nombre de bits spécifié par le réemballage des bits à partir des valeurs renvoyées par son moteur de base.
linear_congruential Class	Génère une séquence aléatoire à l'aide de l'algorithme congruential linéaire.Conservé pour compatibilité TR1.
linear_congruential_engine Class	Génère une séquence aléatoire à l'aide de l'algorithme congruential linéaire.
lognormal_distribution Class	Génère une distribution log-normal.
mersenne_twister Class	Génère une séquence aléatoire à l'aide de l'algorithme de twister Mersenne.Conservé pour compatibilité TR1.
mersenne_twister_engine Class	Génère une séquence aléatoire à l'aide de l'algorithme de twister Mersenne.
negative_binomial_distribution Class	Génère une loi binomiale négative.
normal_distribution Class	Génère une distribution normale.
piecewise_constant_distribution Class	Génère un par morceau distribution constante.
piecewise_linear_distribution Class	Génère un par morceau distribution linéaire.
poisson_distribution Class	Génère une distribution de Poisson.
random_device Class	Génère une séquence aléatoire à l'aide d'un périphérique externe.
seed_seq Class	Stocke un vecteur des valeurs entières non signées peuvent fournir une valeur initiale aléatoire pour un moteur de nombres aléatoires.
shuffle_order_engine Class	Génère une séquence aléatoire en réorganisant les valeurs retournées à partir de son moteur de base.
student_t_distribution Class	Génère une distribution t de Student.
subtract_with_carry Class	Génère une séquence aléatoire à l'aide de la soustraction avec carry algorithme.Conservé pour compatibilité TR1.
subtract_with_carry_01 Class	Génère un aléatoire soustraire de séquence en utilisant la virgule flottante avec un algorithme de transport.Conservé pour compatibilité TR1.
subtract_with_carry_engine Class	Génère une séquence aléatoire à l'aide de la soustraction avec carry algorithme.
uniform_int Class	Génère une distribution uniforme entier.Conservé pour compatibilité TR1.
uniform_int_distribution Class	Génère une distribution uniforme entier.
uniform_real Class	Génère une distribution uniforme en virgule flottante.Conservé pour compatibilité TR1.
uniform_real_distribution Class	Génère une distribution uniforme en virgule flottante.
variate_generator Class	Encapsule un moteur et une distribution.
weibull_distribution Class	Génère une loi de Weibull.
xor_combine Class	Génère une distribution combinée.

Typedef

default_random_engine TypeDef	Type de définition pour le moteur par défaut.
knuth_b TypeDef	Type de définition pour un moteur d'ordre de lecture aléatoire.
minstd_rand0 TypeDef	Type de définition pour un moteur congruential linéaire.
minstd_rand TypeDef	Type de définition pour un moteur congruential linéaire.
mt19937 TypeDef	Type de définition pour moteur Mersenne twister.
mt19937_64 TypeDef	Type de définition pour moteur Mersenne twister.
ranlux_base_01 TypeDef	Définition de type pour un calcul en virgule flottante soustraire avec le moteur de transport.
ranlux3 TypeDef	Définition de type pour une soustraction à effectuer moteur.
ranlux3_01 TypeDef	Définition de type pour un calcul en virgule flottante soustraire avec le moteur de transport.
ranlux4 TypeDef	Définition de type pour une soustraction à effectuer moteur.
ranlux4_01 TypeDef	Définition de type pour un calcul en virgule flottante soustraire avec le moteur de transport.
ranlux24 TypeDef	Type de définition pour un moteur de bloc discard.
ranlux24_base TypeDef	Définition de type pour une soustraction à effectuer moteur.
ranlux48 TypeDef	Type de définition pour un moteur de bloc discard.
ranlux48_base TypeDef	Définition de type pour une soustraction à effectuer moteur.
ranlux64_base_01 TypeDef	Définition de type pour un calcul en virgule flottante soustraire avec le moteur de transport.

Opérateurs

operator== <random>	Vérifie si le moteur sur le côté gauche de l'opérateur est égal à moteur sur le côté droit.
operator!= <random>	Vérifie si le moteur sur le côté gauche de l'opérateur n'est pas égal à moteur sur le côté droit.
operator<< <random>	Écrit des informations d'état dans le flux.
operator>> <random>	Extrait des informations d'état à partir d'un flux.

Fonctions

generate_canonical

Retourne une valeur à virgule flottante d'une séquence aléatoire.