Difference between revisions of "cpp/numeric/random/piecewise linear distribution"

Latest revision as of 01:17, 23 December 2023

Defined in header `<random>`
template< class RealType = double > class piecewise_linear_distribution;		(since C++11)

std::piecewise_linear_distribution produces random floating-point numbers, which are distributed according to a linear probability density function within each of the several subintervals $\small{[b_i, b_{i+1})}$ $[b i, b i+1)$ . The distribution is such that the probability density at each interval boundary is exactly the predefined value $\small{p_i}$ $p i$ .

The probability density for any

b i \leqx<b i+1

is

p i b i+1 -x b i+1 -b i + p i+1 x-b i b i+1 -b i

, where probability densities at interval boundaries

p k

are calculated as

w k /S

where

S

is the sum of all

12 (w k +w k+1)(b k+1 -b k)

.

The set of interval boundaries $\small{b_i}$ $b i$ and the set of weights at boundaries $\small{w_i}$ $w i$ are the parameters of this distribution.

std::piecewise_linear_distribution satisfies all requirements of RandomNumberDistribution.

(constructor) (C++11)	constructs new distribution (public member function) [edit]
reset (C++11)	resets the internal state of the distribution (public member function) [edit]
Generation
operator() (C++11)	generates the next random number in the distribution (public member function) [edit]
Characteristics
intervalsdensities (C++11)	returns the distribution parameters (public member function) [edit]
param (C++11)	gets or sets the distribution parameter object (public member function) [edit]
min (C++11)	returns the minimum potentially generated value (public member function) [edit]
max (C++11)	returns the maximum potentially generated value (public member function) [edit]

[edit] Non-member functions

operator==operator!= (C++11)(C++11)(removed in C++20)	compares two distribution objects (function) [edit]
operator<<operator>> (C++11)	performs stream input and output on pseudo-random number distribution (function template) [edit]

[edit] Example

Run this code

#include <iomanip>
#include <iostream>
#include <map>
#include <random>
#include <string>
 
int main()
{
    std::random_device rd;
    std::mt19937 gen{rd()};
    // increase the probability from 0 to 5
    // remain flat from 5 to 10
    // decrease from 10 to 15 at the same rate
    std::vector<double> i{0, 5, 10, 15};
    std::vector<double> w{0, 1, 1, 0};
    std::piecewise_linear_distribution<> d{i.begin(), i.end(), w.begin()};
 
    std::map<int, int> hist;
    for (int n{}; n < 1e4; ++n)
        ++hist[d(gen)];
 
    for (auto [x, y] : hist)
        std::cout << std::setw(2) << std::setfill('0') << x
                  << ' ' << std::string(y / 100, '*') << '\n';
}

Possible output:

00 *
01 ***
02 ****
03 ******
04 *********
05 *********
06 *********
07 **********
08 *********
09 **********
10 *********
11 *******
12 ****
13 ***
14 *

@@ Line 1: / Line 1: @@
 {{cpp/title|piecewise_linear_distribution}}
-{{cpp/numeric/random/piecewise_linear_distribution/sidebar}}
+{{cpp/numeric/random/piecewise_linear_distribution/navbar}}
-{{ddcl | header=random | notes={{mark since c++11}} | 1=
+{{ddcl|header=random|since=c++11|1=
 template< class RealType = double >
 class piecewise_linear_distribution;
 }}
-{{todo}}
+{{tt|std::piecewise_linear_distribution}} produces random floating-point numbers, which are distributed according to a linear probability density function within each of the several subintervals {{mathjax-or|\(\small{[b_i, b_{i+1})}\)|[b{{su|b=i}}, b{{su|b=i+1}})}}. The distribution is such that the probability density at each interval boundary is exactly the predefined value {{mathjax-or|\(\small{p_i}\)|p{{su|b=i}}}}.
+The probability density for any {{mathjax-or|\(\small{ b_i \le x < b_{i+1} }\)|b{{su|b=i}}≤x<b{{su|b=i+1}}}} is {{mathjax-or|\(\small{p_i\frac{b_{i+1}-x}{b_{i+1}-b_i} + p_{i+1}\frac{x-b_i}{b_{i+1}-b_i} }\)|{{mfrac|p{{su|b=i}}|b{{su|b=i+1}}-x|b{{su|b=i+1}}-b{{su|b=i}}}} + {{mfrac|p{{su|b=i+1}}|x-b{{su|b=i}}|b{{su|b=i+1}}-b{{su|b=i}}}}}}, where probability densities at interval boundaries {{mathjax-or|\(\small{p_k}\)|p{{su|b=k}}}} are calculated as {{mathjax-or|\(\small{w_k/S}\)|w{{su|b=k}}/S}} where {{mathjax-or|\(\small{S}\)|S}} is the sum of all {{mathjax-or|\(\small{\frac{1}{2}(w_k + w_{k+1})(b_{k+1} - b_k)}\)|{{mfrac||1|2}}(w{{su|b=k}}+w{{su|b=k+1}})(b{{su|b=k+1}}−b{{su|b=k}})}}.
+The set of interval boundaries {{mathjax-or|\(\small{b_i}\)|b{{su|b=i}}}} and the set of weights at boundaries {{mathjax-or|\(\small{w_i}\)|w{{su|b=i}}}} are the parameters of this distribution.
+{{ttt|std::piecewise_linear_distribution}} satisfies all requirements of {{named req|RandomNumberDistribution}}.
+===Template parameters===
+{{par begin}}
+{{cpp/numeric/random/param_list|RealType}}
+{{par end}}
 ===Member types===
-{{tdcl list begin}}
+{{dsc begin}}
-{{tdcl list hitem | Member type | Definition}}
+{{dsc hitem|Member type|Definition}}
-{{tdcl list item | {{tt|result_type}} | {{cpp|RealType}}}}
+{{dsc|{{tt|result_type}} {{mark c++11}}|{{co|RealType}}}}
-{{tdcl list item | {{tt|param_type}} | the type of the parameter set, unspecified}}
+{{cpp/numeric/random/param_type}}
-{{tdcl list end}}
+{{dsc end}}
 ===Member functions===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list constructor | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc constructor|piecewise_linear_distribution}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list reset | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc reset|piecewise_linear_distribution}}
-{{dcl list h2 | Generation}}
+{{dsc h2|Generation}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list operator() | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc operator()|piecewise_linear_distribution}}
-{{dcl list h2 | Characteristics}}
+{{dsc h2|Characteristics}}
-{{dcl list todo}}
+{{dsc inc|cpp/numeric/random/piecewise_linear_distribution/dsc params}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list param | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc param|piecewise_linear_distribution}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list min | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc min|piecewise_linear_distribution}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list max | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc max|piecewise_linear_distribution}}
-{{dcl list end}}
+{{dsc end}}
 ===Non-member functions===
-{{dcl list begin}}
+{{dsc begin}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list operator_cmp | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc operator_cmp|piecewise_linear_distribution}}
-{{dcl list template | cpp/numeric/random/distribution/dcl list operator_ltltgtgt | piecewise_linear_distribution}}
+{{dsc inc|cpp/numeric/random/distribution/dsc operator_ltltgtgt|piecewise_linear_distribution}}
-{{dcl list end}}
+{{dsc end}}
 ===Example===
-{{example cpp
+{{example
- | code=
+|code=
-  | output=
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <random>
+#include <string>
+int main()
+{
+    std::random_device rd;
+    std::mt19937 gen{rd()};
+    // increase the probability from 0 to 5
+    // remain flat from 5 to 10
+    // decrease from 10 to 15 at the same rate
+    std::vector<double> i{0, 5, 10, 15};
+    std::vector<double> w{0, 1, 1, 0};
+    std::piecewise_linear_distribution<> d{i.begin(), i.end(), w.begin()};
+    std::map<int, int> hist;
+    for (int n{}; n < 1e4; ++n)
+        ++hist[d(gen)];
+    for (auto [x, y] : hist)
+        std::cout << std::setw(2) << std::setfill('0') << x
+                  << ' ' << std::string(y / 100, '*') << '\n';
+}
+|p=true
+|output=
+*
+***
+****
+******
+*********
+*********
+*********
+**********
+*********
+**********
+*********
+*******
+****
+***
+*
 }}
+{{langlinks|de|es|fr|it|ja|pt|ru|zh}}

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Execution support library (C++26)
Technical specifications
Symbols index
External libraries

Member functions
piecewise_linear_distribution::piecewise_linear_distribution
piecewise_linear_distribution::reset
Generation
piecewise_linear_distribution::operator()
Characteristics
piecewise_linear_distribution::intervalspiecewise_linear_distribution::densities
piecewise_linear_distribution::param
piecewise_linear_distribution::min
piecewise_linear_distribution::max
Non-member functions
operator==operator!= (C++11)(C++11)(until C++20)
operator<<operator>> (C++11)(C++11)

Member type	Definition
`result_type` (C++11)	RealType
`param_type` (C++11)	the type of the parameter set, see RandomNumberDistribution.

cppreference.com

Namespaces

Variants

Views

Actions

Difference between revisions of "cpp/numeric/random/piecewise linear distribution"

Latest revision as of 01:17, 23 December 2023

Contents

[edit] Template parameters

[edit] Member types

[edit] Member functions

Generation

Characteristics

[edit] Non-member functions

[edit] Example

Navigation

Toolbox