Probability Distributions

A probability distribution is family of functions that defines the parameters for a stochastic process. For example, the simplest distribution of random numbers is the uniform distribution, where each value is generated with equal probability in a given range. A particular case of the uniform distribution is Uniform[0,1], where each number is randomly generated with equal probability in the range between 0 and 1.

There are a small number of probability distributions that occur very frequently in the analysis of natural events. These common distributions, which have been studied in several branches of stochastic analysis, are now available as part of the C++ <random> header in standard library. For examples of two common probability distributions, see Figure 13-1 (which shows the normal distribution with mean 0 and standard deviation 1), Figure 13-2 (which shows the exponential distribution with mean 1), and Figure 13-3 (which shows the Chi-squared distribution).

Consider the most common case of generating uniform random integer numbers in a particular range. This can be easily handled in the standard library by using the std::uniform_int_distribution template . This template is capable of creating integer numbers that have uniform distribution as given by the two parameters: the initial and maximum values. Here is an example of how to code a function that returns such random integer numbers:

#include <iostream>

#include <random>

using std::cout;

using std::endl;

std::default_random_engine generator;

int get_uniform_int(int max)

{

    if (max < 1)

    {

        cout  << "invalid parameter max " << max << endl;

        throw std::runtime_error("invalid parameter max");

    }

    std::uniform_int_distribution<int> uint(0,max);

    return uint(generator);

}

The first step is to define a generator to use as the source of random bits. This is done by instantiating an engine (done at the file scope). The std::default_random_engine is the default generator selected by the compiler’s implementation. It should be a reasonable choice, unless you want to be very specific about the generator for your code.

The get_uniform_int function generates a random integer between 0 and max, where max is a parameter passed to the function. The function first checks if the parameter is valid and throws an exception when that is not the case. The function then uses the parameter to create an object of type uniform_int_distribution. This object receives two parameters that define the distribution: the minimum and maximum values. The resulting object is then used to generate the random number itself.

Using Common Probability Distributions

This section will show a few examples of common probability distributions and how they can be used in C++. As mentioned, random numbers can be generated according to different probability functions. These families of functions are grouped according to the parameters and shape of the distribution.

One of the simplest probability distributions is the Bernoulli distribution. This is a family of probability distributions that model a yes/no scenario, an event that has only two results. The only parameter for this distribution is the probability of the yes result. The simplest example of this type of model is a coin toss, with parameter 0.5, representing a fair probability of heads or tails.

In this code, the first step is to use a generator, which in this case is std::default_random_engine allocated in the file scope, so it is available during the lifetime of the application. The coin_toss_experiment function initially checks the validity of the parameter num_experiments, which gives the number of tries in this random experiment.

The function then allocates a new object from the Bernoulli distribution, with parameter 0.5, which indicates that the yes/no event occurs with even probability for each side. The random values are then generated in the loop, where the bernoulli returns Boolean values according to the desired distribution behavior. The values are stored in a vector<bool> container.

Another common distribution that is used to model natural events is the Poisson distribution. This distribution arises commonly when observing the number of events that occur in a period of time, under the assumption that these events are independent. For example, the number of customers arriving at a coffee shop during a given period could be modeled as a Poisson distribution. The mathematical expression used to model the probability distribution of such events is given by

Here, k is the number events that are observed, and λ is the parameter that determines the results of the experiment, which can be interpreted as the average number of events occurring in the given time period.

In the C++ standard library, the Poisson distribution is made available through the std:: poisson_distribution template . The parameter for this distribution is the mean, usually represented as the mathematical variable λ as in the previous equation.

The num_customers_experiment function can generate a sequence of random values based on the Poisson distribution and return a histogram of these values, that is, for each value, it returns the number of times this value was observed.

The algorithm is similar to what you have seen before with the Bernoulli distribution. The first part is used to define the random generator, and it creates an object of type std::poisson_distribution. The parameter passed represents the mean of the distribution.

The for loop in the algorithm is used to build the histogram. At each step, a number is generated according to the Poisson distribution. Then, if the resulting number is less than the parameter max, that value is incremented in the list of occurrences.

The num_customers_experiment function is used in the next code fragment to print the results of the calculation. These numbers have been saved and used to create the chart displayed in Figure 13-4, which shows the observations between 0 and 20 and the corresponding number of observations for 200 trials.

The next example shows how to generate and use random values drawn from the normal distribution. The normal distribution, also known as Gaussian distribution, is one of the most common probability distributions used to model real-world data. It is employed in data analysis, in areas ranging from drug design to sociology. The normal distribution represents the distribution of values that are naturally measured in populations. For example, the heights of people living in a particular geographical area follow the normal distribution.

The bell-shaped probability graph of the normal distribution is determined by the Gaussian equation, which takes as parameters the mean and the standard deviation of a random variable. The equation is given by

In this equation, μ is the mean value of these numbers, and σ is the standard deviation, which is a measure of the variability of these random values.

The next function, test_normal, can be used to verify the correctness of this code. The idea of this function is to use the generated values so that it can create a histogram of the normal-distributed data. The first step of the algorithm is to call the get_normal_observations function and save the returned data. The next step is to get some information about the received data, such as the minimum and maximum values. This is done using the std::minmax_element function , which returns a pair of iterators pointing to the minimum and maximum values in the given range.

The algorithm creates a vector with elements corresponding to “bins,” that is, smaller ranges where each observation is recorded. The size of each such bin is stored as the variable h. The first loop then determines the number of elements in each such range so that a histogram can be calculated.

The values created in this way have been plotted and are displayed in Figure 13-5. The horizontal axis represents the value of each observation. The vertical axis represents the number of occurrences of each observation.