random

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

Classes

Random number engines
linear_congruential_engine (C++11)	implements linear congruential algorithm (class template)
mersenne_twister_engine (C++11)	implements Mersenne twister algorithm (class template)
subtract_with_carry_engine (C++11)	implements subtract with carry (a lagged Fibonacci) algorithm (class template)
Random number engine adaptors
discard_block_engine (C++11)	discards some output of a random number engine (class template)
independent_bits_engine (C++11)	packs the output of a random number engine into blocks of specified number of bits (class template)
shuffle_order_engine (C++11)	delivers the output of a random number engine in different order (class template)
Predefined generators
seed_seq (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
uniform_int_distribution (C++11)	produces integer values evenly distributed across a range (class template)
uniform_real_distribution (C++11)	produces real values evenly distributed across a range (class template)
Bernoulli distributions
bernoulli_distribution (C++11)	produces `bool` values on a Bernoulli distribution. (class)
binomial_distribution (C++11)	produces integer values on a binomial distribution. (class template)
negative_binomial_distribution (C++11)	produces integer values on a negative binomial distribution. (class template)
geometric_distribution (C++11)	produces integer values on a geometric distribution. (class template)
Poisson distributions
poisson_distribution (C++11)	produces integer values on a poisson distribution. (class template)
exponential_distribution (C++11)	produces real values on an exponential distribution. (class template)
gamma_distribution (C++11)	produces real values on an gamma distribution. (class template)
weibull_distribution (C++11)	produces real values on a Weibull distribution. (class template)
extreme_value_distribution (C++11)	produces real values on an extreme value distribution. (class template)
Normal distributions
normal_distribution (C++11)	produces real values on a standard normal (Gaussian) distribution. (class template)
lognormal_distribution (C++11)	produces real values on a lognormal distribution. (class template)
chi_squared_distribution (C++11)	produces real values on a chi-squared distribution. (class template)
cauchy_distribution (C++11)	produces real values on a Cauchy distribution. (class template)
fisher_f_distribution (C++11)	produces real values on a Fisher's F-distribution. (class template)
student_t_distribution (C++11)	produces real values on a Student's t-distribution. (class template)
Sampling distributions
discrete_distribution (C++11)	produces random integers on a discrete distribution. (class template)
piecewise_constant_distribution (C++11)	produces real values distributed on constant subintervals. (class template)
piecewise_linear_distribution (C++11)	produces real values distributed on defined subintervals. (class template)

Functions

generate_canonical

(C++11)

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

Synopsis

#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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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`

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

Links:

http://en.cppreference.com/w/cpp/header/random

doc_CPP

2025-01-10 15:47:30

Comments

random

Classes

Random number engines

Random number engine adaptors

Predefined generators

Uniform distributions

Bernoulli distributions

Poisson distributions

Normal distributions

Sampling distributions

Functions

Synopsis

Class std::linear_congruential_engine

Class std::mersenne_twister_engine

Class std::subtract_with_carry_engine

Class std::discard_block_engine

Class std::independent_bits_engine

Class std::shuffle_order_engine

Class std::random_device

Class std::seed_seq

Class std::uniform_int_distribution

Class std::bernoulli_distribution

Class std::binomial_distribution

Class std::geometric_distribution

Class std::negative_binomial_distribution

Class std::poisson_distribution

Class std::seed_seq

Class std::gamma_distribution

Class std::weibull_distribution

Class std::extreme_value_distribution

Class std::normal_distribution

Class std::lognormal_distribution

Class std::chi_squared_distribution

Class std::cauchy_distribution

Class std::fisher_f_distribution

Class std::student_t_distribution

Class std::discrete_distribution

Class std::piecewise_constant_distribution

Class std::piecewise_linear_distribution

Class `std::linear_congruential_engine`

Class `std::mersenne_twister_engine`

Class `std::subtract_with_carry_engine`

Class `std::discard_block_engine`

Class `std::independent_bits_engine`

Class `std::shuffle_order_engine`

Class `std::random_device`

Class `std::seed_seq`

Class `std::uniform_int_distribution`

Class `std::bernoulli_distribution`

Class `std::binomial_distribution`

Class `std::geometric_distribution`

Class `std::negative_binomial_distribution`

Class `std::poisson_distribution`

Class `std::seed_seq`

Class `std::gamma_distribution`

Class `std::weibull_distribution`

Class `std::extreme_value_distribution`

Class `std::normal_distribution`

Class `std::lognormal_distribution`

Class `std::chi_squared_distribution`

Class `std::cauchy_distribution`

Class `std::fisher_f_distribution`

Class `std::student_t_distribution`

Class `std::discrete_distribution`

Class `std::piecewise_constant_distribution`

Class `std::piecewise_linear_distribution`