Standard library header  (C++11) (original) (raw)

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

[edit] Synopsis

#include   namespace std { // uniform random bit generator requirements template concept uniform_random_bit_generator = /* see description /; // freestanding   // class template linear_congruential_engine template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine; // partially freestanding   // 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; // partially freestanding   // class template subtract_with_carry_engine template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine; // partially freestanding   // class template discard_block_engine template<class Engine, size_t p, size_t r> class discard_block_engine; // partially freestanding   // class template independent_bits_engine template<class Engine, size_t w, class UIntType> class independent_bits_engine; // partially freestanding   // class template shuffle_order_engine template<class Engine, size_t k> class shuffle_order_engine;   // class template philox_engine template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts> class philox_engine; // partially freestanding   // engines and engine adaptors with predefined parameters using minstd_rand0 = / see description /; // freestanding using minstd_rand = / see description /; // freestanding using mt19937 = / see description /; // freestanding using mt19937_64 = / see description /; // freestanding using ranlux24_base = / see description /; // freestanding using ranlux48_base = / see description /; // freestanding using ranlux24 = / see description /; // freestanding using ranlux48 = / see description /; // freestanding using knuth_b = / see description /; using philox4x32 = / see description /; // freestanding using philox4x64 = / see description /; // freestanding   using default_random_engine = / see description */;   // class random_device class random_device;   // class seed_seq class seed_seq;   // function template generate_canonical template<class RealType, size_t digits, class URBG> RealType generate_canonical(URBG& g);   namespace ranges { // generate_random template<class R, class G> requires output_range<R, invoke_result_t<G&>> && uniform_random_bit_generator<remove_cvref_t> constexpr borrowed_iterator_t generate_random(R&& r, G&& g);   template<class G, output_iterator<invoke_result_t<G&>> O, sentinel_for S> requires uniform_random_bit_generator<remove_cvref_t> constexpr O generate_random(O first, S last, G&& g);   template<class R, class G, class D> requires output_range<R, invoke_result_t<D&, G&>> && invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t> && is_arithmetic_v<invoke_result_t<D&, G&>> constexpr borrowed_iterator_t generate_random(R&& r, G&& g, D&& d);   template<class G, class D, output_iterator<invoke_result_t<D&, G&>> O, sentinel_for S> requires invocable<D&, G&> && uniform_random_bit_generator<remove_cvref_t> && is_arithmetic_v<invoke_result_t<D&, G&>> constexpr O generate_random(O first, S last, G&& g, D&& d); }   // class template uniform_int_distribution template class uniform_int_distribution; // partially freestanding   // class template uniform_real_distribution template class uniform_real_distribution;   // class bernoulli_distribution class bernoulli_distribution;   // class template binomial_distribution template class binomial_distribution;   // class template geometric_distribution template class geometric_distribution;   // class template negative_binomial_distribution template class negative_binomial_distribution;   // class template poisson_distribution template class poisson_distribution;   // class template exponential_distribution template class exponential_distribution;   // class template gamma_distribution template class gamma_distribution;   // class template weibull_distribution template class weibull_distribution;   // class template extreme_value_distribution template class extreme_value_distribution;   // class template normal_distribution template class normal_distribution;   // class template lognormal_distribution template class lognormal_distribution;   // class template chi_squared_distribution template class chi_squared_distribution;   // class template cauchy_distribution template class cauchy_distribution;   // class template fisher_f_distribution template class fisher_f_distribution;   // class template student_t_distribution template class student_t_distribution;   // class template discrete_distribution template class discrete_distribution;   // class template piecewise_constant_distribution template class piecewise_constant_distribution;   // class template piecewise_linear_distribution template class piecewise_linear_distribution; }

[edit] Concept uniform_random_bit_generator

namespace std { template concept uniform_random_bit_generator = invocable<G&> && unsigned_integral<invoke_result_t<G&>> && requires { { G::min() } -> same_as<invoke_result_t<G&>>; { G::max() } -> same_as<invoke_result_t<G&>>; requires bool_constant<(G::min() < G::max())>::value; }; }

[edit] Class template std::linear_congruential_engine

namespace std { template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine { public: // types using result_type = UIntType;   // 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 linear_congruential_engine() : linear_congruential_engine(default_seed) { } explicit linear_congruential_engine(result_type s); template explicit linear_congruential_engine(Sseq& q); void seed(result_type s = default_seed); template void seed(Sseq& q);   // equality operators friend bool operator==(const linear_congruential_engine& x, const linear_congruential_engine& y);   // generating functions result_type operator()(); void discard(unsigned long long z);   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // hosted const linear_congruential_engine& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // hosted linear_congruential_engine& x); }; }

[edit] Class template std::mersenne_twister_engine

namespace std { 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 using result_type = UIntType;   // 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 /2^w - 1/; } static constexpr result_type default_seed = 5489u;   // constructors and seeding functions mersenne_twister_engine() : mersenne_twister_engine(default_seed) { } explicit mersenne_twister_engine(result_type value); template explicit mersenne_twister_engine(Sseq& q); void seed(result_type value = default_seed); template void seed(Sseq& q);   // equality operators friend bool operator==(const mersenne_twister_engine& x, const mersenne_twister_engine& y);   // generating functions result_type operator()(); void discard(unsigned long long z);   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // hosted const mersenne_twister_engine& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // hosted mersenne_twister_engine& x); }; }

[edit] Class template std::subtract_with_carry_engine

namespace std { template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine { public: // types using result_type = UIntType;   // 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 uint_least32_t default_seed = 19780503u;   // constructors and seeding functions subtract_with_carry_engine() : subtract_with_carry_engine(0u) { } explicit subtract_with_carry_engine(result_type value); template explicit subtract_with_carry_engine(Sseq& q); void seed(result_type value = 0u); template void seed(Sseq& q);   // equality operators friend bool operator==(const subtract_with_carry_engine& x, const subtract_with_carry_engine& y);   // generating functions result_type operator()(); void discard(unsigned long long z);   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // hosted const subtract_with_carry_engine& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // hosted subtract_with_carry_engine& x); }; }

[edit] Class template std::philox_engine

namespace std { template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts> class philox_engine { static constexpr size_t /array-size/ = n / 2; // exposition only public: // types using result_type = UIntType;   // engine characteristics static constexpr size_t word_size = w; static constexpr size_t word_count = n; static constexpr size_t round_count = r; static constexpr array<result_type, /*array-size*/> multipliers; static constexpr array < result_type, @exposition onlyid { array - size > } @round_consts; static constexpr result_type min() { return 0; } static constexpr result_type max() { return m - 1; } static constexpr result_type default_seed = 20111115u;   // constructors and seeding functions philox_engine() : philox_engine(default_seed) { } explicit philox_engine(result_type value); template explicit philox_engine(Sseq& q); void seed(result_type value = default_seed); template void seed(Sseq& q);   void set_counter(const array<result_type, n>& counter);   // equality operators friend bool operator==(const philox_engine& x, const philox_engine& y);   // generating functions result_type operator()(); void discard(unsigned long long z);   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // hosted const philox_engine& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // hosted philox_engine& x); }; }

[edit] Class template std::discard_block_engine

namespace std { template<class Engine, size_t p, size_t r> class discard_block_engine { public: // types using result_type = typename Engine::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 explicit discard_block_engine(Sseq& q); void seed(); void seed(result_type s); template void seed(Sseq& q);   // equality operators friend bool operator==(const discard_block_engine& x, const discard_block_engine& y);   // generating functions result_type operator()(); void discard(unsigned long long z);   // property functions const Engine& base() const noexcept { return e; }   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // hosted const discard_block_engine& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // hosted discard_block_engine& x);   private: Engine e; // exposition only size_t n; // exposition only }; }

[edit] Class template std::independent_bits_engine

namespace std { template<class Engine, size_t w, class UIntType> class independent_bits_engine { public: // types using result_type = UIntType;   // engine characteristics static constexpr result_type min() { return 0; } static constexpr result_type max() { return /2^w - 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 explicit independent_bits_engine(Sseq& q); void seed(); void seed(result_type s); template void seed(Sseq& q);   // equality operators friend bool operator==(const independent_bits_engine& x, const independent_bits_engine& y);   // generating functions result_type operator()(); void discard(unsigned long long z);   // property functions const Engine& base() const noexcept { return e; }   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // hosted const independent_bits_engine& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // hosted independent_bits_engine& x);   private: Engine e; // exposition only }; }

[edit] Class template std::shuffle_order_engine

namespace std { template<class Engine, size_t k> class shuffle_order_engine { public: // types using result_type = typename Engine::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 explicit shuffle_order_engine(Sseq& q); void seed(); void seed(result_type s); template void seed(Sseq& q);   // equality operators friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);   // generating functions result_type operator()(); void discard(unsigned long long z);   // property functions const Engine& base() const noexcept { return e; }   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const shuffle_order_engine& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, shuffle_order_engine& x);   private: Engine e; // exposition only result_type V[k]; // exposition only result_type Y; // exposition only }; }

[edit] Engines and engine adaptors with predefined parameters

namespace std { using minstd_rand0 = linear_congruential_engine<uint_fast32_t, 16'807, 0, 2'147'483'647>; using minstd_rand = linear_congruential_engine<uint_fast32_t, 48'271, 0, 2'147'483'647>; using mt19937 = mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31, 0x9908'b0df, 11, 0xffff'ffff, 7, 0x9d2c'5680, 15, 0xefc6'0000, 18, 1'812'433'253>; //' using mt19937_64 = mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31, 0xb502'6f5a'a966'19e9, 29, 0x5555'5555'5555'5555, 17, 0x71d6'7fff'eda6'0000, 37, 0xfff7'eee0'0000'0000, 43, 6'364'136'223'846'793'005>; using ranlux24_base = subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>; using ranlux48_base = subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>; using ranlux24 = discard_block_engine<ranlux24_base, 223, 23>; using ranlux48 = discard_block_engine<ranlux48_base, 389, 11>; using knuth_b = shuffle_order_engine<minstd_rand0, 256>; using default_random_engine = /* implementation-defined */; using philox4x32 = philox_engine<uint_fast32_t, 32, 4, 10, 0xD2511F53, 0x9E3779B9, 0xCD9E8D57, 0xBB67AE85>; using philox4x64 = philox_engine<uint_fast64_t, 64, 4, 10, 0xD2E7470EE14C6C93, 0x9E3779B97F4A7C15, 0xCA5A826395121157, 0xBB67AE8584CAA73B>; }

[edit] Class std::random_device

namespace std { class random_device { public: // types using result_type = unsigned int;   // generator characteristics static constexpr result_type min() { return numeric_limits::min(); } static constexpr result_type max() { return numeric_limits::max(); }   // constructors random_device() : random_device(/* implementation-defined */) { } explicit random_device(const string& token);   // 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

namespace std { class seed_seq { public: // types using result_type = uint_least32_t;   // constructors seed_seq() noexcept; template seed_seq(initializer_list il); template seed_seq(InputIter begin, InputIter end);   // generating functions template void generate(RandomAccessIter begin, RandomAccessIter end);   // property functions size_t size() const noexcept; template void param(OutputIter dest) const;   // no copy functions seed_seq(const seed_seq&) = delete; void operator=(const seed_seq&) = delete;   private: vector v; // exposition only }; }

[edit] Class template std::uniform_int_distribution

namespace std { template class uniform_int_distribution { public: // types using result_type = IntType; using param_type = /* unspecified */;   // constructors and reset functions uniform_int_distribution() : uniform_int_distribution(0) { } explicit uniform_int_distribution(IntType a, IntType b = numeric_limits::max()); explicit uniform_int_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const uniform_int_distribution& x, const uniform_int_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // hosted const uniform_int_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // hosted uniform_int_distribution& x); }; }

[edit] Class template std::uniform_real_distribution

namespace std { template class uniform_real_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructors and reset functions uniform_real_distribution() : uniform_real_distribution(0.0) { } explicit uniform_real_distribution(RealType a, RealType b = 1.0); explicit uniform_real_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const uniform_real_distribution& x, const uniform_real_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const uniform_real_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, uniform_real_distribution& x); }; }

[edit] Class std::bernoulli_distribution

namespace std { class bernoulli_distribution { public: // types using result_type = bool; using param_type = /* unspecified */;   // constructors and reset functions bernoulli_distribution() : bernoulli_distribution(0.5) { } explicit bernoulli_distribution(double p); explicit bernoulli_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const bernoulli_distribution& x, const bernoulli_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const bernoulli_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, bernoulli_distribution& x); }; }

[edit] Class template std::binomial_distribution

namespace std { template class binomial_distribution { public: // types using result_type = IntType; using param_type = /* unspecified */;   // constructors and reset functions binomial_distribution() : binomial_distribution(1) { } explicit binomial_distribution(IntType t, double p = 0.5); explicit binomial_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const binomial_distribution& x, const binomial_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const binomial_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, binomial_distribution& x); }; }

[edit] Class template std::geometric_distribution

namespace std { template class geometric_distribution { public: // types using result_type = IntType; using param_type = /* unspecified */;   // constructors and reset functions geometric_distribution() : geometric_distribution(0.5) { } explicit geometric_distribution(double p); explicit geometric_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const geometric_distribution& x, const geometric_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const geometric_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, geometric_distribution& x); }; }

[edit] Class template std::negative_binomial_distribution

namespace std { template class negative_binomial_distribution { public: // types using result_type = IntType; using param_type = /* unspecified */;   // constructor and reset functions negative_binomial_distribution() : negative_binomial_distribution(1) { } explicit negative_binomial_distribution(IntType k, double p = 0.5); explicit negative_binomial_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const negative_binomial_distribution& x, const negative_binomial_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<( basic_ostream<CharT, Traits>& os, const negative_binomial_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, negative_binomial_distribution& x); }; }

[edit] Class template std::poisson_distribution

namespace std { template class poisson_distribution { public: // types using result_type = IntType; using param_type = /* unspecified */;   // constructors and reset functions poisson_distribution() : poisson_distribution(1.0) { } explicit poisson_distribution(double mean); explicit poisson_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const poisson_distribution& x, const poisson_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const poisson_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, poisson_distribution& x); }; }

[edit] Class template std::exponential_distribution

namespace std { template class exponential_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructors and reset functions exponential_distribution() : exponential_distribution(1.0) { } explicit exponential_distribution(RealType lambda); explicit exponential_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const exponential_distribution& x, const exponential_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const exponential_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, exponential_distribution& x); }; }

[edit] Class template std::gamma_distribution

namespace std { template class gamma_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructors and reset functions gamma_distribution() : gamma_distribution(1.0) { } explicit gamma_distribution(RealType alpha, RealType beta = 1.0); explicit gamma_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const gamma_distribution& x, const gamma_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const gamma_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, gamma_distribution& x); }; }

[edit] Class template std::weibull_distribution

namespace std { template class weibull_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions weibull_distribution() : weibull_distribution(1.0) { } explicit weibull_distribution(RealType a, RealType b = 1.0); explicit weibull_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const weibull_distribution& x, const weibull_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const weibull_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, weibull_distribution& x); }; }

[edit] Class template std::extreme_value_distribution

namespace std { template class extreme_value_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions extreme_value_distribution() : extreme_value_distribution(0.0) { } explicit extreme_value_distribution(RealType a, RealType b = 1.0); explicit extreme_value_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const extreme_value_distribution& x, const extreme_value_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const extreme_value_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, extreme_value_distribution& x); }; }

[edit] Class template std::normal_distribution

namespace std { template class normal_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructors and reset functions normal_distribution() : normal_distribution(0.0) { } explicit normal_distribution(RealType mean, RealType stddev = 1.0); explicit normal_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const normal_distribution& x, const normal_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const normal_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, normal_distribution& x); }; }

[edit] Class template std::lognormal_distribution

namespace std { template class lognormal_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions lognormal_distribution() : lognormal_distribution(0.0) { } explicit lognormal_distribution(RealType m, RealType s = 1.0); explicit lognormal_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const lognormal_distribution& x, const lognormal_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const lognormal_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, lognormal_distribution& x); }; }

[edit] Class template std::chi_squared_distribution

namespace std { template class chi_squared_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions chi_squared_distribution() : chi_squared_distribution(1.0) { } explicit chi_squared_distribution(RealType n); explicit chi_squared_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const chi_squared_distribution& x, const chi_squared_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const chi_squared_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, chi_squared_distribution& x); }; }

[edit] Class template std::cauchy_distribution

namespace std { template class cauchy_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions cauchy_distribution() : cauchy_distribution(0.0) { } explicit cauchy_distribution(RealType a, RealType b = 1.0); explicit cauchy_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const cauchy_distribution& x, const cauchy_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const cauchy_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, cauchy_distribution& x); }; }

[edit] Class template std::fisher_f_distribution

namespace std { template class fisher_f_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions fisher_f_distribution() : fisher_f_distribution(1.0) { } explicit fisher_f_distribution(RealType m, RealType n = 1.0); explicit fisher_f_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const fisher_f_distribution& x, const fisher_f_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const fisher_f_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, fisher_f_distribution& x); }; }

[edit] Class template std::student_t_distribution

namespace std { template class student_t_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions student_t_distribution() : student_t_distribution(1.0) { } explicit student_t_distribution(RealType n); explicit student_t_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const student_t_distribution& x, const student_t_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& 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;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const student_t_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, student_t_distribution& x); }; }

[edit] Class template std::discrete_distribution

namespace std { template class discrete_distribution { public: // types using result_type = IntType; using param_type = /* unspecified */;   // constructor and reset functions discrete_distribution(); template discrete_distribution(InputIter firstW, InputIter lastW); discrete_distribution(initializer_list wl); template discrete_distribution(size_t nw, double xmin, double xmax, UnaryOperation fw); explicit discrete_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const discrete_distribution& x, const discrete_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& g, const param_type& parm);   // property functions vector probabilities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, const discrete_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, discrete_distribution& x); }; }

[edit] Class template std::piecewise_constant_distribution

namespace std { template class piecewise_constant_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions piecewise_constant_distribution(); template<class InputIterB, class InputIterW> piecewise_constant_distribution(InputIterB firstB, InputIterB lastB, InputIterW firstW); template piecewise_constant_distribution(initializer_list bl, UnaryOperation fw); template piecewise_constant_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw); explicit piecewise_constant_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const piecewise_constant_distribution& x, const piecewise_constant_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& g, const param_type& parm);   // property functions vector intervals() const; vector densities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<( basic_ostream<CharT, Traits>& os, const piecewise_constant_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, piecewise_constant_distribution& x); }; }

[edit] Class template std::piecewise_linear_distribution

namespace std { template class piecewise_linear_distribution { public: // types using result_type = RealType; using param_type = /* unspecified */;   // constructor and reset functions piecewise_linear_distribution(); template<class InputIterB, class InputIterW> piecewise_linear_distribution(InputIterB firstB, InputIterB lastB, InputIterW firstW); template piecewise_linear_distribution(initializer_list bl, UnaryOperation fw); template piecewise_linear_distribution(size_t nw, RealType xmin, RealType xmax, UnaryOperation fw); explicit piecewise_linear_distribution(const param_type& parm); void reset();   // equality operators friend bool operator==(const piecewise_linear_distribution& x, const piecewise_linear_distribution& y);   // generating functions template result_type operator()(URBG& g); template result_type operator()(URBG& g, const param_type& parm);   // property functions vector intervals() const; vector densities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const;   // inserters and extractors template<class CharT, class Traits> friend basic_ostream<CharT, Traits>& operator<<( basic_ostream<CharT, Traits>& os, const piecewise_linear_distribution& x); template<class CharT, class Traits> friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, piecewise_linear_distribution& x); }; }