# random header | Set 2 (Distributions)

Set 1 (Generators)

Distributions

1. uniform_int_distribution: It produces random integer values i, which are uniformly distributed on the closed interval [a,b], which is described by the following probability mass function: • operator(): It generates the random number that are distributed according to the probability function.
• min: It returns the greatest lower bound of the range of values returned by operator(), which is the distribution parameter ‘a’ for uniform_int_distribution.
• max: It returns the least upper bound of the range of values returned by operator(), which is the distribution parameter ‘b’ for uniform_int_distribution.
• reset: It resets the distribution, so that on the subsequent uses the result does not depends on the values already produced by it.
 `// C++ program to illustrate ` `// the use of operator() ` `// in uniform_int_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `     `  `    ``// Constructing a trivial random generator engine  ` `    ``unsigned s = 2; ` `     `  `    ``// The random number generator ` `    ``default_random_engine generator (s); ` `     `  `    ``uniform_int_distribution<``int``> distribution(1,10); ` `    ``cout << ``"Some random numbers between 1 and 10"``; ` `    ``for` `(``int` `i = 0; i < 10; ++i) ` `        ``cout << distribution(generator) ; ` `     `  `    ``cout << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```Some random numbers between 1 and 10: 1 3 6 10 1 5 1 4 4 9
```
 `// C++ program to illustrate ` `// the use of reset ` `// in uniform_int_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `//Driver program ` `int` `main() ` `{ ` `         `  `    ``//the random number generator ` `    ``default_random_engine generator; ` `     `  `    ``// Initialising the uniform distribution ` `    ``uniform_int_distribution<``int``> distribution(1, 1000); ` `     `  `    ``// First random number is generated ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``//Resets the distribution ` `    ``distribution.reset(); ` `     `  `    ``// Second random number is  ` `    ``//generated independent of previous number ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``return` `0; ` `} `

/div>

Output:

```1
132
```
2. uniform_real_distribution: It is the random number distribution that produces floating-point values , which is described by the following probability density function: • operator(): It returns a new random number that follows the distribution’s parameters.
• min: It returns the greatest lower bound of the range of values returned by operator(), which is the distribution parameter ‘a’ for uniform_real_distribution.
• max: It returns the least upper bound of the range of values returned by operator(), which is the distribution parameter ‘b’ for uniform_real_distribution.
• reset: It resets the distribution, so that on the subsequent uses the result does not depend on values already produced by it.
 `// C++ program to illustrate ` `// the use of operator() ` `// in uniform_int_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `     `  `    ``// Constructing a trivial random generator engine  ` `    ``unsigned s = 2; ` `     `  `    ``// The random number generator ` `    ``default_random_engine generator (s); ` `     `  `    ``uniform_int_distribution<``int``> distribution(1,10); ` `    ``cout << ``"Random numbers between 1 and 10"``; ` `    ``for` `(``int` `i = 0; i< 10; ++i) ` `        ``cout << distribution(generator) ; ` `     `  `    ``cout << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```some random numbers between 0.0 and 10.0:
0.150031
9.77072
3.36669
7.06447
5.11455
8.43061
1.93792
7.78965
8.31532
5.14354
```
 `// C++ program to illustrate ` `// the use of reset ` `// in uniform_real_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``default_random_engine generator; ` `    ``uniform_real_distribution<``double``> distribution(0.0,100.0); ` `     `  `    ``// It prints two independent values: ` `    ``// First random number is generated ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``//Resets the distribution ` `    ``distribution.reset(); ` `     `  `    ``// Second random number is  ` `    ``//generated independent of previous number ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```13.1538
45.865
```

II. Related to bernoulli trials: 1. bernoulli_distribution: It is the random number distribution that produces bool values according to a Bernoulli distribution, given by the following probability mass function: • operator(): It returns a new random number.
• min: It returns the greatest lower bound of the range of values returned by operator(), which for bernoulli_distribution is false.
• max: It returns the least upper bound of the range of values returned by operator(), which for bernoulli_distribution is true.
 `// C++ program to illustrate ` `// the bernoulli_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `//Driver program ` `int` `main() ` `{ ` `    ``const` `int` `temp=500; ` `     `  `    ``//The random number generator ` `    ``default_random_engine generator; ` `     `  `    ``//Initialising the bernoulli distribution ` `    ``bernoulli_distribution distribution(0.7); ` `     `  `    ``// count number of trues ` `    ``int` `count=0;  ` `     `  `    ``for` `(``int` `i = 0; i < temp; ++i)  ` `    ``{ ` `         `  `        ``// checking for true condition  ` `        ``if` `(distribution(generator))  ` `        ``count++; ` `    ``} ` `     `  `    ``cout << ``"bernoulli_distribution (0.7) x 500:"` `<< endl; ` `    ``cout << ``"true: "` `<< count << endl; ` `    ``cout << ``"false: "` `<< temp-count << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```bernoulli_distribution (0.7) x 500:
true:  360
false: 140
```
 `// C++ program to ` `// illustrate the use of reset ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `//Driver program ` `int` `main() ` `{ ` `    ``// Random number generator ` `    ``default_random_engine generator; ` `     `  `    ``// Initialising the bernoulli distribution ` `    ``bernoulli_distribution distribution; ` `     `  `    ``// print two independent values: ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``// use of reset ` `    ``// Generates second output without ` `    ``// the effect of first output  ` `    ``distribution.reset(); ` `    ``cout << distribution(generator) << endl; ` ` `  `return` `0; ` `} `

Output:

```1
1
```
2. binomial_distribution: It is the random number distribution that produces integers according to a binomial discrete distribution, which is given by this probability mass function: • operator(): It generates a new random number.
• max: It returns the least upper bound of the range given by operator(), which for binomial_distribution is the distribution parameter t.
• min: It returns the greatest lower bound of the range given by member operator(), which for binomial_distribution is always zero.
• reset: It resets the distribution, so that subsequent uses of the object do not depend on values already produced by it.
 `// C++ program to illustrate ` `// the use of binomial_distribution ` `#include ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `int` `main() ` `{ ` `     `  `    ``// construct a trivial random  ` `    ``//generator engine from a time-based seed: ` `    ``unsigned seed = chrono::system_clock::now().time_since_epoch().count(); ` `    ``default_random_engine generator (seed); ` `     `  `    ``// Initialising binomial distribution ` `    ``binomial_distribution<``int``> distribution (15, 0.4); ` `     `  `    ``cout << ``"some binomial results (t=15, p=0.4): "``; ` `    ``for` `(``int` `i = 0; i < 15; ++i) ` `    ``{ ` `             `  `        ``// Use of operator() ` `        ``cout << distribution(generator) << ``" "``; ` `    ``} ` `    ``cout << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```some binomial results (t=15, p=0.4): 7 6 7 8 4 6 7 6 9 3 5 6 4 6 7
```
 `// C++ program to illustrate ` `// the use of binomial_distribution ` `#include ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `int` `main() ` `{ ` `     `  `    ``// construct a trivial random  ` `    ``//generator engine from a time-based seed: ` `    ``unsigned seed = chrono::system_clock::now().time_since_epoch().count(); ` `    ``default_random_engine generator (seed); ` `     `  `    ``// Initialising binomial distribution ` `    ``binomial_distribution<``int``> distribution (15, 0.4); ` `     `  `    ``cout << ``"some binomial results (t=15, p=0.4): "``; ` `    ``for` `(``int` `i = 0; i < 15; ++i) ` `    ``{ ` `             `  `        ``// Use of operator() ` `        ``cout << distribution(generator) << ``" "``; ` `    ``} ` `    ``cout << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```57
52
```
3. geometric_distribution: It is a random number distribution that produces integers according to a geometric discrete distribution, given by the following probability mass function: • operator(): It returns a new random number that follows the distribution’s parameters.
• max: It returns least upper bound of the range given by operator().
• min: It returns the minimum value given by operator().
• reset: It resets the distribution, so that subsequent uses of the object do not depend on values already produced by it.
 `// C++ program to illustrate ` `//the use of geometric_distribution  ` `#include ` `#include ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `int` `main() ` `{ ` `    ``// construct a trivial random ` `    ``// generator engine from a time-based seed: ` `    ``int` `seed = chrono::system_clock::now().time_since_epoch().count(); ` `    ``default_random_engine generator (seed); ` `     `  `    ``// Initialises the geometric distribution ` `    ``geometric_distribution<``int``> distribution (1.0 / 5); ` `     `  `    ``cout << ``"Plus sign is 5 spaces away from the next :"` `<< endl; ` `    ``for` `(``int` `i = 0; i < 10 ; ++i)  ` `    ``{ ` `        ``int` `number = distribution(generator); ` `        ``cout << string (number,``' '``) << ``"+"``; ` `    ``} ` ` `  `return` `0; ` `} `

Output:

```each plus sign is 5 spaces away from the next :
++ + +   +  ++     +        ++
```
 `// C++ program to illustrate  ` `// the use of reset ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `     `  `    ``// Random number generator  ` `    ``default_random_engine generator; ` `     `  `    ``// Initialising the geometric distribution ` `    ``geometric_distribution<``int``> distribution(0.3); ` `     `  `    ``// Prints two independent values: ` `    ``// Generates the first value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``// Use of reset ` `    ``distribution.reset(); ` `     `  `    ``// Generates second value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```0
1
```
4. negative_binomial_distribution: It is a random number distribution that produces integers according to a negative binomial discrete distribution (also known as Pascal distribution), given by the following probability mass function: • operator():It returns a new random number which follows the distribution’s parameters.
• max:It returns least upper bound of the range given by operator().
• min:It returns the minimum value given by operator(),which for negative_binomial_distribution is always zero.
• reset: It resets the distribution, so that subsequent uses of the object do not depend on values already produced by it.
 `// C++ program to illustrate ` `// the use of operator() in ` `// negative_binomial_distribution  ` `#include ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `    ``// construct a trivial random  ` `    ``// generator engine from a time-based seed: ` `    ``unsigned seed = chrono::system_clock::now().time_since_epoch().count(); ` `    ``default_random_engine generator (seed); ` `     `  `    ``// Initialising negative binomial distribution ` `    ``negative_binomial_distribution<``int``> distribution (6,0.7); ` `     `  `    ``cout << ``"Negative binomial results (t=6, p=0.7): "``; ` `    ``for` `(``int` `i = 0; i < 15; ++i) ` `        ``{ ` `            ``// Use of operator ` `            ``cout << distribution(generator) << ``" "``; ` `        ``} ` `     `  `    ``cout << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```Negative binomial results (t=6, p=0.7): 2 6 3 1 4 1 4 1 2 0 7 3 4 4 4
```
 `// C++ program to illustrate ` `// the use of reset in ` `// negative_binomial_distribution:: ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `     `  `    ``// Random number generator  ` `    ``default_random_engine generator; ` `     `  `    ``// Initialising the negative binomial distribution ` `    ``negative_binomial_distribution<``int``> distribution(20, 0.5); ` `     `  `    ``// print two independent values: ` `    ``// Generates the first value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``// Use of reset ` `    ``distribution.reset(); ` `     `  `    ``// Generates the second value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```23
30
```

III.Piece wise distributions: 1. discrete_distribution: It is a random number distribution that produces integer values according to a discrete distribution.

• operator(): It returns a new random number that follows the distribution’s parameters.
• max: It returns the least upper bound of the range given by operator().
• min: It returns the greatest lower bound of the range given by operator().
• reset: It resets the distribution, so that subsequent uses of the object do not depend on values already produced by it.
 `// C++ program to illustrate the ` `// use of operator() in ` `// discrete_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `int` `main() ` `{ ` `     `  `    ``// number of experiments ` `    ``int` `n = 10000;  ` `     `  `    ``// maximum number of stars to distribute ` `    ``int` `m = 100;  ` `     `  `    ``// Random number generator ` `    ``default_random_engine generator; ` `     `  `    ``//Initialising discrete distribution ` `    ``discrete_distribution<``int``> distribution { 2, 2, 1, 1, 2, 2, 1, 1, 2, 2 }; ` `     `  `    ``int` `p = {}; ` `     `  `    ``// use of operator() ` `    ``for` `(``int` `i = 0; i < n; i++)  ` `    ``{ ` `        ``int` `number = distribution(generator); ` `        ``p[number]++; ` `    ``} ` `     `  `    ``cout << ``"a discrete_distribution:"` `<< endl; ` `    ``for` `(``int` `i = 0; i < 10; ++i) ` `    ``{ ` `        ``cout << i << ``": "` `<< string(p[i]*m/n,``'*'``) << endl; ` `    ``} ` `     `  `    ``return` `0; ` `} `

Output:

```a discrete_distribution:
0: ************
1: *************
2: *****
3: ******
4: ************
5: ************
6: ******
7: ******
8: ************
9: ************
```
 `// C++ program to illustrate ` `//the use of reset in ` `//discrete_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `     `  `    ``// Random number generator  ` `    ``default_random_engine generator; ` `     `  `    ``// Initialising the discrete distribution ` `    ``discrete_distribution<``int``> distribution {20,20,30,40}; ` `     `  `    ``// print two independent values: ` `    ``// Generates the first value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``// Use of reset ` `    ``distribution.reset(); ` `     `  `    ``// Generates the secong value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```0
2
```
2. piecewise_constant_distribution: It is a random number distribution that produces floating-point values that are uniformly distributed over each of a sequence of contiguous subintervals, given by following probability density function: • operator(): It returns a new random number that follows the distribution’s parameters.
• max: It returns the least upper bound of the range given by operator().
• min: It returns the greatest lower bound of the range given by operator().
• reset: It resets the distribution, so that subsequent uses of the object do not depend on values already produced by it.
 `// C++ program to illustrate the ` `// use of reset in ` `// piecewise_constant_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `     `  `    ``// Random number generator ` `    ``default_random_engine generator; ` `     `  `    ``// Initialisind piecewise_constant_distribution ` `    ``piecewise_constant_distribution<``double``> distribution  ` `                ``( 4, 0.0, 10.0, [](``double` `x){``return` `x;} ); ` `     `  `    ``// print two independent values: ` `    ``// Generates the first value ` `    ``// Use of operator() ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``// Use of reset ` `    ``distribution.reset(); ` `     `  `    ``// Generates second value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```3.4205
6.6692
```
3. piecewise_linear_distribution: It is a random number distribution that produces floating-point values that are distributed over a sequence of contiguous subintervals.

• operator():It returns a new random number that follows the distribution’s parameters.
• max: It returns the least upper bound of the range given by operator().
• min: It returns the greatest lower bound of the range given by operator().
• reset: It resets the distribution, so that subsequent uses of the object do not depend on values already produced by it.
 `// C++ program to illustrate the ` `// use of reset in ` `// piecewise_linear_distribution ` `#include ` `#include ` `using` `namespace` `std; ` ` `  `// Driver program ` `int` `main() ` `{ ` `     `  `    ``// Random number generator ` `    ``default_random_engine generator; ` `     `  `    ``// Initialising piecewise_linear_distribution ` `    ``piecewise_linear_distribution<``double``> ` `        ``distribution ( 5, 0.0, 10.0, [](``double` `x){``return` `x+1.0;} ); ` `     `  `    ``// print two independent values: ` `    ``// generates first value ` `    ``// use of operator() ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``// Use of reset ` `    ``distribution.reset(); ` `     `  `    ``// generates second value ` `    ``cout << distribution(generator) << endl; ` `     `  `    ``return` `0; ` `} `

Output:

```2.48143
6.07656
```

## tags:

C++ Technical Scripter CPP