26 Numerics library [numerics]

26.6 Random number generation [rand]

26.6.8 Random number distribution class templates [rand.dist]

26.6.8.6 Sampling distributions [rand.dist.samp]

26.6.8.6.3 Class template piecewise_linear_distribution [rand.dist.samp.plinear]

A piecewise_linear_distribution random number distribution produces random numbers x,

b_{0} \leq x < b_{n}

, distributed over each subinterval

[b_{i}, b_{i + 1})

according to the probability density function

p (x | b_{0}, \dots, b_{n}, ρ_{0}, \dots, ρ_{n}) = ρ_{i} \cdot \frac{b_{i + 1} - x}{b_{i + 1} - b_{i}} + ρ_{i + 1} \cdot \frac{x - b_{i}}{b_{i + 1} - b_{i}}, for b_{i} \leq x < b_{i + 1} .

The

n + 1

distribution parameters

b_{i}

, also known as this distribution's interval boundaries, shall satisfy the relation

b_{i} < b_{i + 1}

for

i = 0, \dots, n - 1

Unless specified otherwise, the remaining

n + 1

distribution parameters are calculated as

ρ_{k} = w_{k} / S

for

k = 0, \dots, n

, in which the values

w_{k}

, commonly known as the weights at boundaries, shall be non-negative, non-NaN, and non-infinity.

Moreover, the following relation shall hold:

0 < S = \frac{1}{2} \cdot n - 1 \sum k = 0 (w_{k} + w_{k + 1}) \cdot (b_{k + 1} - b_{k}) .

template<class RealType = double>
  class piecewise_linear_distribution {
  public:
    // types
    using result_type = RealType;
    using param_type  = unspecified;

    // constructor and reset functions
    piecewise_linear_distribution();
    template<class InputIteratorB, class InputIteratorW>
      piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
                                    InputIteratorW firstW);
    template<class UnaryOperation>
      piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);
    template<class UnaryOperation>
      piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);
    explicit piecewise_linear_distribution(const param_type& parm);
    void reset();

    // generating functions
    template<class URBG>
      result_type operator()(URBG& g);
    template<class URBG>
      result_type operator()(URBG& g, const param_type& parm);

    // property functions
    vector<result_type> intervals() const;
    vector<result_type> densities() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
  };

🔗

piecewise_linear_distribution();

Effects: Constructs a piecewise_linear_distribution object with

n = 1

ρ_{0} = ρ_{1} = 1

b_{0} = 0

, and

b_{1} = 1

🔗

template<class InputIteratorB, class InputIteratorW>
 piecewise_linear_distribution(InputIteratorB firstB, InputIteratorB lastB,
                               InputIteratorW firstW);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Preconditions: InputIteratorB and InputIteratorW each meet the Cpp17InputIterator requirements ([input.iterators]).

If firstB == lastB or ++firstB == lastB, let

n = 1

ρ_{0} = ρ_{1} = 1

b_{0} = 0

, and

b_{1} = 1

Otherwise,

[firstB, lastB)

forms a sequence b of length

n + 1

, the length of the sequence w starting from firstW is at least

n + 1

, and any

w_{k}

for

k \geq n + 1

are ignored by the distribution.

Effects: Constructs a piecewise_linear_distribution object with parameters as specified above.

🔗

template<class UnaryOperation>
 piecewise_linear_distribution(initializer_list<RealType> bl, UnaryOperation fw);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: If

bl.size() < 2

, let

n = 1

ρ_{0} = ρ_{1} = 1

b_{0} = 0

, and

b_{1} = 1

Otherwise, let

[bl.begin(), bl.end())

form a sequence

b_{0}, \dots, b_{n}

, and let

w_{k} = fw (b_{k})

for

k = 0, \dots, n

Complexity: The number of invocations of fw does not exceed

n + 1

🔗

template<class UnaryOperation>
 piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw);

Mandates: is_invocable_r_v<double, UnaryOperation&, double> is true.

Preconditions: If

nw = 0

, let

n = 1

, otherwise let

n = nw

The relation

0 < δ = (xmax - xmin) / n

holds.

Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: Let

b_{k} = xmin + k \cdot δ

for

k = 0, \dots, n

, and

w_{k} = fw (b_{k})

for

k = 0, \dots, n

Complexity: The number of invocations of fw does not exceed

n + 1

🔗

vector<result_type> intervals() const;

Returns: A vector<result_type> whose size member returns

n + 1

and whose operator[] member returns

b_{k}

when invoked with argument k for

k = 0, \dots, n

🔗

vector<result_type> densities() const;

Returns: A vector<result_type> whose size member returns n and whose operator[] member returns

ρ_{k}

when invoked with argument k for

k = 0, \dots, n

26 Numerics library [numerics]

26.6 Random number generation [rand]

26.6.8 Random number distribution class templates [rand.dist]

26.6.8.6 Sampling distributions [rand.dist.samp]

26.6.8.6.3 Class template piecewise_­linear_­distribution [rand.dist.samp.plinear]

26.6.8.6.3 Class template piecewise_linear_distribution [rand.dist.samp.plinear]