[rand.dist.samp]

26.5.8.6 Sampling distributions [rand.dist.samp]

26.5.8.6.1 Class template discrete_distribution [rand.dist.samp.discrete]

A discrete_distribution random number distribution produces random integers i, 0 ≤ i < n, distributed according to the discrete probability function P(i | p₀,…,p_n-1) = p_i .

Unless specified otherwise, the distribution parameters are calculated as: p_k = w_k / S for k = 0, …, n-1 , in which the values w_k, commonly known as the weights, shall be non-negative, non-NaN, and non-infinity. Moreover, the following relation shall hold: 0 < S = w₀ + ⋯ + w_n-1 .

template<class IntType = int>
 class discrete_distribution{
public:
 // types
 typedef IntType result_type;
 typedef unspecified param_type;

 // constructor and reset functions
 discrete_distribution();
 template<class InputIterator>
   discrete_distribution(InputIterator firstW, InputIterator lastW);
 discrete_distribution(initializer_list<double> wl);
 template<class UnaryOperation>
   discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);
 explicit discrete_distribution(const param_type& parm);
 void reset();

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

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

discrete_distribution();

Effects: Constructs a discrete_distribution object with n = 1 and p₀ = 1 . [ Note: Such an object will always deliver the value 0. — end note ]

template<class InputIterator> discrete_distribution(InputIterator firstW, InputIterator lastW);

Requires: InputIterator shall satisfy the requirements of an input iterator (Table [tab:iterator.input.requirements]) type. Moreover, iterator_traits<InputIterator>::value_type shall denote a type that is convertible to double. If firstW == lastW, let n = 1 and w₀ = 1 . Otherwise, [firstW, lastW) shall form a sequence w of length n > 0.

Effects: Constructs a discrete_distribution object with probabilities given by the formula above.

discrete_distribution(initializer_list<double> wl);

Effects: Same as discrete_distribution(wl.begin(), wl.end()).

template<class UnaryOperation> discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw);

Requires: Each instance of type UnaryOperation shall be a function object ([function.objects]) whose return type shall be convertible to double. Moreover, double shall be convertible to the type of UnaryOperation's sole parameter. If nw = 0 , let n = 1 , otherwise let n = nw. The relation 0 < δ = (xmax - xmin) / n shall hold.

Effects: Constructs a discrete_distribution object with probabilities given by the formula above, using the following values: If nw = 0, let w₀ = 1 . Otherwise, let w_k = fw(xmin + k · δ + δ / 2) for k = 0, …, n-1 .

Complexity: The number of invocations of fw shall not exceed n.

vector<double> probabilities() const;

Returns: A vector<double> whose size member returns n and whose operator[] member returns p_k when invoked with argument k for k = 0, …, n-1 .

26.5.8.6.2 Class template piecewise_constant_distribution [rand.dist.samp.pconst]

A piecewise_constant_distribution random number distribution produces random numbers x, b₀ ≤ x < b_n , uniformly distributed over each subinterval [ b_i, b_i+1 ) according to the probability density function p(x | b₀,…,b_n, ρ₀,…,ρ_n-1) = ρ_i , for b_i ≤ 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, …, n-1 . Unless specified otherwise, the remaining n distribution parameters are calculated as: $% \rho_k = \; \frac{w_k}{S \cdot (b_{k+1}-b_k)} \; \mbox{ for } k = 0, \ldots, n\!-\!1,$ in which the values w_k, commonly known as the weights, shall be non-negative, non-NaN, and non-infinity. Moreover, the following relation shall hold: 0 < S = w₀ + ⋯ + w_n-1 .

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

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

 // generating functions
 template<class URNG>
   result_type operator()(URNG& g);
 template<class URNG>
   result_type operator()(URNG& 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_constant_distribution();

Effects: Constructs a piecewise_constant_distribution object with n = 1 , ρ₀ = 1 , b₀ = 0 , and b₁ = 1 .

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

Requires: InputIteratorB and InputIteratorW shall each satisfy the requirements of an input iterator (Table [tab:iterator.input.requirements]) type. Moreover, iterator_traits<InputIteratorB>::value_type and iterator_traits<InputIteratorW>::value_type shall each denote a type that is convertible to double. If firstB == lastB or ++firstB == lastB, let n = 1 , w₀ = 1 , b₀ = 0 , and b₁ = 1 . Otherwise, [firstB, lastB) shall form a sequence b of length n+1, the length of the sequence w starting from firstW shall be at least n, and any w_k for k ≥ n shall be ignored by the distribution.

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

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

Effects: Constructs a piecewise_constant_distribution object with parameters taken or calculated from the following values: If bl.size() < 2, let n = 1, w₀ = 1 , b₀ = 0 , and b₁ = 1 . Otherwise, let [bl.begin(), bl.end()) form a sequence b₀, …, b_n , and let w_k = fw((b_k+1 + b_k) / 2) for k = 0, …, n-1 .

Complexity: The number of invocations of fw shall not exceed n.

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

Effects: Constructs a piecewise_constant_distribution object with parameters taken or calculated from the following values: Let b_k = xmin + k · δ for k = 0, …, n , and w_k = fw(b_k + δ / 2) for k = 0, …, n-1 .

Complexity: The number of invocations of fw shall not exceed n.

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, …, 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, …, n-1 .

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

A piecewise_linear_distribution random number distribution produces random numbers x, b₀ ≤ x < b_n , distributed over each subinterval [ b_i, b_i+1 ) according to the probability density function $% p(x\,|\,b_0,\ldots,b_n,\;\rho_0,\ldots,\rho_n) = \rho_i \cdot {\frac{b_{i+1} - x}{b_{i+1} - b_i}} + \rho_{i+1} \cdot {\frac{x - b_i}{b_{i+1} - b_i}} \; \mbox{,} \mbox{ for } b_i \le x < b_{i+1} \; \mbox{.}$

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, …, n-1 . Unless specified otherwise, the remaining n+1 distribution parameters are calculated as ρ_k = w_k / S for k = 0, …, 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 \sum_{k=0}^{n-1} (w_k + w_{k+1}) \cdot (b_{k+1} - b_k) \; \mbox{.}$

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

 // 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 URNG>
   result_type operator()(URNG& g);
 template<class URNG>
   result_type operator()(URNG& 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 , ρ₀ = ρ₁ = 1 , b₀ = 0 , and b₁ = 1 .

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

Requires: InputIteratorB and InputIteratorW shall each satisfy the requirements of an input iterator (Table [tab:iterator.input.requirements]) type. Moreover, iterator_traits<InputIteratorB>::value_type and iterator_traits<InputIteratorW>::value_type shall each denote a type that is convertible to double. If firstB == lastB or ++firstB == lastB, let n = 1 , ρ₀ = ρ₁ = 1 , b₀ = 0 , and b₁ = 1 . Otherwise, [firstB, lastB) shall form a sequence b of length n+1, the length of the sequence w starting from firstW shall be at least n+1, and any w_k for k ≥ n+1 shall be 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);

Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: If bl.size() < 2, let n = 1, ρ₀ = ρ₁ = 1 , b₀ = 0 , and b₁ = 1 . Otherwise, let [bl.begin(), bl.end()) form a sequence b₀, …, b_n , and let w_k = fw(b_k) for k = 0, …, n .

Complexity: The number of invocations of fw shall not exceed n+1.

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

Effects: Constructs a piecewise_linear_distribution object with parameters taken or calculated from the following values: Let b_k = xmin + k · δ for k = 0, …, n , and w_k = fw(b_k) for k = 0, …, n .

Complexity: The number of invocations of fw shall 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, …, 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, …, n .

26 Numerics library [numerics]

26.5 Random number generation [rand]

26.5.8 Random number distribution class templates [rand.dist]

26.5.8.6 Sampling distributions [rand.dist.samp]

26.5.8.6.1 Class template discrete_distribution [rand.dist.samp.discrete]

26.5.8.6.2 Class template piecewise_constant_distribution [rand.dist.samp.pconst]

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