Standard library header <random> (C++11)

From cppreference.net

< cpp ‎ | header

Cet en-tête fait partie de la bibliothèque de génération de nombres pseudo-aléatoires .

Table des matières

Inclusions

<initializer_list>

(C++11)

std::initializer_list modèle de classe

Concepts

Exigences des générateurs de bits aléatoires uniformes

uniform_random_bit_generator

(C++20)

spécifie qu'un type est qualifié comme générateur uniforme de bits aléatoires
(concept)

Classes

Moteurs de génération de nombres aléatoires

linear_congruential_engine

(C++11)

implémente l'algorithme congruentiel linéaire
(modèle de classe)

mersenne_twister_engine

(C++11)

implémente l'algorithme Mersenne twister
(modèle de classe)

subtract_with_carry_engine

(C++11)

implémente un algorithme de soustraction avec retenue ( Fibonacci décalé )
(modèle de classe)

philox_engine

(C++26)

un générateur parallélisable basé sur un compteur
(modèle de classe)

Adaptateurs de moteurs de génération de nombres aléatoires

discard_block_engine

(C++11)

ignore certaines sorties d'un moteur de nombres aléatoires
(modèle de classe)

independent_bits_engine

(C++11)

regroupe la sortie d'un moteur de nombres aléatoires en blocs d'un nombre spécifié de bits
(modèle de classe)

shuffle_order_engine

(C++11)

délivre la sortie d'un moteur de nombres aléatoires dans un ordre différent
(modèle de classe)

Générateurs prédéfinis
`minstd_rand0` (C++11)	std:: linear_congruential_engine < std:: uint_fast32_t , 16807 , 0 , 2147483647 > Découvert en 1969 par Lewis, Goodman et Miller, adopté comme "Standard minimal" en 1988 par Park et Miller
`minstd_rand` (C++11)	std:: linear_congruential_engine < std:: uint_fast32_t , 48271 , 0 , 2147483647 > Nouveau "standard minimum", recommandé par Park, Miller et 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 32 bits par Matsumoto et 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 64 bits de Matsumoto et 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 > Générateur RANLUX 24 bits par Martin Lüscher et Fred James, 1994
`ranlux48` (C++11)	std:: discard_block_engine < std:: ranlux48_base , 389 , 11 > Générateur RANLUX 48 bits par Martin Lüscher et Fred James, 1994
`knuth_b` (C++11)	std:: shuffle_order_engine < std:: minstd_rand0 , 256 >
`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 >
`default_random_engine` (C++11)	un type RandomNumberEngine défini par l'implémentation

Nombres aléatoires non déterministes
random_device (C++11)	générateur de nombres aléatoires non déterministe utilisant une source d'entropie matérielle (classe)
Distributions uniformes
uniform_int_distribution (C++11)	produit des valeurs entières uniformément réparties sur une plage (modèle de classe)
uniform_real_distribution (C++11)	produit des valeurs réelles uniformément réparties sur une plage (modèle de classe)
Distributions de Bernoulli
bernoulli_distribution (C++11)	produit des valeurs bool selon une distribution de Bernoulli (classe)
binomial_distribution (C++11)	produit des valeurs entières selon une distribution binomiale (modèle de classe)
negative_binomial_distribution (C++11)	produit des valeurs entières selon une distribution binomiale négative (modèle de classe)
geometric_distribution (C++11)	produit des valeurs entières selon une distribution géométrique (modèle de classe)
Distributions de Poisson
poisson_distribution (C++11)	produit des valeurs entières selon une distribution de Poisson (modèle de classe)
exponential_distribution (C++11)	produit des valeurs réelles selon une distribution exponentielle (modèle de classe)
gamma_distribution (C++11)	produit des valeurs réelles selon une distribution gamma (modèle de classe)
weibull_distribution (C++11)	produit des valeurs réelles selon une distribution de Weibull (modèle de classe)
extreme_value_distribution (C++11)	produit des valeurs réelles selon une distribution des valeurs extrêmes (modèle de classe)
Distributions normales
normal_distribution (C++11)	produit des valeurs réelles selon une distribution normale standard (gaussienne) (modèle de classe)
lognormal_distribution (C++11)	produit des valeurs réelles selon une distribution log-normale (modèle de classe)
chi_squared_distribution (C++11)	produit des valeurs réelles selon une distribution du chi carré (modèle de classe)
cauchy_distribution (C++11)	produit des valeurs réelles selon une distribution de Cauchy (modèle de classe)
fisher_f_distribution (C++11)	produit des valeurs réelles selon une distribution F de Fisher (modèle de classe)
student_t_distribution (C++11)	produit des valeurs réelles selon une distribution de Student (modèle de classe)
Distributions d'échantillonnage
discrete_distribution (C++11)	produit des valeurs entières selon une distribution discrète (modèle de classe)
piecewise_constant_distribution (C++11)	produit des valeurs réelles distribuées sur des sous-intervalles constants (modèle de classe)
piecewise_linear_distribution (C++11)	produit des valeurs réelles distribuées sur des sous-intervalles définis (modèle de classe)
Utilitaires
seed_seq (C++11)	générateur de séquence de graine brouillée à usage général éliminant les biais (classe)
Fonctions
generate_canonical (C++11)	répartit uniformément les valeurs réelles de précision donnée dans l'intervalle `[` 0 `,` 1 `)` (modèle de fonction)
ranges::generate_random (C++26)	remplit une plage avec des nombres aléatoires provenant d'un générateur de bits aléatoires uniforme (objet fonction algorithme)

Synopsis

#include <initializer_list>
namespace std {
  // exigences du générateur de bits aléatoires uniforme
  template<class G>
  concept uniform_random_bit_generator = /* voir description */; // autonome
  // modèle de classe linear_congruential_engine
  template<class UIntType, UIntType a, UIntType c, UIntType m>
  class linear_congruential_engine;                             // partiellement autonome
  // modèle de classe mersenne_twister_engine
  template<class UIntType,
           size_t w,
           size_t n,
           size_t m,
           size_t r,
           UIntType a,
           size_t u,
           UIntType d,
           size_t s,
           UIntType b,
           size_t t,
           UIntType c,
           size_t l,
           UIntType f>
  class mersenne_twister_engine;                                // partiellement autonome
  // modèle de classe subtract_with_carry_engine
  template<class UIntType, size_t w, size_t s, size_t r>
  class subtract_with_carry_engine;                             // partiellement autonome
  // modèle de classe discard_block_engine
  template<class Engine, size_t p, size_t r>
  class discard_block_engine;                                   // partiellement autonome
  // modèle de classe independent_bits_engine
  template<class Engine, size_t w, class UIntType>
  class independent_bits_engine;                                // partiellement autonome
  // modèle de classe shuffle_order_engine
  template<class Engine, size_t k>
  class shuffle_order_engine;
  // modèle de classe philox_engine
  template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts>
  class philox_engine;                                          // partiellement autonome
  // moteurs et adaptateurs de moteur avec des paramètres prédéfinis
  using minstd_rand0          = /* voir description */;          // autonome
  using minstd_rand           = /* voir description */;          // autonome
  using mt19937               = /* voir description */;          // freestanding
  using mt19937_64            = /* voir description */;          // autonome
  using ranlux24_base         = /* voir description */;          // autonome
  using ranlux48_base         = /* voir description */;          // autonome
  using ranlux24              = /* voir description */;          // autonome
  using ranlux48              = /* voir description */;          // autonome
  using knuth_b               = /* voir description */;
  using philox4x32            = /* voir description */;          // autonome
  using philox4x64            = /* voir description */;          // autonome
  using default_random_engine = /* voir description */;
  // classe random_device
  class random_device;
  // classe seed_seq
  class seed_seq;
  // modèle de fonction generate_canonical
  template<class RealType, size_t digits, class URBG>
  RealType generate_canonical(URBG& g);
  namespace ranges {
    // générer_aléatoire
    template<class R, class G>
      requires output_range<R, invoke_result_t<G&>> &&
               uniform_random_bit_generator<remove_cvref_t<G>>
    constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g);
    template<class G, output_iterator<invoke_result_t<G&>> O, sentinel_for<O> S>
      requires uniform_random_bit_generator<remove_cvref_t<G>>
    constexpr O generate_random(O first, S last, G&& g);
    template<class R, class G, class D>
      requires output_range<R, invoke_result_t<D&, G&>> && invocable<D&, G&> &&
               uniform_random_bit_generator<remove_cvref_t<G>> &&
               is_arithmetic_v<invoke_result_t<D&, G&>>
    constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g, D&& d);
    template<class G, class D,
             output_iterator<invoke_result_t<D&, G&>> O, sentinel_for<O> S>
      requires invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t<G>> &&
               is_arithmetic_v<invoke_result_t<D&, G&>>
    constexpr O generate_random(O first, S last, G&& g, D&& d);
  }
  // modèle de classe uniform_int_distribution
  template<class IntType = int>
  class uniform_int_distribution;                               // partiellement autonome
  // modèle de classe uniform_real_distribution
  template<class RealType = double>
  class uniform_real_distribution;
  // classe bernoulli_distribution
  class bernoulli_distribution;
  // modèle de classe binomial_distribution
  template<class IntType = int>
  class binomial_distribution;
  // modèle de classe geometric_distribution
  template<class IntType = int>
  class geometric_distribution;
  // modèle de classe negative_binomial_distribution
  template<class IntType = int>
  class negative_binomial_distribution;
  // modèle de classe poisson_distribution
  template<class IntType = int>
  class poisson_distribution;
  // modèle de classe exponential_distribution
  template<class RealType = double>
  class exponential_distribution;
  // modèle de classe gamma_distribution
  template<class RealType = double>
  class gamma_distribution;
  // modèle de classe weibull_distribution
  template<class RealType = double>
  class weibull_distribution;
  // modèle de classe extreme_value_distribution
  template<class RealType = double>
  class extreme_value_distribution;
  // modèle de classe normal_distribution
  template<class RealType = double>
  class normal_distribution;
  // modèle de classe lognormal_distribution
  template<class RealType = double>
  class lognormal_distribution;
  // modèle de classe chi_squared_distribution
  template<class RealType = double>
  class chi_squared_distribution;
  // modèle de classe cauchy_distribution
  template<class RealType = double>
  class cauchy_distribution;
  // modèle de classe fisher_f_distribution
  template<class RealType = double>
  class fisher_f_distribution;
  // modèle de classe student_t_distribution
  template<class RealType = double>
  class student_t_distribution;
  // modèle de classe discrete_distribution
  template<class IntType = int>
  class discrete_distribution;
  // modèle de classe piecewise_constant_distribution
  template<class RealType = double>
  class piecewise_constant_distribution;
  // modèle de classe piecewise_linear_distribution
  template<class RealType = double>
  class piecewise_linear_distribution;
}

Concept `uniform_random_bit_generator`

namespace std {
  template<class G>
  concept uniform_random_bit_generator =
    invocable<G&> && unsigned_integral<invoke_result_t<G&>> && requires {
      {
        G::min()
      } -> same_as<invoke_result_t<G&>>;
      {
        G::max()
      } -> same_as<invoke_result_t<G&>>;
      requires bool_constant<(G::min() < G::max())>::value;
    };
}

Modèle de classe std::linear_congruential_engine

namespace std {
  template<class UIntType, UIntType a, UIntType c, UIntType m>
  class linear_congruential_engine
  {
  public:
    // types
    using result_type = UIntType;
    // caractéristiques du moteur
    static constexpr result_type multiplier = a;
    static constexpr result_type increment  = c;
    static constexpr result_type modulus    = m;
    static constexpr result_type min() { return c == 0u ? 1u : 0u; }
    static constexpr result_type max() { return m - 1u; }
    static constexpr result_type default_seed = 1u;
    // constructeurs et fonctions d'initialisation
    linear_congruential_engine()
      : linear_congruential_engine(default_seed)
    {
    }
    explicit linear_congruential_engine(result_type s);
    template<class Sseq>
    explicit linear_congruential_engine(Sseq& q);
    void seed(result_type s = default_seed);
    template<class Sseq>
    void seed(Sseq& q);
    // opérateurs d'égalité
    friend bool operator==(const linear_congruential_engine& x,
                           const linear_congruential_engine& y);
    // fonctions de génération
    result_type operator()();
    void discard(unsigned long long z);
    // opérateurs d'insertion et d'extraction
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // hébergé
                 const linear_congruential_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // hébergé
                 linear_congruential_engine& x);
  };
}

Modèle de classe std::mersenne_twister_engine

namespace std {
  template<class UIntType,
           size_t w,
           size_t n,
           size_t m,
           size_t r,
           UIntType a,
           size_t u,
           UIntType d,
           size_t s,
           UIntType b,
           size_t t,
           UIntType c,
           size_t l,
           UIntType f>
  class mersenne_twister_engine
  {
  public:
    // types
    using result_type = UIntType;
    // caractéristiques du moteur
    static constexpr size_t word_size                   = w;
    static constexpr size_t state_size                  = n;
    static constexpr size_t shift_size                  = m;
    static constexpr size_t mask_bits                   = r;
    static constexpr UIntType xor_mask                  = a;
    static constexpr size_t tempering_u                 = u;
    static constexpr UIntType tempering_d               = d;
    static constexpr size_t tempering_s                 = s;
    static constexpr UIntType tempering_b               = b;
    static constexpr size_t tempering_t                 = t;
    static constexpr UIntType tempering_c               = c;
    static constexpr size_t tempering_l                 = l;
    static constexpr UIntType initialization_multiplier = f;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return /*2^w - 1*/; }
    static constexpr result_type default_seed = 5489u;
    // constructeurs et fonctions d'initialisation
    mersenne_twister_engine()
      : mersenne_twister_engine(default_seed)
    {
    }
    explicit mersenne_twister_engine(result_type value);
    template<class Sseq>
    explicit mersenne_twister_engine(Sseq& q);
    void seed(result_type value = default_seed);
    template<class Sseq>
    void seed(Sseq& q);
    // opérateurs d'égalité
    friend bool operator==(const mersenne_twister_engine& x,
                           const mersenne_twister_engine& y);
    // fonctions de génération
    result_type operator()();
    void discard(unsigned long long z);
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // hébergé
                 const mersenne_twister_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // hébergé
                 mersenne_twister_engine& x);
  };
}

Modèle de classe std::subtract_with_carry_engine

namespace std {
  template<class UIntType, size_t w, size_t s, size_t r>
  class subtract_with_carry_engine
  {
  public:
    // types
    using result_type = UIntType;
    // caractéristiques du moteur
    static constexpr size_t word_size = w;
    static constexpr size_t short_lag = s;
    static constexpr size_t long_lag  = r;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return /*m - 1*/; }
    static constexpr uint_least32_t default_seed = 19780503u;
    // constructeurs et fonctions d'initialisation
    subtract_with_carry_engine()
      : subtract_with_carry_engine(0u)
    {
    }
    explicit subtract_with_carry_engine(result_type value);
    template<class Sseq>
    explicit subtract_with_carry_engine(Sseq& q);
    void seed(result_type value = 0u);
    template<class Sseq>
    void seed(Sseq& q);
    // opérateurs d'égalité
    friend bool operator==(const subtract_with_carry_engine& x,
                           const subtract_with_carry_engine& y);
    // fonctions de génération
    result_type operator()();
    void discard(unsigned long long z);
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // hébergé
                 const subtract_with_carry_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // hébergé
                 subtract_with_carry_engine& x);
  };
}

Modèle de classe std::philox_engine

namespace std {
  template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts>
  class philox_engine
  {
    static constexpr size_t /*array-size*/ = n / 2; // à titre indicatif uniquement
  public:
    // types
    using result_type = UIntType;
    // caractéristiques du moteur
    static constexpr size_t word_size   = w;
    static constexpr size_t word_count  = n;
    static constexpr size_t round_count = r;
    static constexpr array<result_type, /*array-size*/> multipliers;
    static constexpr array < result_type, @exposition onlyid { array - size > }
    @round_consts;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return m - 1; }
    static constexpr result_type default_seed = 20111115u;
    // constructeurs et fonctions d'initialisation
    philox_engine()
      : philox_engine(default_seed)
    {
    }
    explicit philox_engine(result_type value);
    template<class Sseq>
    explicit philox_engine(Sseq& q);
    void seed(result_type value = default_seed);
    template<class Sseq>
    void seed(Sseq& q);
    void set_counter(const array<result_type, n>& counter);
    // opérateurs d'égalité
    friend bool operator==(const philox_engine& x, const philox_engine& y);
    // fonctions de génération
    result_type operator()();
    void discard(unsigned long long z);
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // hébergé
                 const philox_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // hébergé
                 philox_engine& x);
  };
}

Modèle de classe std::discard_block_engine

namespace std {
  template<class Engine, size_t p, size_t r>
  class discard_block_engine
  {
  public:
    // types
    using result_type = typename Engine::result_type;
    // caractéristiques du moteur
    static constexpr size_t block_size = p;
    static constexpr size_t used_block = r;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr result_type max() { return Engine::max(); }
    // constructeurs et fonctions d'initialisation
    discard_block_engine();
    explicit discard_block_engine(const Engine& e);
    explicit discard_block_engine(Engine&& e);
    explicit discard_block_engine(result_type s);
    template<class Sseq>
    explicit discard_block_engine(Sseq& q);
    void seed();
    void seed(result_type s);
    template<class Sseq>
    void seed(Sseq& q);
    // opérateurs d'égalité
    friend bool operator==(const discard_block_engine& x, const discard_block_engine& y);
    // fonctions de génération
    result_type operator()();
    void discard(unsigned long long z);
    // fonctions de propriété
    const Engine& base() const noexcept { return e; }
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // hébergé
                 const discard_block_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // hébergé
                 discard_block_engine& x);
  private:
    Engine e; // exposition uniquement
    size_t n; // exposition uniquement
  };
}

Modèle de classe std::independent_bits_engine

namespace std {
  template<class Engine, size_t w, class UIntType>
  class independent_bits_engine
  {
  public:
    // types
    using result_type = UIntType;
    // caractéristiques du moteur
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return /*2^w - 1*/; }
    // constructeurs et fonctions d'initialisation
    independent_bits_engine();
    explicit independent_bits_engine(const Engine& e);
    explicit independent_bits_engine(Engine&& e);
    explicit independent_bits_engine(result_type s);
    template<class Sseq>
    explicit independent_bits_engine(Sseq& q);
    void seed();
    void seed(result_type s);
    template<class Sseq>
    void seed(Sseq& q);
    // opérateurs d'égalité
    friend bool operator==(const independent_bits_engine& x,
                           const independent_bits_engine& y);
    // fonctions de génération
    result_type operator()();
    void discard(unsigned long long z);
    // fonctions d'accès
    const Engine& base() const noexcept { return e; }
    // opérateurs d'insertion et d'extraction
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // hébergé
                 const independent_bits_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // hébergé
                 independent_bits_engine& x);
  private:
    Engine e; // exposition uniquement
  };
}

Modèle de classe std::shuffle_order_engine

namespace std {
  template<class Engine, size_t k>
  class shuffle_order_engine
  {
  public:
    // types
    using result_type = typename Engine::result_type;
    // caractéristiques du moteur
    static constexpr size_t table_size = k;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr result_type max() { return Engine::max(); }
    // constructeurs et fonctions d'initialisation
    shuffle_order_engine();
    explicit shuffle_order_engine(const Engine& e);
    explicit shuffle_order_engine(Engine&& e);
    explicit shuffle_order_engine(result_type s);
    template<class Sseq>
    explicit shuffle_order_engine(Sseq& q);
    void seed();
    void seed(result_type s);
    template<class Sseq>
    void seed(Sseq& q);
    // opérateurs d'égalité
    friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);
    // fonctions de génération
    result_type operator()();
    void discard(unsigned long long z);
    // fonctions d'accès
    const Engine& base() const noexcept { return e; }
    // opérateurs d'entrée/sortie
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const shuffle_order_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    shuffle_order_engine& x);
  private:
    Engine e;         // exposition uniquement
    result_type V[k]; // exposition uniquement
    result_type Y;    // exposition uniquement
  };
}

Moteurs et adaptateurs de moteur avec paramètres prédéfinis

namespace std {
using minstd_rand0 = linear_congruential_engine<uint_fast32_t, 16'807, 0, 2'147'483'647>;
using minstd_rand = linear_congruential_engine<uint_fast32_t, 48'271, 0, 2'147'483'647>;
using mt19937 = mersenne_twister_engine<uint_fast32_t,
                                        32,
                                        624,
                                        397,
                                        31,
                                        0x9908'b0df,
                                        11,
                                        0xffff'ffff,
                                        7,
                                        0x9d2c'5680,
                                        15,
                                        0xefc6'0000,
                                        18,
                                        1'812'433'253>; //'
using mt19937_64 = mersenne_twister_engine<uint_fast64_t,
                                           64,
                                           312,
                                           156,
                                           31,
                                           0xb502'6f5a'a966'19e9,
                                           29,
                                           0x5555'5555'5555'5555,
                                           17,
                                           0x71d6'7fff'eda6'0000,
                                           37,
                                           0xfff7'eee0'0000'0000,
                                           43,
                                           6'364'136'223'846'793'005>;
using ranlux24_base = subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>;
using ranlux48_base = subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>;
using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>;
using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>;
using knuth_b = shuffle_order_engine<minstd_rand0, 256>;
using default_random_engine = /* défini par l'implémentation */;
using philox4x32 = philox_engine<uint_fast32_t,
                                 32,
                                 4,
                                 10,
                                 0xD2511F53,
                                 0x9E3779B9,
                                 0xCD9E8D57,
                                 0xBB67AE85>;
using philox4x64 = philox_engine<uint_fast64_t,
                                 64,
                                 4,
                                 10,
                                 0xD2E7470EE14C6C93,
                                 0x9E3779B97F4A7C15,
                                 0xCA5A826395121157,
                                 0xBB67AE8584CAA73B>;
}

Classe std::random_device

namespace std {
  class random_device
  {
  public:
    // types
    using result_type = unsigned int;
    // caractéristiques du générateur
    static constexpr result_type min() { return numeric_limits<result_type>::min(); }
    static constexpr result_type max() { return numeric_limits<result_type>::max(); }
    // constructeurs
    random_device()
      : random_device(/* implementation-defined */)
    {
    }
    explicit random_device(const string& token);
    // fonctions de génération
    result_type operator()();
    // fonctions de propriété
    double entropy() const noexcept;
    // fonctions de copie interdites
    random_device(const random_device&)  = delete;
    void operator=(const random_device&) = delete;
  };
}

Classe std::seed_seq

namespace std {
  class seed_seq
  {
  public:
    // types
    using result_type = uint_least32_t;
    // constructeurs
    seed_seq() noexcept;
    template<class T>
    seed_seq(initializer_list<T> il);
    template<class InputIter>
    seed_seq(InputIter begin, InputIter end);
    // fonctions de génération
    template<class RandomAccessIter>
    void generate(RandomAccessIter begin, RandomAccessIter end);
    // fonctions de propriété
    size_t size() const noexcept;
    template<class OutputIter>
    void param(OutputIter dest) const;
    // fonctions de non-copie
    seed_seq(const seed_seq&)       = delete;
    void operator=(const seed_seq&) = delete;
  private:
    vector<result_type> v; // exposition uniquement
  };
}

Modèle de classe std::uniform_int_distribution

namespace std {
  template<class IntType = int>
  class uniform_int_distribution
  {
  public:
    // types
    using result_type = IntType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    uniform_int_distribution()
      : uniform_int_distribution(0)
    {
    }
    explicit uniform_int_distribution(IntType a,
                                      IntType b = numeric_limits<IntType>::max());
    explicit uniform_int_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const uniform_int_distribution& x,
                           const uniform_int_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions d'accès
    result_type a() const;
    result_type b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // opérateurs d'insertion et d'extraction
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // hébergé
                 const uniform_int_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // hébergé
                 uniform_int_distribution& x);
  };
}

Modèle de classe std::uniform_real_distribution

namespace std {
  template<class RealType = double>
  class uniform_real_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    uniform_real_distribution()
      : uniform_real_distribution(0.0)
    {
    }
    explicit uniform_real_distribution(RealType a, RealType b = 1.0);
    explicit uniform_real_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const uniform_real_distribution& x,
                           const uniform_real_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    result_type a() const;
    result_type b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extracteurs
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const uniform_real_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    uniform_real_distribution& x);
  };
}

Classe std::bernoulli_distribution

namespace std {
  class bernoulli_distribution
  {
  public:
    // types
    using result_type = bool;
    using param_type  = /* unspecified */;
    // constructeurs et fonctions de réinitialisation
    bernoulli_distribution()
      : bernoulli_distribution(0.5)
    {
    }
    explicit bernoulli_distribution(double p);
    explicit bernoulli_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const bernoulli_distribution& x,
                           const bernoulli_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const bernoulli_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    bernoulli_distribution& x);
  };
}

Modèle de classe std::binomial_distribution

namespace std {
  template<class IntType = int>
  class binomial_distribution
  {
  public:
    // types
    using result_type = IntType;
    using param_type  = /* unspecified */;
    // constructeurs et fonctions de réinitialisation
    binomial_distribution()
      : binomial_distribution(1)
    {
    }
    explicit binomial_distribution(IntType t, double p = 0.5);
    explicit binomial_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const binomial_distribution& x,
                           const binomial_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    IntType t() const;
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const binomial_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    binomial_distribution& x);
  };
}

Modèle de classe std::geometric_distribution

namespace std {
  template<class IntType = int>
  class geometric_distribution
  {
  public:
    // types
    using result_type = IntType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    geometric_distribution()
      : geometric_distribution(0.5)
    {
    }
    explicit geometric_distribution(double p);
    explicit geometric_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const geometric_distribution& x,
                           const geometric_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const geometric_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    geometric_distribution& x);
  };
}

Modèle de classe std::negative_binomial_distribution

namespace std {
  template<class IntType = int>
  class negative_binomial_distribution
  {
  public:
    // types
    using result_type = IntType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    negative_binomial_distribution()
      : negative_binomial_distribution(1)
    {
    }
    explicit negative_binomial_distribution(IntType k, double p = 0.5);
    explicit negative_binomial_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const negative_binomial_distribution& x,
                           const negative_binomial_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    IntType k() const;
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(
      basic_ostream<CharT, Traits>& os,
      const negative_binomial_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    negative_binomial_distribution& x);
  };
}

Modèle de classe std::poisson_distribution

namespace std {
  template<class IntType = int>
  class poisson_distribution
  {
  public:
    // types
    using result_type = IntType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    poisson_distribution()
      : poisson_distribution(1.0)
    {
    }
    explicit poisson_distribution(double mean);
    explicit poisson_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const poisson_distribution& x, const poisson_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    double mean() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const poisson_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    poisson_distribution& x);
  };
}

Modèle de classe std::exponential_distribution

namespace std {
  template<class RealType = double>
  class exponential_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    exponential_distribution()
      : exponential_distribution(1.0)
    {
    }
    explicit exponential_distribution(RealType lambda);
    explicit exponential_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const exponential_distribution& x,
                           const exponential_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType lambda() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const exponential_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    exponential_distribution& x);
  };
}

Modèle de classe std::gamma_distribution

namespace std {
  template<class RealType = double>
  class gamma_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    gamma_distribution()
      : gamma_distribution(1.0)
    {
    }
    explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
    explicit gamma_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const gamma_distribution& x, const gamma_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType alpha() const;
    RealType beta() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const gamma_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    gamma_distribution& x);
  };
}

Modèle de classe std::weibull_distribution

namespace std {
  template<class RealType = double>
  class weibull_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    weibull_distribution()
      : weibull_distribution(1.0)
    {
    }
    explicit weibull_distribution(RealType a, RealType b = 1.0);
    explicit weibull_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const weibull_distribution& x, const weibull_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const weibull_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    weibull_distribution& x);
  };
}

Modèle de classe std::extreme_value_distribution

namespace std {
  template<class RealType = double>
  class extreme_value_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    extreme_value_distribution()
      : extreme_value_distribution(0.0)
    {
    }
    explicit extreme_value_distribution(RealType a, RealType b = 1.0);
    explicit extreme_value_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const extreme_value_distribution& x,
                           const extreme_value_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const extreme_value_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    extreme_value_distribution& x);
  };
}

Modèle de classe std::normal_distribution

namespace std {
  template<class RealType = double>
  class normal_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    normal_distribution()
      : normal_distribution(0.0)
    {
    }
    explicit normal_distribution(RealType mean, RealType stddev = 1.0);
    explicit normal_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const normal_distribution& x, const normal_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType mean() const;
    RealType stddev() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extracteurs
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const normal_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    normal_distribution& x);
  };
}

Modèle de classe std::lognormal_distribution

namespace std {
  template<class RealType = double>
  class lognormal_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    lognormal_distribution()
      : lognormal_distribution(0.0)
    {
    }
    explicit lognormal_distribution(RealType m, RealType s = 1.0);
    explicit lognormal_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const lognormal_distribution& x,
                           const lognormal_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType m() const;
    RealType s() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const lognormal_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    lognormal_distribution& x);
  };
}

Modèle de classe std::chi_squared_distribution

namespace std {
  template<class RealType = double>
  class chi_squared_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    chi_squared_distribution()
      : chi_squared_distribution(1.0)
    {
    }
    explicit chi_squared_distribution(RealType n);
    explicit chi_squared_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const chi_squared_distribution& x,
                           const chi_squared_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const chi_squared_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    chi_squared_distribution& x);
  };
}

Modèle de classe std::cauchy_distribution

namespace std {
  template<class RealType = double>
  class cauchy_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    cauchy_distribution()
      : cauchy_distribution(0.0)
    {
    }
    explicit cauchy_distribution(RealType a, RealType b = 1.0);
    explicit cauchy_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const cauchy_distribution& x, const cauchy_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const cauchy_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    cauchy_distribution& x);
  };
}

Modèle de classe std::fisher_f_distribution

namespace std {
  template<class RealType = double>
  class fisher_f_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    fisher_f_distribution()
      : fisher_f_distribution(1.0)
    {
    }
    explicit fisher_f_distribution(RealType m, RealType n = 1.0);
    explicit fisher_f_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const fisher_f_distribution& x,
                           const fisher_f_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType m() const;
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const fisher_f_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    fisher_f_distribution& x);
  };
}

Modèle de classe std::student_t_distribution

namespace std {
  template<class RealType = double>
  class student_t_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    student_t_distribution()
      : student_t_distribution(1.0)
    {
    }
    explicit student_t_distribution(RealType n);
    explicit student_t_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const student_t_distribution& x,
                           const student_t_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const student_t_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    student_t_distribution& x);
  };
}

Modèle de classe std::discrete_distribution

namespace std {
  template<class IntType = int>
  class discrete_distribution
  {
  public:
    // types
    using result_type = IntType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    discrete_distribution();
    template<class InputIter>
    discrete_distribution(InputIter firstW, InputIter lastW);
    discrete_distribution(initializer_list<double> wl);
    template<class UnaryOperation>
    discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
    explicit discrete_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const discrete_distribution& x,
                           const discrete_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    vector<double> probabilities() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os,
                                                    const discrete_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    discrete_distribution& x);
  };
}

Modèle de classe std::piecewise_constant_distribution

namespace std {
  template<class RealType = double>
  class piecewise_constant_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    piecewise_constant_distribution();
    template<class InputIterB, class InputIterW>
    piecewise_constant_distribution(InputIterB firstB,
                                    InputIterB lastB,
                                    InputIterW firstW);
    template<class UnaryOperation>
    piecewise_constant_distribution(initializer_list<RealType> bl, UnaryOperation fw);
    template<class UnaryOperation>
    piecewise_constant_distribution(size_t nw,
                                    RealType xmin,
                                    RealType xmax,
                                    UnaryOperation fw);
    explicit piecewise_constant_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const piecewise_constant_distribution& x,
                           const piecewise_constant_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    vector<result_type> intervals() const;
    vector<result_type> densities() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(
      basic_ostream<CharT, Traits>& os,
      const piecewise_constant_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    piecewise_constant_distribution& x);
  };
}

Modèle de classe std::piecewise_linear_distribution

namespace std {
  template<class RealType = double>
  class piecewise_linear_distribution
  {
  public:
    // types
    using result_type = RealType;
    using param_type  = /* non spécifié */;
    // constructeurs et fonctions de réinitialisation
    piecewise_linear_distribution();
    template<class InputIterB, class InputIterW>
    piecewise_linear_distribution(InputIterB firstB, InputIterB lastB, InputIterW firstW);
    template<class UnaryOperation>
    piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);
    template<class UnaryOperation>
    piecewise_linear_distribution(size_t nw,
                                  RealType xmin,
                                  RealType xmax,
                                  UnaryOperation fw);
    explicit piecewise_linear_distribution(const param_type& parm);
    void reset();
    // opérateurs d'égalité
    friend bool operator==(const piecewise_linear_distribution& x,
                           const piecewise_linear_distribution& y);
    // fonctions de génération
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // fonctions de propriété
    vector<result_type> intervals() const;
    vector<result_type> densities() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // inserters et extractors
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>& operator<<(
      basic_ostream<CharT, Traits>& os,
      const piecewise_linear_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is,
                                                    piecewise_linear_distribution& x);
  };
}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

Standard library header <random> (C++11)

Table des matières

Inclusions

Concepts

Exigences des générateurs de bits aléatoires uniformes

Classes

Moteurs de génération de nombres aléatoires

Adaptateurs de moteurs de génération de nombres aléatoires

Générateurs prédéfinis

Nombres aléatoires non déterministes

Distributions uniformes

Distributions de Bernoulli

Distributions de Poisson

Distributions normales

Distributions d'échantillonnage

Utilitaires

Fonctions

Synopsis

Concept uniform_random_bit_generator

Modèle de classe std::linear_congruential_engine

Modèle de classe std::mersenne_twister_engine

Modèle de classe std::subtract_with_carry_engine

Modèle de classe std::philox_engine

Modèle de classe std::discard_block_engine

Modèle de classe std::independent_bits_engine

Modèle de classe std::shuffle_order_engine

Moteurs et adaptateurs de moteur avec paramètres prédéfinis

Classe std::random_device

Classe std::seed_seq

Modèle de classe std::uniform_int_distribution

Modèle de classe std::uniform_real_distribution

Classe std::bernoulli_distribution

Modèle de classe std::binomial_distribution

Modèle de classe std::geometric_distribution

Modèle de classe std::negative_binomial_distribution

Modèle de classe std::poisson_distribution

Modèle de classe std::exponential_distribution

Modèle de classe std::gamma_distribution

Modèle de classe std::weibull_distribution

Modèle de classe std::extreme_value_distribution

Modèle de classe std::normal_distribution

Modèle de classe std::lognormal_distribution

Modèle de classe std::chi_squared_distribution

Modèle de classe std::cauchy_distribution

Modèle de classe std::fisher_f_distribution

Modèle de classe std::student_t_distribution

Modèle de classe std::discrete_distribution

Modèle de classe std::piecewise_constant_distribution

Modèle de classe std::piecewise_linear_distribution

Concept `uniform_random_bit_generator`