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

Generadores predefinidos
`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 > 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 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
`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 por Martin Lüscher y Fred James, 1994
`ranlux48` (C++11)	std:: discard_block_engine < std:: ranlux48_base , 389 , 11 > Generador RANLUX de 48 bits por Martin Lüscher y 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 tipo RandomNumberEngine definido por la implementación

Números aleatorios no deterministas
random_device (C++11)	generador de números aleatorios no determinista que utiliza una fuente de entropía de hardware (clase)
Distribuciones uniformes
uniform_int_distribution (C++11)	produce valores enteros distribuidos uniformemente a lo largo de 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 según una distribución de Bernoulli (clase)
binomial_distribution (C++11)	produce valores enteros en una distribución binomial (plantilla de clase)
negative_binomial_distribution (C++11)	produce valores enteros según una distribución binomial negativa (plantilla de clase)
geometric_distribution (C++11)	produce valores enteros en una distribución geométrica (plantilla de clase)
Distribuciones de Poisson
poisson_distribution (C++11)	produce valores enteros según una distribución de Poisson (plantilla de clase)
exponential_distribution (C++11)	produce valores reales en una distribución exponencial (plantilla de clase)
gamma_distribution (C++11)	produce valores reales según una distribución gamma (plantilla de clase)
weibull_distribution (C++11)	produce valores reales en una distribución Weibull (plantilla de clase)
extreme_value_distribution (C++11)	produce valores reales en una distribución de valor extremo (plantilla de clase)
Distribuciones normales
normal_distribution (C++11)	produce valores reales en una distribución normal estándar (Gaussiana) (plantilla de clase)
lognormal_distribution (C++11)	produce valores reales en una distribución logarítmica normal (plantilla de clase)
chi_squared_distribution (C++11)	produce valores reales en una distribución chi-cuadrado (plantilla de clase)
cauchy_distribution (C++11)	produce valores reales en una distribución de Cauchy (plantilla de clase)
fisher_f_distribution (C++11)	produce valores reales en una distribución F de Fisher (plantilla de clase)
student_t_distribution (C++11)	produce valores reales en una distribución t de Student (plantilla de clase)
Distribuciones de muestreo
discrete_distribution (C++11)	produce valores enteros en una distribución discreta (plantilla de clase)
piecewise_constant_distribution (C++11)	produce valores reales distribuidos en subintervalos constantes (plantilla de clase)
piecewise_linear_distribution (C++11)	produce valores reales distribuidos en subintervalos definidos (plantilla de clase)
Utilidades
seed_seq (C++11)	generador de secuencias de semillas revueltas de propósito general que elimina sesgos (clase)
Funciones
generate_canonical (C++11)	distribuye uniformemente valores reales de precisión dada a través de `[` 0 `,` 1 `)` (plantilla de función)
ranges::generate_random (C++26)	llena un rango con números aleatorios de un generador uniforme de bits aleatorios (objeto función de algoritmo)

Sinopsis

#include <initializer_list>
namespace std {
  // requisitos de generador de bits aleatorios uniformes
  template<class G>
  concept uniform_random_bit_generator = /* ver descripción */; // freestanding
  // plantilla de clase linear_congruential_engine
  template<class UIntType, UIntType a, UIntType c, UIntType m>
  class linear_congruential_engine;                             // parcialmente independiente
  // class template 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;                                // parcialmente independiente
  // class template subtract_with_carry_engine
  template<class UIntType, size_t w, size_t s, size_t r>
  class subtract_with_carry_engine;                             // parcialmente independiente
  // class template discard_block_engine
  template<class Engine, size_t p, size_t r>
  class discard_block_engine;                                   // parcialmente independiente
  // class template independent_bits_engine
  template<class Engine, size_t w, class UIntType>
  class independent_bits_engine;                                // parcialmente independiente
  // plantilla de clase shuffle_order_engine
  template<class Engine, size_t k>
  class shuffle_order_engine;
  // plantilla de clase philox_engine
  template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts>
  class philox_engine;                                          // parcialmente independiente
  // motores y adaptadores de motor con parámetros predefinidos
  using minstd_rand0          = /* ver descripción */;          // freestanding
  using minstd_rand           = /* ver descripción */;          // freestanding
  using mt19937               = /* ver descripción */;          // freestanding
  using mt19937_64            = /* ver descripción */;          // freestanding
  using ranlux24_base         = /* ver descripción */;          // freestanding
  using ranlux48_base         = /* ver descripción */;          // freestanding
  using ranlux24              = /* ver descripción */;          // freestanding
  using ranlux48              = /* ver descripción */;          // freestanding
  using knuth_b               = /* ver descripción */;
  using philox4x32            = /* ver descripción */;          // freestanding
  using philox4x64            = /* ver descripción */;          // freestanding
  using default_random_engine = /* ver descripción */;
  // class random_device
  class random_device;
  // class seed_seq
  class seed_seq;
  // plantilla de función generate_canonical
  template<class RealType, size_t digits, class URBG>
  RealType generate_canonical(URBG& g);
  namespace ranges {
    // generate_random
    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);
  }
  // class template uniform_int_distribution
  template<class IntType = int>
  class uniform_int_distribution;                               // parcialmente independiente
  // plantilla de clase uniform_real_distribution
  template<class RealType = double>
  class uniform_real_distribution;
  // class bernoulli_distribution
  class bernoulli_distribution;
  // class template binomial_distribution
  template<class IntType = int>
  class binomial_distribution;
  // plantilla de clase geometric_distribution
  template<class IntType = int>
  class geometric_distribution;
  // class template negative_binomial_distribution
  template<class IntType = int>
  class negative_binomial_distribution;
  // plantilla de clase poisson_distribution
  template<class IntType = int>
  class poisson_distribution;
  // class template exponential_distribution
  template<class RealType = double>
  class exponential_distribution;
  // class template gamma_distribution
  template<class RealType = double>
  class gamma_distribution;
  // class template weibull_distribution
  template<class RealType = double>
  class weibull_distribution;
  // plantilla de clase extreme_value_distribution
  template<class RealType = double>
  class extreme_value_distribution;
  // class template normal_distribution
  template<class RealType = double>
  class normal_distribution;
  // class template lognormal_distribution
  template<class RealType = double>
  class lognormal_distribution;
  // class template chi_squared_distribution
  template<class RealType = double>
  class chi_squared_distribution;
  // plantilla de clase cauchy_distribution
  template<class RealType = double>
  class cauchy_distribution;
  // plantilla de clase fisher_f_distribution
  template<class RealType = double>
  class fisher_f_distribution;
  // class template student_t_distribution
  template<class RealType = double>
  class student_t_distribution;
  // plantilla de clase discrete_distribution
  template<class IntType = int>
  class discrete_distribution;
  // class template piecewise_constant_distribution
  template<class RealType = double>
  class piecewise_constant_distribution;
  // plantilla de clase piecewise_linear_distribution
  template<class RealType = double>
  class piecewise_linear_distribution;
}

Concepto `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;
    };
}

Plantilla de clase std::linear_congruential_engine

namespace std {
  template<class UIntType, UIntType a, UIntType c, UIntType m>
  class linear_congruential_engine
  {
  public:
    // tipos
    using result_type = UIntType;
    // características del motor
    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;
    // constructores y funciones de inicialización
    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);
    // operadores de igualdad
    friend bool operator==(const linear_congruential_engine& x,
                           const linear_congruential_engine& y);
    // funciones de generación
    result_type operator()();
    void discard(unsigned long long z);
    // insertadores y extractores
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // alojado
                 const linear_congruential_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // alojado
                 linear_congruential_engine& x);
  };
}

Plantilla de clase 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:
    // tipos
    using result_type = UIntType;
    // características del motor
    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;
    // constructores y funciones de inicialización
    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);
    // operadores de igualdad
    friend bool operator==(const mersenne_twister_engine& x,
                           const mersenne_twister_engine& y);
    // funciones de generación
    result_type operator()();
    void discard(unsigned long long z);
    // insertadores y extractores
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // alojado
                 const mersenne_twister_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // alojado
                 mersenne_twister_engine& x);
  };
}

Plantilla de clase 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:
    // tipos
    using result_type = UIntType;
    // características del motor
    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;
    // constructores y funciones de inicialización
    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);
    // operadores de igualdad
    friend bool operator==(const subtract_with_carry_engine& x,
                           const subtract_with_carry_engine& y);
    // funciones de generación
    result_type operator()();
    void discard(unsigned long long z);
    // insertadores y extractores
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // alojado
                 const subtract_with_carry_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // alojado
                 subtract_with_carry_engine& x);
  };
}

Plantilla de clase 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; // solo para exposición
  public:
    // tipos
    using result_type = UIntType;
    // características del motor
    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, @exposición soloid { 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;
    // constructores y funciones de inicialización
    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);
    // operadores de igualdad
    friend bool operator==(const philox_engine& x, const philox_engine& y);
    // funciones de generación
    result_type operator()();
    void discard(unsigned long long z);
    // insertadores y extractores
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // alojado
                 const philox_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // alojado
                 philox_engine& x);
  };
}

Plantilla de clase std::discard_block_engine

namespace std {
  template<class Engine, size_t p, size_t r>
  class discard_block_engine
  {
  public:
    // tipos
    using result_type = typename Engine::result_type;
    // características del motor
    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(); }
    // constructores y funciones de inicialización
    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);
    // operadores de igualdad
    friend bool operator==(const discard_block_engine& x, const discard_block_engine& y);
    // funciones de generación
    result_type operator()();
    void discard(unsigned long long z);
    // funciones de propiedad
    const Engine& base() const noexcept { return e; }
    // insertadores y extractores
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // alojado
                 const discard_block_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // alojado
                 discard_block_engine& x);
  private:
    Engine e; // solo para exposición
    size_t n; // solo para exposición
  };
}

Plantilla de clase std::independent_bits_engine

namespace std {
  template<class Engine, size_t w, class UIntType>
  class independent_bits_engine
  {
  public:
    // tipos
    using result_type = UIntType;
    // características del motor
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return /*2^w - 1*/; }
    // constructores y funciones de inicialización
    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);
    // operadores de igualdad
    friend bool operator==(const independent_bits_engine& x,
                           const independent_bits_engine& y);
    // funciones de generación
    result_type operator()();
    void discard(unsigned long long z);
    // funciones de propiedad
    const Engine& base() const noexcept { return e; }
    // insertadores y extractores
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // alojado
                 const independent_bits_engine& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // alojado
                 independent_bits_engine& x);
  private:
    Engine e; // solo para exposición
  };
}

Plantilla de clase std::shuffle_order_engine

namespace std {
  template<class Engine, size_t k>
  class shuffle_order_engine
  {
  public:
    // tipos
    using result_type = typename Engine::result_type;
    // características del motor
    static constexpr size_t table_size = k;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr result_type max() { return Engine::max(); }
    // constructores y funciones de inicialización
    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);
    // operadores de igualdad
    friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);
    // funciones de generación
    result_type operator()();
    void discard(unsigned long long z);
    // funciones de propiedad
    const Engine& base() const noexcept { return e; }
    // insertadores y extractores
    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;         // solo para exposición
    result_type V[k]; // solo para exposición
    result_type Y;    // solo para exposición
  };
}

Motores y adaptadores de motor con parámetros predefinidos

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 = /* definido por la implementación */;
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>;
}

Clase std::random_device

namespace std {
  class random_device
  {
  public:
    // tipos
    using result_type = unsigned int;
    // características del generador
    static constexpr result_type min() { return numeric_limits<result_type>::min(); }
    static constexpr result_type max() { return numeric_limits<result_type>::max(); }
    // constructores
    random_device()
      : random_device(/* implementation-defined */)
    {
    }
    explicit random_device(const string& token);
    // funciones de generación
    result_type operator()();
    // funciones de propiedad
    double entropy() const noexcept;
    // funciones de no copia
    random_device(const random_device&)  = delete;
    void operator=(const random_device&) = delete;
  };
}

Clase std::seed_seq

namespace std {
  class seed_seq
  {
  public:
    // tipos
    using result_type = uint_least32_t;
    // constructores
    seed_seq() noexcept;
    template<class T>
    seed_seq(initializer_list<T> il);
    template<class InputIter>
    seed_seq(InputIter begin, InputIter end);
    // funciones de generación
    template<class RandomAccessIter>
    void generate(RandomAccessIter begin, RandomAccessIter end);
    // funciones de propiedad
    size_t size() const noexcept;
    template<class OutputIter>
    void param(OutputIter dest) const;
    // funciones de no copia
    seed_seq(const seed_seq&)       = delete;
    void operator=(const seed_seq&) = delete;
  private:
    vector<result_type> v; // solo para exposición
  };
}

Plantilla de clase std::uniform_int_distribution

namespace std {
  template<class IntType = int>
  class uniform_int_distribution
  {
  public:
    // tipos
    using result_type = IntType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const uniform_int_distribution& x,
                           const uniform_int_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    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;
    // insertadores y extractores
    template<class CharT, class Traits>
    friend basic_ostream<CharT, Traits>&
      operator<<(basic_ostream<CharT, Traits>& os, // alojado
                 const uniform_int_distribution& x);
    template<class CharT, class Traits>
    friend basic_istream<CharT, Traits>&
      operator>>(basic_istream<CharT, Traits>& is, // alojado
                 uniform_int_distribution& x);
  };
}

Plantilla de clase std::uniform_real_distribution

namespace std {
  template<class RealType = double>
  class uniform_real_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const uniform_real_distribution& x,
                           const uniform_real_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    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;
    // insertadores y extractores
    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);
  };
}

Clase std::bernoulli_distribution

namespace std {
  class bernoulli_distribution
  {
  public:
    // tipos
    using result_type = bool;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    bernoulli_distribution()
      : bernoulli_distribution(0.5)
    {
    }
    explicit bernoulli_distribution(double p);
    explicit bernoulli_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const bernoulli_distribution& x,
                           const bernoulli_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::binomial_distribution

namespace std {
  template<class IntType = int>
  class binomial_distribution
  {
  public:
    // tipos
    using result_type = IntType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    binomial_distribution()
      : binomial_distribution(1)
    {
    }
    explicit binomial_distribution(IntType t, double p = 0.5);
    explicit binomial_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const binomial_distribution& x,
                           const binomial_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    IntType t() const;
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::geometric_distribution

namespace std {
  template<class IntType = int>
  class geometric_distribution
  {
  public:
    // tipos
    using result_type = IntType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    geometric_distribution()
      : geometric_distribution(0.5)
    {
    }
    explicit geometric_distribution(double p);
    explicit geometric_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const geometric_distribution& x,
                           const geometric_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::negative_binomial_distribution

namespace std {
  template<class IntType = int>
  class negative_binomial_distribution
  {
  public:
    // tipos
    using result_type = IntType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const negative_binomial_distribution& x,
                           const negative_binomial_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedades
    IntType k() const;
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::poisson_distribution

namespace std {
  template<class IntType = int>
  class poisson_distribution
  {
  public:
    // tipos
    using result_type = IntType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    poisson_distribution()
      : poisson_distribution(1.0)
    {
    }
    explicit poisson_distribution(double mean);
    explicit poisson_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const poisson_distribution& x, const poisson_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    double mean() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::exponential_distribution

namespace std {
  template<class RealType = double>
  class exponential_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    exponential_distribution()
      : exponential_distribution(1.0)
    {
    }
    explicit exponential_distribution(RealType lambda);
    explicit exponential_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const exponential_distribution& x,
                           const exponential_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType lambda() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::gamma_distribution

namespace std {
  template<class RealType = double>
  class gamma_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    gamma_distribution()
      : gamma_distribution(1.0)
    {
    }
    explicit gamma_distribution(RealType alpha, RealType beta = 1.0);
    explicit gamma_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const gamma_distribution& x, const gamma_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType alpha() const;
    RealType beta() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::weibull_distribution

namespace std {
  template<class RealType = double>
  class weibull_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    weibull_distribution()
      : weibull_distribution(1.0)
    {
    }
    explicit weibull_distribution(RealType a, RealType b = 1.0);
    explicit weibull_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const weibull_distribution& x, const weibull_distribution& y);
    // funciones de generación
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::extreme_value_distribution

namespace std {
  template<class RealType = double>
  class extreme_value_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const extreme_value_distribution& x,
                           const extreme_value_distribution& y);
    // funciones de generación
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::normal_distribution

namespace std {
  template<class RealType = double>
  class normal_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // constructores y funciones de reinicio
    normal_distribution()
      : normal_distribution(0.0)
    {
    }
    explicit normal_distribution(RealType mean, RealType stddev = 1.0);
    explicit normal_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const normal_distribution& x, const normal_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType mean() const;
    RealType stddev() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::lognormal_distribution

namespace std {
  template<class RealType = double>
  class lognormal_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    lognormal_distribution()
      : lognormal_distribution(0.0)
    {
    }
    explicit lognormal_distribution(RealType m, RealType s = 1.0);
    explicit lognormal_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const lognormal_distribution& x,
                           const lognormal_distribution& y);
    // funciones de generación
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType m() const;
    RealType s() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::chi_squared_distribution

namespace std {
  template<class RealType = double>
  class chi_squared_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    chi_squared_distribution()
      : chi_squared_distribution(1.0)
    {
    }
    explicit chi_squared_distribution(RealType n);
    explicit chi_squared_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const chi_squared_distribution& x,
                           const chi_squared_distribution& y);
    // funciones de generación
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::cauchy_distribution

namespace std {
  template<class RealType = double>
  class cauchy_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    cauchy_distribution()
      : cauchy_distribution(0.0)
    {
    }
    explicit cauchy_distribution(RealType a, RealType b = 1.0);
    explicit cauchy_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const cauchy_distribution& x, const cauchy_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::fisher_f_distribution

namespace std {
  template<class RealType = double>
  class fisher_f_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const fisher_f_distribution& x,
                           const fisher_f_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedades
    RealType m() const;
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::student_t_distribution

namespace std {
  template<class RealType = double>
  class student_t_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    student_t_distribution()
      : student_t_distribution(1.0)
    {
    }
    explicit student_t_distribution(RealType n);
    explicit student_t_distribution(const param_type& parm);
    void reset();
    // operadores de igualdad
    friend bool operator==(const student_t_distribution& x,
                           const student_t_distribution& y);
    // funciones generadoras
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::discrete_distribution

namespace std {
  template<class IntType = int>
  class discrete_distribution
  {
  public:
    // tipos
    using result_type = IntType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const discrete_distribution& x,
                           const discrete_distribution& y);
    // funciones de generación
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    vector<double> probabilities() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::piecewise_constant_distribution

namespace std {
  template<class RealType = double>
  class piecewise_constant_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const piecewise_constant_distribution& x,
                           const piecewise_constant_distribution& y);
    // funciones de generación
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    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;
    // insertadores y extractores
    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);
  };
}

Plantilla de clase std::piecewise_linear_distribution

namespace std {
  template<class RealType = double>
  class piecewise_linear_distribution
  {
  public:
    // tipos
    using result_type = RealType;
    using param_type  = /* no especificado */;
    // funciones de construcción y reinicio
    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();
    // operadores de igualdad
    friend bool operator==(const piecewise_linear_distribution& x,
                           const piecewise_linear_distribution& y);
    // funciones de generación
    template<class URBG>
    result_type operator()(URBG& g);
    template<class URBG>
    result_type operator()(URBG& g, const param_type& parm);
    // funciones de propiedad
    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;
    // insertadores y extractores
    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)

Contenidos

Incluye

Conceptos

Requisitos de generador uniforme de bits aleatorios

Clases

Motores de números aleatorios

Adaptadores de motor de números aleatorios

Generadores predefinidos

Números aleatorios no deterministas

Distribuciones uniformes

Distribuciones de Bernoulli

Distribuciones de Poisson

Distribuciones normales

Distribuciones de muestreo

Utilidades

Funciones

Sinopsis

Concepto uniform_random_bit_generator

Plantilla de clase std::linear_congruential_engine

Plantilla de clase std::mersenne_twister_engine

Plantilla de clase std::subtract_with_carry_engine

Plantilla de clase std::philox_engine

Plantilla de clase std::discard_block_engine

Plantilla de clase std::independent_bits_engine

Plantilla de clase std::shuffle_order_engine

Motores y adaptadores de motor con parámetros predefinidos

Clase std::random_device

Clase std::seed_seq

Plantilla de clase std::uniform_int_distribution

Plantilla de clase std::uniform_real_distribution

Clase std::bernoulli_distribution

Plantilla de clase std::binomial_distribution

Plantilla de clase std::geometric_distribution

Plantilla de clase std::negative_binomial_distribution

Plantilla de clase std::poisson_distribution

Plantilla de clase std::exponential_distribution

Plantilla de clase std::gamma_distribution

Plantilla de clase std::weibull_distribution

Plantilla de clase std::extreme_value_distribution

Plantilla de clase std::normal_distribution

Plantilla de clase std::lognormal_distribution

Plantilla de clase std::chi_squared_distribution

Plantilla de clase std::cauchy_distribution

Plantilla de clase std::fisher_f_distribution

Plantilla de clase std::student_t_distribution

Plantilla de clase std::discrete_distribution

Plantilla de clase std::piecewise_constant_distribution

Plantilla de clase std::piecewise_linear_distribution

Concepto `uniform_random_bit_generator`