C++

Reference

<random>

uniform_int_distribution

class template
<random>

std::uniform_int_distribution

template <class IntType = int> class uniform_int_distribution;
Uniform discrete distribution
Random number distribution that produces integer values according to a uniform discrete distribution, which is described by the following probability mass function:



This distribution produces random integers in a range [a,b] where each possible value has an equal likelihood of being produced. This is the distribution function that appears on many trivial random processes (like the result of rolling a die).

The distribution parameters, a and b, are set on construction.

To produce a random value following this distribution, call its member function operator().

For a discrete distribution that can have different probabilities for each possible value, see discrete_distribution.

Template parameters

IntType
An integer type. Aliased as member type result_type.
By default, this is int.

Member types

The following aliases are member types of uniform_int_distribution:

member typedefinitionnotes
result_typeThe first template parameter (IntType)The type of the numbers generated (defaults to int)
param_typenot specifiedThe type returned by member param.

Member functions

(constructor)
Construct uniform discrete distribution (public member function)
operator()
Generate random number (public member function)
reset
Reset distribution (public member function)
param
Distribution parameters (public member function)
min
Minimum value (public member function)
max
Maximum value (public member function)

Distribution parameters:

a
Lower bound of range (public member function)
b
Upper bound of range (public member function)

Non-member functions

operator<<
Insert into output stream (function template)
operator>>
Extract from input stream (function template)
relational operators
Relational operators (function template)

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
// uniform_int_distribution
#include <iostream>
#include <random>

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

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

  int p[10]={};

  for (int i=0; i<nrolls; ++i) {
    int number = distribution(generator);
    ++p[number];
  }

  std::cout << "uniform_int_distribution (0,9):" << std::endl;
  for (int i=0; i<10; ++i)
    std::cout << i << ": " << std::string(p[i]*nstars/nrolls,'*') << std::endl;

  return 0;
}

Possible output:
uniform_int_distribution (0,9):
0: *********
1: *********
2: *********
3: *********
4: *********
5: *********
6: *********
7: *********
8: *********
9: *********


See also

uniform_real_distribution
Uniform real distribution (class template)
bernoulli_distribution
Bernoulli distribution (class)