Reference

<random>

class template
<random>

std::exponential_distribution

template <class RealType = double> class exponential_distribution;
Exponential distribution
Random number distribution that produces floating-point values according to an exponential distribution, which is described by the following probability density function:



This distribution produces random numbers where each value represents the interval between two random events that are independent but statistically defined by a constant average rate of occurrence (its lambda, λ).

The distribution parameter, lambda, is set on construction.

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

Its analogous discrete distribution is the geometric_distribution.

Template parameters

RealType
A floating-point type. Aliased as member type result_type.
By default, this is double.

Member types

The following aliases are member types of geometric_distribution:

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

Member functions

(constructor)
Construct exponential 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:

lambda
Lambda (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
26
27
28
29
30
// exponential_distribution
#include <iostream>
#include <random>
int main()
{
 const int nrolls=10000; // number of experiments
 const int nstars=100; // maximum number of stars to distribute
 const int nintervals=10; // number of intervals
 std::default_random_engine generator;
 std::exponential_distribution<double> distribution(3.5);
 int p[nintervals]={};
 for (int i=0; i<nrolls; ++i) {
 double number = distribution(generator);
 if (number<1.0) ++p[int(nintervals*number)];
 }
 std::cout << "exponential_distribution (3.5):" << std::endl;
 std::cout << std::fixed; std::cout.precision(1);
 for (int i=0; i<nintervals; ++i) {
 std::cout << float(i)/nintervals << "-" << float(i+1)/nintervals << ": ";
 std::cout << std::string(p[i]*nstars/nrolls,'*') << std::endl;
 }
 return 0;
}

Possible output:
exponential_distribution (3.5):
0.0-0.1: *****************************
0.1-0.2: *********************
0.2-0.3: **************
0.3-0.4: *********
0.4-0.5: *******
0.5-0.6: *****
0.6-0.7: ***
0.7-0.8: **
0.8-0.9: *
0.9-1.0: *


See also

geometric_distribution
Geometric distribution (class template)
poisson_distribution
Poisson distribution (class template)
gamma_distribution
Gamma distribution (class template)
weibull_distribution
Weibull distribution (class template)
extreme_value_distribution
Extreme Value distribution (class template)

AltStyle によって変換されたページ (->オリジナル) /