##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <random>

From cppreference.com
< cpp‎ | header

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

### [edit] 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<uint_fast32_t, 16807, 0, 2147483647>
`minstd_rand` | std::linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
`mt19937` | std::mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253>
`mt19937_64` | std::mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9, 29, 0x5555555555555555, 17, 0x71d67fffeda60000, 37, 0xfff7eee000000000, 43, 6364136223846793005>
`ranlux24_base` | std::subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
`ranlux48_base` | std::subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
`ranlux24` | std::discard_block_engine<ranlux24_base, 223, 23>
`ranlux48` | std::discard_block_engine<ranlux48_base, 389, 11>
`knuth_b` | std::shuffle_order_engine<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) [edit]
##### 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)

### [edit] Functions

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

### [edit] 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

#### [edit] 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);
    };

#### [edit] 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);
    };

#### [edit] 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);
    };

#### [edit] 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
    };

#### [edit] 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
    };

#### [edit] 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
    };

#### [edit] 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;
    };

#### [edit] 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
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

#### [edit] 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;
    };

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/random&oldid=57523"