MENU
Edit
In Place Editing Advanced Editing

random

This header is part of the pseudo-random number generation library.

Classes

Random number engines
(C++11)
 implements linear congruential algorithm
(class template)
(C++11)
 implements Mersenne twister algorithm
(class template)
(C++11)
 implements subtract with carry (a lagged Fibonacci) algorithm
(class template)
Random number engine adaptors
(C++11)
 discards some output of a random number engine
(class template)
(C++11)
 packs the output of a random number engine into blocks of specified number of bits
(class template)
(C++11)
 delivers the output of a random number engine in different order
(class template)
Predefined generators
(C++11)
 general-purpose bias-eliminating scrambled seed sequence generator
(class)
minstd_rand0 std::linear_congruential_engine<std::uint_fast32_t, 16807, 0, 2147483647>

Discovered in 1969 by Lewis, Goodman and Miller, adopted as "Minimal standard" in 1988 by Park and Miller.
minstd_rand std::linear_congruential_engine<std::uint_fast32_t, 48271, 0, 2147483647>

Newer "Minimum standard", recommended by Park, Miller, and Stockmeyer in 1993.
mt19937

std::mersenne_twister_engine<std::uint_fast32_t, 32, 624, 397, 31,
0x9908b0df, 11,
0xffffffff, 7,
0x9d2c5680, 15,
0xefc60000, 18, 1812433253>
32-bit Mersenne Twister by Matsumoto and Nishimura, 1998.
mt19937_64

std::mersenne_twister_engine<std::uint_fast64_t, 64, 312, 156, 31,
0xb5026f5aa96619e9, 29,
0x5555555555555555, 17,
0x71d67fffeda60000, 37,
0xfff7eee000000000, 43, 6364136223846793005>
64-bit Mersenne Twister by Matsumoto and Nishimura, 2000.
ranlux24_base std::subtract_with_carry_engine<std::uint_fast32_t, 24, 10, 24>
ranlux48_base std::subtract_with_carry_engine<std::uint_fast64_t, 48, 5, 12>
ranlux24 std::discard_block_engine<std::ranlux24_base, 223, 23>

24-bit RANLUX generator by Martin Lüscher and Fred James, 1994.
ranlux48 std::discard_block_engine<std::ranlux48_base, 389, 11>

48-bit RANLUX generator by Martin Lüscher and Fred James, 1994.
knuth_b std::shuffle_order_engine<std::minstd_rand0, 256>
default_random_engine implementation-defined
Uniform distributions
(C++11)
 produces integer values evenly distributed across a range
(class template)
(C++11)
 produces real values evenly distributed across a range
(class template)
Bernoulli distributions
(C++11)
 produces bool values on a Bernoulli distribution.
(class)
(C++11)
 produces integer values on a binomial distribution.
(class template)
(C++11)
 produces integer values on a negative binomial distribution.
(class template)
(C++11)
 produces integer values on a geometric distribution.
(class template)
Poisson distributions
(C++11)
 produces integer values on a poisson distribution.
(class template)
(C++11)
 produces real values on an exponential distribution.
(class template)
(C++11)
 produces real values on an gamma distribution.
(class template)
(C++11)
 produces real values on a Weibull distribution.
(class template)
(C++11)
 produces real values on an extreme value distribution.
(class template)
Normal distributions
(C++11)
 produces real values on a standard normal (Gaussian) distribution.
(class template)
(C++11)
 produces real values on a lognormal distribution.
(class template)
(C++11)
 produces real values on a chi-squared distribution.
(class template)
(C++11)
 produces real values on a Cauchy distribution.
(class template)
(C++11)
 produces real values on a Fisher's F-distribution.
(class template)
(C++11)
 produces real values on a Student's t-distribution.
(class template)
Sampling distributions
(C++11)
 produces random integers on a discrete distribution.
(class template)
(C++11)
 produces real values distributed on constant subintervals.
(class template)
(C++11)
 produces real values distributed on defined subintervals.
(class template)

Functions

(C++11)
 evenly distributes real values of given precision across [0, 1)
(function template)

Synopsis

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
#include <initializer_list>
namespace std {
    // class template linear_congruential_engine
    template<class UIntType, UIntType a, UIntType c, UIntType m>
        class linear_congruential_engine;
  
    // class template mersenne_twister_engine
    template<class UIntType, size_t w, size_t n, size_t m, size_t r,
             UIntType a, size_t u, UintType d, size_t s,
             UIntType b, size_t t,
             UIntType c, size_t l, UintType f>
     class mersenne_twister_engine;
  
    // class template subtract_with_carry_engine
    template<class UIntType, size_t w, size_t s, size_t r>
        class subtract_with_carry_engine;
  
    // class template discard_block_engine
    template<class Engine, size_t p, size_t r>
        class discard_block_engine;
  
    // class template independent_bits_engine
    template<class Engine, size_t w, class UIntType>
        class independent_bits_engine;
  
    // class template shuffle_order_engine
    template<class Engine, size_t k>
        class shuffle_order_engine;
  
    // engines and engine adaptors with predefined parameters
    typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
        minstd_rand0;
    typedef  linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
        minstd_rand;
    typedef  mersenne_twister_engine<uint_fast32_t,
            32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,
            0xefc60000,18,1812433253>
        mt19937;
    typedef mersenne_twister_engine<uint_fast64_t,
                64,312,156,31,0xb5026f5aa96619e9,29,
                0x5555555555555555,17,
                0x71d67fffeda60000,37,
                0xfff7eee000000000,43,
                6364136223846793005>
        mt19937_64;
    typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
        ranlux24_base;
    typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
        ranlux48_base;
    typedef  discard_block_engine<ranlux24_base, 223, 23>
        ranlux24;
    typedef discard_block_engine<ranlux48_base, 389, 11>
        ranlux48;
    typedef  shuffle_order_engine<minstd_rand0,256>
        knuth_b;
    typedef /*implementation-defined*/ default_random_engine;
  
    // class random_device
    class random_device;
  
    // class seed_seq
    class seed_seq;
  
    // function template generate_canonical
    template<class RealType, size_t bits, class URNG>
        RealType generate_canonical(URNG& g);
  
    // class template uniform_int_distribution
    template<class IntType = int>
        class uniform_int_distribution;
  
    // class template uniform_real_distribution
    template<class RealType = double>
        class uniform_real_distribution;
  
    // class bernoulli_distribution
    class bernoulli_distribution;
  
    // class template binomial_distribution
    template<class IntType = int>
        class binomial_distribution;
  
    // class template geometric_distribution
    template<class IntType = int>
        class geometric_distribution;
  
    // class template negative_binomial_distribution
    template<class IntType = int>
        class negative_binomial_distribution;
  
    // class template poisson_distribution
    template<class IntType = int>
        class poisson_distribution;
  
    // class template exponential_distribution
    template<class RealType = double>
        class exponential_distribution;
  
    // class template gamma_distribution
    template<class RealType = double>
        class gamma_distribution;
  
    // class template weibull_distribution
    template<class RealType = double>
        class weibull_distribution;
  
    // class template extreme_value_distribution
    template<class RealType = double>
        class extreme_value_distribution;
  
    // class template normal_distribution
    template<class RealType = double>
    class normal_distribution;
  
    // class template lognormal_distribution
    template<class RealType = double>
        class lognormal_distribution;
  
    // class template chi_squared_distribution
    template<class RealType = double>
        class chi_squared_distribution;
  
    // class template cauchy_distribution
    template<class RealType = double>
        class cauchy_distribution;
  
    // class template fisher_f_distribution
    template<class RealType = double>
        class fisher_f_distribution;
  
    // class template student_t_distribution
    template<class RealType = double>
        class student_t_distribution;
  
    // class template discrete_distribution
    template<class IntType = int>
        class discrete_distribution;
  
    // class template piecewise_constant_distribution
    template<class RealType = double>
        class piecewise_constant_distribution;
  
    // class template piecewise_linear_distribution
    template<class RealType = double>
        class piecewise_linear_distribution;
} // namespace std

Class std::linear_congruential_engine

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
template<class UIntType, UIntType a, UIntType c, UIntType m>
class linear_congruential_engine
{
public:
    // types
    typedef UIntType result_type;
  
    // engine characteristics
    static constexpr result_type multiplier = a;
    static constexpr result_type increment = c;
    static constexpr result_type modulus = m;
    static constexpr result_type min() { return c == 0u ? 1u: 0u };
    static constexpr result_type max() { return m - 1u };
    static constexpr result_type default_seed = 1u;
  
    // constructors and seeding functions
    explicit linear_congruential_engine(result_type s = default_seed);
    template<class Sseq> explicit linear_congruential_engine(Sseq& q);
        void seed(result_type s = default_seed);
    template<class Sseq> void seed(Sseq& q);
  
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
};

Class std::mersenne_twister_engine

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
31
32
33
34
35
36
37
38
template<class UIntType, size_t w, size_t n, size_t m, size_t r,
        UIntType a, size_t u, UIntType d, size_t s,
        UIntType b, size_t t,
        UIntType c, size_t l, UIntType f>
class mersenne_twister_engine
{
public:
    // types
    typedef UIntType result_type;
  
    // engine characteristics
    static constexpr size_t word_size = w;
    static constexpr size_t state_size = n;
    static constexpr size_t shift_size = m;
    static constexpr size_t mask_bits = r;
    static constexpr UIntType xor_mask = a;
    static constexpr size_t tempering_u = u;
    static constexpr UIntType tempering_d = d;
    static constexpr size_t tempering_s = s;
    static constexpr UIntType tempering_b = b;
    static constexpr size_t tempering_t = t;
    static constexpr UIntType tempering_c = c;
    static constexpr size_t tempering_l = l;
    static constexpr UIntType initialization_multiplier = f;
    static constexpr result_type min () { return 0; }
    static constexpr result_type max() { return 2w − 1; }
    static constexpr result_type default_seed = 5489u;
  
    // constructors and seeding functions
    explicit mersenne_twister_engine(result_type value = default_seed);
    template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
        void seed(result_type value = default_seed);
    template<class Sseq> void seed(Sseq& q);
  
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
};

Class std::subtract_with_carry_engine

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
template<class UIntType, size_t w, size_t s, size_t r>
class subtract_with_carry_engine
{
public:
    // types
    typedef UIntType result_type;
  
    // engine characteristics
    static constexpr size_t word_size = w;
    static constexpr size_t short_lag = s;
    static constexpr size_t long_lag = r;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return m − 1; }
    static constexpr result_type default_seed = 19780503u;
  
    // constructors and seeding functions
    explicit subtract_with_carry_engine(result_type value = default_seed);
    template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
        void seed(result_type value = default_seed);
    template<class Sseq> void seed(Sseq& q);
  
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
};

Class std::discard_block_engine

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
31
32
33
template<class Engine, size_t p, size_t r>
class discard_block_engine
{
public:
    // types
    typedef typename Engine::result_type result_type;
  
    // engine characteristics
    static constexpr size_t block_size = p;
    static constexpr size_t used_block = r;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr result_type max() { return Engine::max(); }
  
    // constructors and seeding functions
    discard_block_engine();
    explicit discard_block_engine(const Engine& e);
    explicit discard_block_engine(Engine&& e);
    explicit discard_block_engine(result_type s);
    template<class Sseq> explicit discard_block_engine(Sseq& q);
    void seed();
    void seed(result_type s);
    template<class Sseq> void seed(Sseq& q);
  
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
  
    // property functions
    const Engine& base() const noexcept { return e; };
private:
    Engine e; // exposition only
    int n; // exposition only
};

Class std::independent_bits_engine

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
31
template<class Engine, size_t w, class UIntType>
class independent_bits_engine
{
public:
    // types
    typedef UIntType result_type;
  
    // engine characteristics
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return 2w - 1; }
  
    // constructors and seeding functions
    independent_bits_engine();
    explicit independent_bits_engine(const Engine& e);
    explicit independent_bits_engine(Engine&& e);
    explicit independent_bits_engine(result_type s);
    template<class Sseq> explicit independent_bits_engine(Sseq& q);
    void seed();
    void seed(result_type s);
    template<class Sseq> void seed(Sseq& q);
  
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
  
    // property functions
    const Engine& base() const noexcept { return e; };
  
private:
    Engine e; // exposition only
};

Class std::shuffle_order_engine

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
31
32
33
34
template<class Engine, size_t k>
class shuffle_order_engine
{
public:
    // types
    typedef typename Engine::result_type result_type;
  
    // engine characteristics
    static constexpr size_t table_size = k;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr result_type max() { return Engine::max(); }
  
    // constructors and seeding functions
    shuffle_order_engine();
    explicit shuffle_order_engine(const Engine& e);
    explicit shuffle_order_engine(Engine&& e);
    explicit shuffle_order_engine(result_type s);
    template<class Sseq> explicit shuffle_order_engine(Sseq& q);
    void seed();
    void seed(result_type s);
    template<class Sseq> void seed(Sseq& q);
  
    // generating functions
    result_type operator()();
    void discard(unsigned long long z);
  
    // property functions
    const Engine& base() const noexcept { return e; };
  
private:
    Engine e;           // exposition only
    result_type Y;      // exposition only
    result_type V[k];   // exposition only
};

Class std::random_device

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class random_device
{
public:
    // types
    typedef unsigned int result_type;
  
    // generator characteristics
    static constexpr result_type min() { return numeric_limits<result_type>::min(); }
    static constexpr result_type max() { return numeric_limits<result_type>::max(); }
  
    // constructors
    explicit random_device(const string& token = implementation-defined);
  
    // generating functions
    result_type operator()();
  
    // property functions
    double entropy() const noexcept;
  
    // no copy functions
    random_device(const random_device& ) = delete;
    void operator=(const random_device& ) = delete;
};

Class std::seed_seq

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
class seed_seq
{
public:
    // types
    typedef uint_least32_t result_type;
  
    // constructors
    seed_seq();
    template<class T>
    seed_seq(initializer_list<T> il);
    template<class InputIterator>
    seed_seq(InputIterator begin, InputIterator end);
  
    // generating functions
    template<class RandomAccessIterator>
    void generate(RandomAccessIterator begin, RandomAccessIterator end);
  
    // property functions
    size_t size() const;
    template<class OutputIterator>
    void param(OutputIterator dest) const;
  
    // no copy functions
    seed_seq(const seed_seq& ) = delete;
    void operator=(const seed_seq& ) = delete;
  
private:
    vector<result_type> v; // exposition only
};

Class std::uniform_int_distribution

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
template<class IntType = int>
class uniform_int_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit uniform_int_distribution(IntType a = 0, IntType b = numeric_limits<IntType>::max());
    explicit uniform_int_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
    result_type a() const;
    result_type b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::bernoulli_distribution

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
class bernoulli_distribution
{
public:
    // types
    typedef bool result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit bernoulli_distribution(double p = 0.5);
    explicit bernoulli_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
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::binomial_distribution

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
template<class IntType = int>
class binomial_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit binomial_distribution(IntType t = 1, double p = 0.5);
    explicit binomial_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
    IntType t() const;
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::geometric_distribution

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
template<class IntType = int>
class geometric_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit geometric_distribution(double p = 0.5);
    explicit geometric_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
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::negative_binomial_distribution

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
template<class IntType = int>
class negative_binomial_distribution
{
public:
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
    // constructor and reset functions
    explicit negative_binomial_distribution(IntType k = 1, double p = 0.5);
    explicit negative_binomial_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
    IntType k() const;
    double p() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::poisson_distribution

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
template<class IntType = int>
class poisson_distribution
{
public:
  
    // types
    typedef IntType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit poisson_distribution(double mean = 1.0);
    explicit poisson_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
    double mean() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::seed_seq

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
template<class RealType = double>
class exponential_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit exponential_distribution(RealType lambda = 1.0);
    explicit exponential_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
    RealType lambda() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::gamma_distribution

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
template<class RealType = double>
class gamma_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit gamma_distribution(RealType alpha = 1.0, RealType beta = 1.0);
    explicit gamma_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
    RealType alpha() const;
    RealType beta() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::weibull_distribution

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
template<class RealType = double>
class weibull_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructor and reset functions
    explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0)
    explicit weibull_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
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::extreme_value_distribution

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
template<class RealType = double>
class extreme_value_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructor and reset functions
    explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0);
    explicit extreme_value_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
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::normal_distribution

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
template<class RealType = double>
class normal_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructors and reset functions
    explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0);
    explicit normal_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
    RealType mean() const;
    RealType stddev() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::lognormal_distribution

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
template<class RealType = double>
class lognormal_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructor and reset functions
    explicit lognormal_distribution(RealType m = 0.0, RealType s = 1.0);
    explicit lognormal_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
    RealType m() const;
    RealType s() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::chi_squared_distribution

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
template<class RealType = double>
class chi_squared_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructor and reset functions
    explicit chi_squared_distribution(RealType n = 1);
    explicit chi_squared_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
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::cauchy_distribution

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
template<class RealType = double>
class cauchy_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructor and reset functions
    explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0);
    explicit cauchy_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
    RealType a() const;
    RealType b() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::fisher_f_distribution

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
template<class RealType = double>
class fisher_f_distribution
{
public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructor and reset functions
    explicit fisher_f_distribution(RealType m = 1, RealType n = 1);
    explicit fisher_f_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
    RealType m() const;
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::student_t_distribution

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
template<class RealType = double>
class student_t_distribution
{
    public:
  
    // types
    typedef RealType result_type;
    typedef /*unspecified*/ param_type;
  
    // constructor and reset functions
    explicit student_t_distribution(RealType n = 1);
    explicit student_t_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
    RealType n() const;
    param_type param() const;
    void param(const param_type& parm);
    result_type min() const;
    result_type max() const;
};

Class std::discrete_distribution

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
31
32
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;
};

Class std::piecewise_constant_distribution

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
31
32
33
34
35
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;
};

Class std::piecewise_linear_distribution

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
31
32
33
34
35
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;
};
doc_CPP
doc_CPP
2025-01-10 15:47:30
Comments
Leave a Comment

Please login to continue.