Monday, May 19, 2025

random number distributions

Overview
Multiple classes are provided to generate pseudo random numbers sequences. These classes use a pseudo random number engine to generate numbers and later distribute them into sequences using mathematical functions.

Details
A random number distribution is a function object that, when called with a random number generator
argument, produces a sequence of values of its result_type which can be any arithmetic type and Boolean.
IntType can be any of short, int, long, long long, unsigned short, unsigned int, unsigned long, or unsigned long long.
RealType can be any of float, double, or long double.

The distributions can be classified as below.
CategoryNameDefinition
Uniformuniform_int_distribution➹uniform_int_distribution<IntType>(IntType a, IntType b)
Example
/*prints

uniform_int_distribution:
0-1: *********
1-2: **********
2-3: *********
3-4: *********
4-5: **********
5-6: **********
6-7: *********
7-8: *********
8-9: **********
9-10: **********

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  uniform_int_distribution<int> distribution(0,9);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "uniform_int_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Uniformuniform_real_distribution➹uniform_real_distribution<RealType>(RealType a, RealType b)
Example
/*prints

uniform_real_distribution:
0-1: ****************************************************************************************************
1-2: 
2-3: 
3-4: 
4-5: 
5-6: 
6-7: 
7-8: 
8-9: 
9-10: 

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  uniform_real_distribution<double> distribution(0.0,1.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "uniform_real_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Bernoullibernoulli_distribution➹bernoulli_distribution<bool>(double p)
Example
/*prints

bernoulli_distribution:
0-1: **************************************************
1-2: *************************************************
2-3: 
3-4: 
4-5: 
5-6: 
6-7: 
7-8: 
8-9: 
9-10: 

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  bernoulli_distribution distribution(0.5);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "bernoulli_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Bernoullibinomial_distribution➹binomial_distribution<IntType>(IntType t, double p)
Example
/*prints

binomial_distribution:
0-1: 
1-2: *
2-3: ******
3-4: ***************
4-5: *************************
5-6: ************************
6-7: ****************
7-8: *******
8-9: *
9-10:

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  binomial_distribution<int> distribution(9,0.5);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "binomial_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Bernoulligeometric_distribution➹geometric_distribution<IntType>(double p)
Example
/*prints

geometric_distribution:
0-1: *****************************
1-2: ********************
2-3: ***************
3-4: **********
4-5: *******
5-6: ****
6-7: ***
7-8: **
8-9: *
9-10: *

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  geometric_distribution<int> distribution(0.3);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "geometric_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Bernoullinegative_binomial_distribution➹negative_binomial_distribution<IntType>(IntType k, double p)
Example
/*prints

negative_binomial_distribution:
0-1: ************
1-2: *******************
2-3: *****************
3-4: ****************
4-5: ***********
5-6: *******
6-7: *****
7-8: ***
8-9: **
9-10: *

*/    


  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  negative_binomial_distribution<int> distribution(3,0.5);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "negative_binomial_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Rate-basedpoisson_distribution➹poisson_distribution<IntType>(double mean)
Example
/*prints

poisson_distribution:
0-1: *
1-2: ******
2-3: **************
3-4: *******************
4-5: *******************
5-6: ****************
6-7: ***********
7-8: ******
8-9: ***
9-10: *

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  poisson_distribution<int> distribution(4.1);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "poisson_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Rate-basedexponential_distribution➹exponential_distribution<RealType>(RealType lambda)
Example
/*prints

exponential_distribution:
0-1: ************************************************************************************************
1-2: ***
2-3: 
3-4: 
4-5: 
5-6: 
6-7: 
7-8: 
8-9: 
9-10: 

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  exponential_distribution<double> distribution(3.5);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "exponential_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Rate-basedgamma_distribution➹gamma_distribution<RealType>(RealType alpha, RealType beta)
Example
/*prints

gamma_distribution:
0-1: *********
1-2: *****************
2-3: ******************
3-4: **************
4-5: ************
5-6: *********
6-7: *****
7-8: ****
8-9: ***
9-10: **

*/    
int main()
{
  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  gamma_distribution<double> distribution(2.0,2.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "gamma_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Rate-basedweibull_distribution➹weibull_distribution<RealType>(RealType a, RealType b)
Example
/*prints

weibull_distribution:
0-1: *****
1-2: ****************
2-3: ********************
3-4: ********************
4-5: ***************
5-6: *********
6-7: *****
7-8: **
8-9: *
9-10: 

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  weibull_distribution<double> distribution(2.0,4.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "weibull_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Rate-basedextreme_value_distribution➹extreme_value_distribution<RealType>(RealType a, RealType b)
Example
/*prints

extreme_value_distribution<double> distribution:
0-1: ********
1-2: *********
2-3: *********
3-4: ********
4-5: *******
5-6: *******
6-7: *****
7-8: *****
8-9: ****
9-10: ***

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
 extreme_value_distribution<double> distribution(2.0,4.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "extreme_value_distribution<double> distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Normalnormal_distribution➹normal_distribution<RealType>(RealType mean, RealType stddev)
Example
/*prints

normal_distribution<double> distribution):
0-1: *
1-2: ****
2-3: *********
3-4: ***************
4-5: ******************
5-6: *******************
6-7: ***************
7-8: ********
8-9: ****
9-10: * 

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  normal_distribution<double> distribution(5.0,2.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "normal_distribution<double> distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Normallognormal_distribution➹lognormal_distribution<RealType>(RealType m, RealType s)
Example
/*prints

lognormal_distribution<double> distribution(0.0,1.0):
0-1: **************************************************
1-2: **************************
2-3: **********
3-4: *****
4-5: **
5-6: *
6-7: 
7-8: 
8-9: 
9-10: 

*/    
int main()
{
  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  lognormal_distribution<double> distribution(0.0,1.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "lognormal_distribution<double> distribution(0.0,1.0):" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Normalchi_squared_distribution➹chi_squared_distribution<RealType>(RealType n)
Example
/*prints

chi_squared_distribution<double> distribution:
0-1: *******************
1-2: ***********************
2-3: ******************
3-4: ************
4-5: *********
5-6: *****
6-7: ***
7-8: **
8-9: *
9-10: *

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  chi_squared_distribution<double> distribution(3.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "chi_squared_distribution<double> distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Normalcauchy_distribution➹cauchy_distribution<RealType>(RealType a, RealType b)
Example
/*prints

cauchy_distribution<double> distribution:
0-1: *
1-2: **
2-3: ****
3-4: **********
4-5: ************************
5-6: *************************
6-7: *********
7-8: ****
8-9: **
9-10: *

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  cauchy_distribution<double> distribution(5.0,1.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "cauchy_distribution<double> distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Normalfisher_f_distribution➹fisher_f_distribution<RealType>(RealType m, RealType n)
Example
/*prints

fisher_f_distribution:
0-1: *************************************************
1-2: ****************
2-3: ********
3-4: *****
4-5: ***
5-6: **
6-7: *
7-8: *
8-9: *
9-10: *

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  fisher_f_distribution<double> distribution(2.0,2.0);

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "fisher_f_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Normalstudent_t_distribution➹student_t_distribution<RealType>(RealType n)
Example
/*prints

student_t_distribution:
-3.0..-2.5: 
-2.5..-2.0: **
-2.0..-1.5: ****
-1.5..-1.0: ********
-1.0..-0.5: **************
-0.5.. 0.0: ******************
 0.0.. 0.5: *******************
 0.5.. 1.0: **************
 1.0.. 1.5: ********
 1.5.. 2.0: ****
 2.0.. 2.5: **
 2.5.. 3.0: *

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  // intervals definitions:
  const int nintervals=12;
  const double first=-3.0;
  const double span=0.5;

  default_random_engine generator;
  student_t_distribution<double> distribution(10.0);

  int p[nintervals]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=first)&&(number<first+nintervals*span))
      ++p[int((number-first)/span)];
  }

  cout << "student_t_distribution:" << endl;
  cout << fixed; cout.precision(1);

  for (int i=0; i<nintervals; ++i) 
  {
    cout.width(4); cout << (first+i*span) << "..";
    cout.width(4); cout << (first+(i+1)*span) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Piecewisediscrete_distribution➹discrete_distribution<IntType>(size_t nw, double xmin, double xmax, UnaryOperation fw);
Example
/*prints

discrete_distribution:
0-1: ************
1-2: *************
2-3: *****
3-4: ******
4-5: ************
5-6: ************
6-7: ******
7-8: ******
8-9: ************
9-10: ************
9-10: ************ 

*/    
  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  discrete_distribution<int> distribution {2,2,1,1,2,2,1,1,2,2};

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "discrete_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Piecewisepiecewise_constant_distribution➹piecewise_constant_distribution<RealType>(InputIt first_i, InputIt last_i, InputIt2 first_w)
Example
/*prints

piecewise_constant_distribution:
0-1: ************
1-2: *************
2-3: *****
3-4: ******
4-5: ************
5-6: ************
6-7: ******
7-8: ******
8-9: ************
9-10: ************ 

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  array<double,6> intervals {0.0, 2.0, 4.0, 6.0, 8.0, 10.0};
  array<double,5> weights {2.0, 1.0, 2.0, 1.0, 2.0};
  piecewise_constant_distribution<double>
    distribution (intervals.begin(),intervals.end(),weights.begin());

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "piecewise_constant_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }
Piecewisepiecewise_linear_distribution➹piecewise_linear_distribution<RealType>(InputIt first_i, InputIt last_i, InputIt2 first_w)
Example
/*prints

piecewise_linear_distribution:
0-1: *******************
1-2: **************
2-3: *********
3-4: *****
4-5: *
5-6: *****
6-7: **********
7-8: **************
8-9: *******************
9-10: 

*/    

  const int nrolls=10000;  // number of experiments
  const int nstars=100;    // maximum number of stars to distribute

  default_random_engine generator;
  array<double,3> intervals {0.0, 4.5, 9.0};
  array<double,3> weights {10.0, 0.0, 10.0};
  piecewise_linear_distribution<double>
    distribution (intervals.begin(),intervals.end(),weights.begin());

  int p[10]={};

  for (int i=0; i<nrolls; ++i) 
  {
    double number = distribution(generator);
    if ((number>=0.0)&&(number<10.0)) ++p[int(number)];
  }

  cout << "piecewise_linear_distribution:" << endl;

  for (int i=0; i<10; ++i) 
  {
    cout << i << "-" << (i+1) << ": ";
    cout << string(p[i]*nstars/nrolls,'*') << endl;
  }

interface
All engines distributions provide same interface except for parameters. Constructor might differ for based on parameters. The following describes the interface for uniform_int_distribution➹.


at
Labels:

No comments:

Post a Comment

Subscribe to: Post Comments (Atom)