class template
<random>

std::piecewise_linear_distribution

template <class RealType = double> class piecewise_linear_distribution;
Piecewise linear distribution
Random number distribution that produces floating-point values that are distributed over a sequence of contiguous subintervals, of which the probability density at its boundaries is specified, as if defined by the following probability density function:



A set of n non-negative individual weights (the w's) for each of the n subinterval bounds (bi) are set on construction. The probability density on the bounds is proportional to those weights in such a way that the integral that covers all possible values is exactly 1.0.
The probability of producing a value within each subinterval is the linear value in between the probability density of its bounds.

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

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 piecewise_linear_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 piecewise linear 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:

intervals
Intervals (public member function)
densities
Densities (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
 
// piecewise_linear_distribution
#include <iostream>
#include <array>
#include <random>

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

  std::default_random_engine generator;
  std::array<double,3> intervals {0.0, 4.5, 9.0};
  std::array<double,3> weights {10.0, 0.0, 10.0};
  std::piecewise_linear_distribution<double>
    distribution (intervals.begin(),intervals.end(),weights.begin());

  int p[10]={};

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

  std::cout << "a piecewise_linear_distribution:" << std::endl;
  for (int i=0; i<9; ++i) {
    std::cout << i << "-" << i+1 << ": ";
    std::cout << std::string(p[i]*nstars/nrolls,'*') << std::endl;
  }
  return 0;
}


Possible output:
a piecewise_linear_distribution:
0-1: *******************
1-2: **************
2-3: *********
3-4: *****
4-5: *
5-6: *****
6-7: *********
7-8: **************
8-9: *******************

See also

uniform_real_distribution
Uniform real distribution (class template )
discrete_distribution
Discrete distribution (class template )
piecewise_constant_distribution
Piecewise constant distribution (class template )

C++