discrete_distribution (Clase)

 

Para obtener la documentación más reciente de Visual Studio 2017 RC, consulte Documentación de Visual Studio 2017 RC.

Genera una distribución de enteros discreta que tenga intervalos de ancho uniforme con probabilidad uniforme en cada intervalo.

class discrete_distribution  
   {  
   public:  // types  
   typedef IntType result_type;  
   struct param_type;  // constructor and reset functions  
   discrete_distribution();
   template <class InputIterator>  
   discrete_distribution(InputIterator firstW, InputIterator lastW);
   discrete_distribution(initializer_list<double>  
   weightlist);
   template <class UnaryOperation>  
   discrete_distribution(size_t count, double xmin, double xmax, UnaryOperation funcweight);
   explicit discrete_distribution(const param_type& parm);
   void reset();
   // generating functions  
   template <class URNG>  
   result_type operator()(URNG& gen);
   template <class URNG>  
   result_type operator()(URNG& gen, const param_type& parm);
   // property functions  
   vector<double>  
   probabilities() const;
   param_type param() const;
   void param(const param_type& parm);
   result_type min() const;
   result_type max() const;
   };  

Parámetros

IntType
Un tipo de resultado de entero, el valor predeterminado es int. Para los tipos posibles, consulte <> </> > .

Esta distribución de muestreo tiene intervalos de ancho uniforme con probabilidad uniforme en cada intervalo. Para obtener información sobre otras distribuciones de muestreo, vea piecewise_linear_distribution (clase) y piecewise_constant_distribution (clase).

La tabla siguiente incluye vínculos a artículos sobre miembros individuales:

discrete_distribution::discrete_distributiondiscrete_distribution::param
discrete_distribution::operator()discrete_distribution::param_type

La función de propiedad vector<double> probabilities() devuelve las probabilidades individuales de cada entero generado.

Para obtener más información acerca de las clases de distribución y sus miembros, vea <> </> > .

// compile with: /EHsc /W4  
#include <random>   
#include <iostream>  
#include <iomanip>  
#include <string>  
#include <map>  
  
using namespace std;  
  
void test(const int s) {  
  
    // uncomment to use a non-deterministic generator  
    // random_device rd;  
    // mt19937 gen(rd());  
    mt19937 gen(1701);  
  
    discrete_distribution<> distr({ 1, 2, 3, 4, 5 });  
  
    cout << endl;  
    cout << "min() == " << distr.min() << endl;  
    cout << "max() == " << distr.max() << endl;  
    cout << "probabilities (value: probability):" << endl;  
    vector<double> p = distr.probabilities();  
    int counter = 0;  
    for (const auto& n : p) {  
        cout << fixed << setw(11) << counter << ": " << setw(14) << setprecision(10) << n << endl;  
        ++counter;  
    }  
    cout << endl;  
  
    // generate the distribution as a histogram  
    map<int, int> histogram;  
    for (int i = 0; i < s; ++i) {  
        ++histogram[distr(gen)];  
    }  
  
    // print results  
    cout << "Distribution for " << s << " samples:" << endl;  
    for (const auto& elem : histogram) {  
        cout << setw(5) << elem.first << ' ' << string(elem.second, ':') << endl;  
    }  
    cout << endl;  
}  
  
int main()  
{  
    int samples = 100;  
  
    cout << "Use CTRL-Z to bypass data entry and run using default values." << endl;  
    cout << "Enter an integer value for the sample count: ";  
    cin >> samples;  
  
    test(samples);  
}  
  

Use CTRL-Z to bypass data entry and run using default values.Enter an integer value for the sample count: 100min() == 0max() == 4probabilities (value: probability):          0:   0.0666666667          1:   0.1333333333          2:   0.2000000000          3:   0.2666666667          4:   0.3333333333Distribution for 100 samples:    0 :::::    1 ::::::::::::::    2 :::::::::::::::::    3 ::::::::::::::::::::::::::::::    4 ::::::::::::::::::::::::::::::::::  

Encabezado:<>>

Espacio de nombres: std

Construye la distribución.

 
// default constructor  
discrete_distribution();

 
// constructs using a range of weights, [firstW, lastW)  
template <class InputIterator>  
discrete_distribution(InputIterator firstW, InputIterator lastW);

 
// constructs using an initializer list for range of weights  
discrete_distribution(initializer_list<double>  
weightlist);

 
// constructs using unary operation function  
template <class UnaryOperation>  
discrete_distribution(size_t count, double xmin, double xmax, UnaryOperation weightfunc);

 
// constructs from an existing param_type structure  
explicit discrete_distribution(const param_type& parm);

Parámetros

firstW
Primer iterador de la lista a partir del que se va a construir la distribución.

lastW
Último iterador de la lista a partir del que se va a construir la distribución (no se incluye, ya que los iteradores usan un elemento vacío para el final).

weightlist
El initializer_list desde la que se va a construir la distribución.

count
Número de elementos del intervalo de distribución. Si count==0, equivale al constructor predeterminado (siempre genera cero).

minx
Valor mínimo del intervalo de distribución.

maxw
Valor máximo del intervalo de distribución.

weightfunc
Objeto que representa la función de probabilidad de la distribución. Tanto el parámetro como el valor devuelto debe poder convertirse a double.

parm
La estructura de parámetros utilizada para construir la distribución.

Comentarios

El constructor predeterminado crea un objeto cuyo valor de probabilidad almacenado tiene un elemento con el valor 1. Esto derivará en una distribución que siempre genera cero.

El constructor de intervalo de iterador

template <class InputIterator>  
discrete_distribution(InputIterator firstW, InputIterator lastW);

Construye un objeto de distribución con pesos de iteradores sobre la secuencia del intervalo [ firstI, lastI).

El constructor de lista de inicializador

discrete_distribution(initializer_list<double> weightlist);

crea un objeto de distribución con pesos de la lista de inicializadores weightlist.

El constructor definido como

template <class UnaryOperation>  
discrete_distribution(size_t count, double xmin, double xmax, UnaryOperation funcweight);

crea un objeto de distribución cuyo valor de probabilidad almacenado se inicializa en función de las siguientes reglas. Si count < 1, n = 1y como tal, equivale al constructor predeterminado, siempre genera cero. If count > 0, n = count. Provided 0 < d = ( maxw - minw)/ n, using d uniform subranges each weight is assigned as follows: weightk = weightfunc(x), where x = xmin + k * d + d/ 2, for k = 0, ..., n - 1.

El constructor definido como

explicit discrete_distribution(const param_type& parm);

crea un objeto de distribución usando parm como la estructura de parámetros almacenados.

Almacena todos los parámetros de la distribución.

struct param_type {  
   typedef discrete_distribution<IntType> distribution_type;  
   param_type();
   template <class UnaryOperation>  
   param_type(size_t count, double low, double high, UnaryOperation weightfunc);
   std::vector<double>  
   probabilities() const;
   ....  
   bool operator==(const param_type& right) const;
   bool operator!=(const param_type& right) const;
   };  

Parámetros

Consulte el tema primario discrete_distribution (clase).

Comentarios

Este paquete de parámetros puede pasarse a operator() para generar el valor devuelto.

<>>

Mostrar: