Tutorialspoint.dev

random header | Set 2 (Distributions)

Set 1 (Generators)

Distributions

I. Uniform : uniform

  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:
    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 <iostream>
    #include <random>
    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 <iostream>
    #include <random>
    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;
    }

    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:
    uniform_real

    • 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 <iostream>
    #include <random>
    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 <iostream>
    #include <random>
    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:
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:
    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 <iostream>
    #include <random>
    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 <iostream>
    #include <random>
    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:
    binomial_distribution

    • 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 <iostream>
    #include <chrono>
    #include <random>
    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 <iostream>
    #include <chrono>
    #include <random>
    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:
    geometric_distribution

    • 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 <iostream>
    #include <chrono>
    #include <string>
    #include <random>
    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 <iostream>
    #include <random>
    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:
    negative

    • 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 <iostream>
    #include <chrono>
    #include <random>
    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 <iostream>
    #include <random>
    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:
piecewise

  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 <iostream>
    #include <random>
    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[10] = {};
          
        // 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 <iostream>
    #include <random>
    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:
    piecwise constant

    • 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 <iostream>
    #include <random>
    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 <iostream>
    #include <random>
    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
    

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.



This article is attributed to GeeksforGeeks.org

leave a comment

code

0 Comments

load comments

Subscribe to Our Newsletter