Espacios de nombres
Variantes

    Archivo de encabezado de la biblioteca estándar <random>

    De cppreference.com
     
    C++
    Apoyo de compiladores
    Implementaciones independientes y albergadas
    Lenguaje
    Biblioteca estándar
    Encabezados de la biblioteca estándar
    Requisitos denominados
    Macros de prueba de característica (C++20)
    Biblioteca de apoyo del lenguaje
    Biblioteca de conceptos (C++20)
    Biblioteca de diagnósticos
    Biblioteca de gestión de memoria
    Biblioteca de metaprogramación (C++11)
    Biblioteca de servicios generales
    Biblioteca de contenedores
    Biblioteca de iteradores
    Biblioteca de rangos (C++20)
    Biblioteca de algoritmos
    Biblioteca de cadenas
    Biblioteca de procesamiento de texto
    Biblioteca numérica
    Biblioteca de fecha y hora
    Biblioteca de entrada/salida
    Biblioteca del sistema de archivos (C++17)
    Biblioteca de apoyo de concurrencia (C++11)
    Biblioteca de apoyo de ejecución (C++26)
    Especificaciones técnicas
    Índice de símbolos
    Bibliotecas externas
     
    Archivos de encabezado de la biblioteca estándar
     
    See More

    Este archivo de encabezado es parte de la biblioteca de generación de números pseudoaleatorios.

    Plantilla:cpp/numeric/random/dsc minstd rand0Plantilla:cpp/numeric/random/dsc minstd randPlantilla:cpp/numeric/random/dsc mt19937Plantilla:cpp/numeric/random/dsc mt19937 64Plantilla:cpp/numeric/random/dsc ranlux24 basePlantilla:cpp/numeric/random/dsc ranlux48 basePlantilla:cpp/numeric/random/dsc ranlux24Plantilla:cpp/numeric/random/dsc ranlux48Plantilla:cpp/numeric/random/dsc knuth bPlantilla:cpp/numeric/random/dsc bernoulli distributionPlantilla:cpp/numeric/random/dsc binomial distributionPlantilla:cpp/numeric/random/dsc negative binomial distributionPlantilla:cpp/numeric/random/dsc geometric distributionPlantilla:cpp/numeric/random/dsc poisson distributionPlantilla:cpp/numeric/random/dsc exponential distributionPlantilla:cpp/numeric/random/dsc gamma distributionPlantilla:cpp/numeric/random/dsc weibull distributionPlantilla:cpp/numeric/random/dsc extreme value distributionPlantilla:cpp/numeric/random/dsc normal distributionPlantilla:cpp/numeric/random/dsc lognormal distributionPlantilla:cpp/numeric/random/dsc chi squared distributionPlantilla:cpp/numeric/random/dsc cauchy distributionPlantilla:cpp/numeric/random/dsc fisher f distributionPlantilla:cpp/numeric/random/dsc student t distributionPlantilla:cpp/numeric/random/dsc discrete distributionPlantilla:cpp/numeric/random/dsc piecewise constant distributionPlantilla:cpp/numeric/random/dsc piecewise linear distributionPlantilla:cpp/numeric/random/dsc seed seq

    Incluye

    (C++11)
    		 Plantilla de clase std::initializer_list. [editar]

    Conceptos

    Requerimientos del generador de bits aleatorios uniforme
    (C++20)
    		 Especifica que un tipo se califica como un generador de bits aleatorios uniforme.
    (concepto) [editar]

    Clases

    Motores de números aleatorios
    (C++11)
    		 Implementa un algoritmo generador lineal congruencial.
    (plantilla de clase) [editar]
    (C++11)
    		 Implementa el algoritmo Mersenne twister
    (plantilla de clase) [editar]
    (C++11)
    		 Implementa un algoritmo de resta con acarreo (Fibonacci con retraso).
    (plantilla de clase) [editar]
    Adaptadores de motores de números aleatorios
    (C++11)
    		 Descarta alguna salida de un motor de números aleatorios.
    (plantilla de clase) [editar]
    (C++11)
    		 Empaqueta la salida de un motor de números aleatorios en bloques de un número específico de bits.
    (plantilla de clase) [editar]
    (C++11)
    		 Entrega la salida de un motor de número aleatorios en un orden diferente.
    (plantilla de clase) [editar]
    Generadores predefinidos
    default_random_engine(C++11) definido por la implementación
    Números aleatorios no deterministas
    (C++11)
    		 Generador de números aleatorios no determinista usando como fuente entropía hardware.
    (clase) [editar]
    Distribuciones uniformes
    (C++11)
    		 Produce valores enteros distribuidos uniformemente en un rango.
    (plantilla de clase) [editar]
    (C++11)
    		 Produce valores reales distribuidos uniformemente en un rango.
    (plantilla de clase) [editar]
    Distribuciones de Bernoulli
    Distribuciones de Poisson
    Distribuciones normales
    Distribuciones de muestreo
    Utilerías

    Funciones

    (C++11)
    		 Distribuye uniformemente los valores reales de precisión dada en el rango [0, 1).
    (plantilla de función) [editar]

    Sinopsis

    #include <initializer_list>

namespace std {
  // requerimientos del generador de bits aleatorios uniforme
  template<class G>
    concept uniform_random_bit_generator = /* véase descripción */;

  // plantilla de clase linear_congruential_engine
  template<class UIntType, UIntType a, UIntType c, UIntType m>
    class linear_congruential_engine;

  // plantilla de clase 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;

  // plantilla de clase subtract_with_carry_engine
  template<class UIntType, size_t w, size_t s, size_t r>
    class subtract_with_carry_engine;

  // plantilla de clase discard_block_engine
  template<class Engine, size_t p, size_t r>
    class discard_block_engine;

  // plantilla de clase independent_bits_engine
  template<class Engine, size_t w, class UIntType>
    class independent_bits_engine;

  // plantilla de clase shuffle_order_engine
  template<class Engine, size_t k>
    class shuffle_order_engine;

  // motores y adaptadores de motores con parámetros predefinidos
  using minstd_rand0  = /* véase descripción */;
  using minstd_rand   = /* véase descripción */;
  using mt19937       = /* véase descripción */;
  using mt19937_64    = /* véase descripción */;
  using ranlux24_base = /* véase descripción */;
  using ranlux48_base = /* véase descripción */;
  using ranlux24      = /* véase descripción */;
  using ranlux48      = /* véase descripción */;
  using knuth_b       = /* véase descripción */;

  using default_random_engine = /* véase descripción */;

  // clase random_device
  class random_device;

  // clase seed_seq
  class seed_seq;

  // plantilla de función generate_canonical
  template<class RealType, size_t bits, class URBG>
    RealType generate_canonical(URBG& g);

  // plantilla de clase uniform_int_distribution
  template<class IntType = int>
    class uniform_int_distribution;

  // plantilla de clase uniform_real_distribution
  template<class RealType = double>
    class uniform_real_distribution;

  // clase bernoulli_distribution
  class bernoulli_distribution;

  // plantilla de clase binomial_distribution
  template<class IntType = int>
    class binomial_distribution;

  // plantilla de clase geometric_distribution
  template<class IntType = int>
    class geometric_distribution;

  // plantilla de clase negative_binomial_distribution
  template<class IntType = int>
    class negative_binomial_distribution;

  // plantilla de clase poisson_distribution
  template<class IntType = int>
    class poisson_distribution;

  // plantilla de clase exponential_distribution
  template<class RealType = double>
    class exponential_distribution;

  // plantilla de clase gamma_distribution
  template<class RealType = double>
    class gamma_distribution;

  // plantilla de clase weibull_distribution
  template<class RealType = double>
    class weibull_distribution;

  // plantilla de clase extreme_value_distribution
  template<class RealType = double>
    class extreme_value_distribution;

  // plantilla de clase normal_distribution
  template<class RealType = double>
    class normal_distribution;

  // plantilla de clase lognormal_distribution
  template<class RealType = double>
    class lognormal_distribution;

  // plantilla de clase 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;

  // plantilla de clase student_t_distribution
  template<class RealType = double>
    class student_t_distribution;

  // plantilla de clase discrete_distribution
  template<class IntType = int>
    class discrete_distribution;

  // plantilla de clase 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 siembra
      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, const linear_congruential_engine& x);
      template<class charT, class traits>
        friend basic_istream<charT, traits>&
          operator>>(basic_istream<charT, traits>& is, 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 /* pow(2, w) - 1 */; }
      static constexpr result_type default_seed = 5489u;

      // constructores y funciones de siembra
      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, const mersenne_twister_engine& x);
      template<class charT, class traits>
        friend basic_istream<charT, traits>&
          operator>>(basic_istream<charT, traits>& is, 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 /* pow(2, w) - 1 */; }
      static constexpr result_type default_seed = 19780503u;

      // constructores y funciones de siembra
      subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {}
      explicit subtract_with_carry_engine(result_type value);
      template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
      void seed(result_type value = default_seed);
      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, const subtract_with_carry_engine& x);
      template<class charT, class traits>
        friend basic_istream<charT, traits>&
          operator>>(basic_istream<charT, traits>& is, subtract_with_carry_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 siembra
      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 propiedades
      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 discard_block_engine& x);
      template<class charT, class traits>
        friend basic_istream<charT, traits>&
          operator>>(basic_istream<charT, traits>& is, discard_block_engine& x);

    private:
      Engine e;   // solo de exposición
      int n;      // solo de 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 /* pow(2, w) - 1 */; }

      // constructores y funciones de siembra
      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 propiedades
      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 independent_bits_engine& x);
      template<class charT, class traits>
        friend basic_istream<charT, traits>&
          operator>>(basic_istream<charT, traits>& is, independent_bits_engine& x);

    private:
      Engine e;   // solo de 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 siembra
      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 propiedades
      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 de exposición
      result_type V[k];   // solo de exposición
      result_type Y;      // solo de exposición
    };
}

    Motores y adaptadores de motores 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 */;
}

    Clase std::random_device

    namespace std {
  class random_device {
  public:
    // tipos
    using result_type = unsigned int;

    // caracteristicas 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(/* definido por la implementación */) {}
    explicit random_device(const string& token);

    // funciones de generación
    result_type operator()();

    // funciones de propiedades
    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 InputIt>
      seed_seq(InputIt begin, InputIt end);

    // funciones de generación
    template<class RandomAccessIt>
      void generate(RandomAccessIt begin, RandomAccessIt end);

    // funciones de propiedades
    size_t size() const noexcept;
    template<class OutputIt>
      void param(OutputIt dest) const;

    // funciones de no copia
    seed_seq(const seed_seq&) = delete;
    void operator=(const seed_seq&) = delete;

  private:
    vector<result_type> v;        // solo de 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 restablecimiento
      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 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 propiedades
      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_int_distribution& x);
      template<class charT, class traits>
        friend basic_istream<charT, traits>&
          operator>>(basic_istream<charT, traits>& is, 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 restablecimiento
      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 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 propiedades
      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 restablecimiento
    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 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 propiedades
    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 restablecimiento
      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 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 propiedades
      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 restablecimiento
      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 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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      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 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 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 restablecimiento
      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 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 propiedades
      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 restablecimiento
      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 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 propiedades
      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 restablecimiento
      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 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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      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 propiedades
      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 restablecimiento
      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 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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      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 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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      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 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 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 */;

      // constructores y funciones de restablecimiento
      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 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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      discrete_distribution();
      template<class InputIt>
        discrete_distribution(InputIt firstW, InputIt 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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      piecewise_constant_distribution();
      template<class InputItB, class InputItW>
        piecewise_constant_distribution(InputItB firstB, InputItB lastB, InputItW 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 propiedades
      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 */;

      // constructores y funciones de restablecimiento
      piecewise_linear_distribution();
      template<class InputItB, class InputItW>
        piecewise_linear_distribution(InputItB firstB, InputItB lastB, InputItW 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 propiedades
      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);
    };
}