random header | Set 2 (Distributions)
Last Updated :
29 May, 2017
Set 1 (Generators)
Distributions
I. Uniform :
- 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.
#include <iostream>
#include <random>
using namespace std;
int main()
{
unsigned s = 2;
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
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
uniform_int_distribution< int > distribution(1, 1000);
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
1
132
- 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.
#include <iostream>
#include <random>
using namespace std;
int main()
{
unsigned s = 2;
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
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
uniform_real_distribution< double > distribution(0.0,100.0);
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
13.1538
45.865
II. Related to bernoulli trials:
-
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.
#include <iostream>
#include <random>
using namespace std;
int main()
{
const int temp=500;
default_random_engine generator;
bernoulli_distribution distribution(0.7);
int count=0;
for ( int i = 0; i < temp; ++i)
{
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
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
bernoulli_distribution distribution;
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
1
1
-
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.
#include <iostream>
#include <chrono>
#include <random>
using namespace std;
int main()
{
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
default_random_engine generator (seed);
binomial_distribution< int > distribution (15, 0.4);
cout << "some binomial results (t=15, p=0.4): " ;
for ( int i = 0; i < 15; ++i)
{
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
#include <iostream>
#include <chrono>
#include <random>
using namespace std;
int main()
{
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
default_random_engine generator (seed);
binomial_distribution< int > distribution (15, 0.4);
cout << "some binomial results (t=15, p=0.4): " ;
for ( int i = 0; i < 15; ++i)
{
cout << distribution(generator) << " " ;
}
cout << endl;
return 0;
}
|
Output:
57
52
-
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.
#include <iostream>
#include <chrono>
#include <string>
#include <random>
using namespace std;
int main()
{
int seed = chrono::system_clock::now().time_since_epoch().count();
default_random_engine generator (seed);
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 :
++ + + + ++ + ++
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
geometric_distribution< int > distribution(0.3);
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
0
1
- 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.
#include <iostream>
#include <chrono>
#include <random>
using namespace std;
int main()
{
unsigned seed = chrono::system_clock::now().time_since_epoch().count();
default_random_engine generator (seed);
negative_binomial_distribution< int > distribution (6,0.7);
cout << "Negative binomial results (t=6, p=0.7): " ;
for ( int i = 0; i < 15; ++i)
{
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
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
negative_binomial_distribution< int > distribution(20, 0.5);
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
23
30
III.Piece wise distributions:
-
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.
#include <iostream>
#include <random>
using namespace std;
int main()
{
int n = 10000;
int m = 100;
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 < 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: ************
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
discrete_distribution< int > distribution {20,20,30,40};
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
0
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.
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
piecewise_constant_distribution< double > distribution
( 4, 0.0, 10.0, []( double x){ return x;} );
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
3.4205
6.6692
-
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.
#include <iostream>
#include <random>
using namespace std;
int main()
{
default_random_engine generator;
piecewise_linear_distribution< double >
distribution ( 5, 0.0, 10.0, []( double x){ return x+1.0;} );
cout << distribution(generator) << endl;
distribution.reset();
cout << distribution(generator) << endl;
return 0;
}
|
Output:
2.48143
6.07656
Share your thoughts in the comments
Please Login to comment...