29 Numerics library [numerics]

29.5 Random number generation [rand]

29.5.9 Random number distribution class templates [rand.dist]

29.5.9.6 Sampling distributions [rand.dist.samp]

29.5.9.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 in Formula 29.21 .

\begin{matrix} 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} . \\ (29.21) \end{matrix}

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}) .

🔗

namespace std { 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(); // equality operators friend bool operator==(const piecewise_linear_distribution& x, const piecewise_linear_distribution& y); // 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; // inserters and extractors template<class charT, class traits> friend basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os, const piecewise_linear_distribution& x); template<class charT, class traits> friend basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, piecewise_linear_distribution& x); }; }

🔗

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: Both of

(4.1)
is_convertible_v<iterator_traits<InputIteratorB>::value_type, double>
(4.2)
is_convertible_v<iterator_traits<InputIteratorW>::value_type, double>

are 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