标准库头文件 <random>
此头文件是伪随机数生成库的一部分。
包含 | |
(C++11) |
std::initializer_list 类模板 |
概念 | |
均匀随机位生成器要求 | |
(C++20) |
指定类型具备作为均匀随机位生成器的资格 (概念) |
类 | |
随机数引擎 | |
(C++11) |
实现线性同余算法 (类模板) |
(C++11) |
实现梅森缠绕器算法 (类模板) |
(C++11) |
实现带进位减(一种延迟斐波那契)算法 (类模板) |
随机数引擎适配器 | |
(C++11) |
舍弃随机数引擎的某些输出 (类模板) |
(C++11) |
将一个随机数引擎的输出打包为指定位数的块 (类模板) |
(C++11) |
以不同顺序发送一个随机数引擎的输出 (类模板) |
预定义生成器 | |
minstd_rand0 (C++11)
|
std::linear_congruential_engine<std::uint_fast32_t, 16807, 0, 2147483647> 由 Lewis、Goodman 及 Miller 发现于 1969,由 Park 与 Miller 于 1988 采纳为“最小标准” |
minstd_rand (C++11)
|
std::linear_congruential_engine<std::uint_fast32_t, 48271, 0, 2147483647> 较新的“最小标准”,为 Park、 Miller 及 Stockmeyer 于 1993 推荐 |
mt19937 (C++11)
|
std::mersenne_twister_engine<std::uint_fast32_t, 32, 624, 397, 31, |
mt19937_64 (C++11)
|
std::mersenne_twister_engine<std::uint_fast64_t, 64, 312, 156, 31, |
ranlux24_base (C++11)
|
std::subtract_with_carry_engine<std::uint_fast32_t, 24, 10, 24> |
ranlux48_base (C++11)
|
std::subtract_with_carry_engine<std::uint_fast64_t, 48, 5, 12> |
ranlux24 (C++11)
|
std::discard_block_engine<std::ranlux24_base, 223, 23> 24 位 RANLUX 生成器,由 Martin Lüscher 与 Fred James 设计于 1994 |
ranlux48 (C++11)
|
std::discard_block_engine<std::ranlux48_base, 389, 11> 48 位 RANLUX 生成器,由 Martin Lüscher 与 Fred James 设计于 1994 |
knuth_b (C++11)
|
std::shuffle_order_engine<std::minstd_rand0, 256> |
default_random_engine (C++11)
|
实现定义 |
非确定性随机数 | |
(C++11) |
使用硬件熵源的非确定随机数生成器 (类) |
均匀分布 | |
(C++11) |
产生在一个范围上均匀分布的整数值 (类模板) |
(C++11) |
产生在一个范围上均匀分布的实数值 (类模板) |
伯努利分布 | |
(C++11) |
产生伯努利分布上的 bool 值。 (类) |
(C++11) |
产生二项分布上的整数值。 (类模板) |
产生负二项分布上的整数值。 (类模板) | |
(C++11) |
产生几何分布上的整数值。 (类模板) |
泊松分布 | |
(C++11) |
产生泊松分布上的整数值。 (类模板) |
(C++11) |
产生指数分布上的实数值。 (类模板) |
(C++11) |
产生 Γ 分布上的实数值 (类模板) |
(C++11) |
产生威布尔分布上的实数值。 (类模板) |
(C++11) |
产生极值分布上的实数值。 (类模板) |
正态分布 | |
(C++11) |
产生标准正态(高斯)分布上的实数值。 (类模板) |
(C++11) |
产生对数正态分布上的实数值。 (类模板) |
(C++11) |
产生 χ2 分布上的实数值。 (类模板) |
(C++11) |
产生柯西分布上的实数值。 (类模板) |
(C++11) |
产生费舍尔 F 分布上的实数值。 (类模板) |
(C++11) |
产生学生 t 分布上的实数值。 (类模板) |
采样分布 | |
(C++11) |
产生离散分布上的随机整数。 (类模板) |
产生分布在常子区间上的实数值。 (类模板) | |
产生分布在定义的子区间上的实数值。 (类模板) | |
工具 | |
(C++11) |
通用的偏差消除的混淆种子序列生成器 (类) |
函数 | |
(C++11) |
给定精度的均匀分布在 [0, 1) 上的实数值 (函数模板) |
概要
#include <initializer_list> namespace std { // 均匀随机位生成器要求 template<class G> concept uniform_random_bit_generator = /* 见描述 */; // 类模板 linear_congruential_engine template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine; // 类模板 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; // 类模板 subtract_with_carry_engine template<class UIntType, size_t w, size_t s, size_t r> class subtract_with_carry_engine; // 类模板 discard_block_engine template<class Engine, size_t p, size_t r> class discard_block_engine; // 类模板 independent_bits_engine template<class Engine, size_t w, class UIntType> class independent_bits_engine; // 类模板 shuffle_order_engine template<class Engine, size_t k> class shuffle_order_engine; // 带预定义形参的引擎及引擎适配器 using minstd_rand0 = /* 见描述 */; using minstd_rand = /* 见描述 */; using mt19937 = /* 见描述 */; using mt19937_64 = /* 见描述 */; using ranlux24_base = /* 见描述 */; using ranlux48_base = /* 见描述 */; using ranlux24 = /* 见描述 */; using ranlux48 = /* 见描述 */; using knuth_b = /* 见描述 */; using default_random_engine = /* 见描述 */; // 类 random_device class random_device; // 类 seed_seq class seed_seq; // 函数模板 generate_canonical template<class RealType, size_t bits, class URBG> RealType generate_canonical(URBG& g); // 类模板 uniform_int_distribution template<class IntType = int> class uniform_int_distribution; // 类模板 uniform_real_distribution template<class RealType = double> class uniform_real_distribution; // 类 bernoulli_distribution class bernoulli_distribution; // 类模板 binomial_distribution template<class IntType = int> class binomial_distribution; // 类模板 geometric_distribution template<class IntType = int> class geometric_distribution; // 类模板 negative_binomial_distribution template<class IntType = int> class negative_binomial_distribution; // 类模板 poisson_distribution template<class IntType = int> class poisson_distribution; // 类模板 exponential_distribution template<class RealType = double> class exponential_distribution; // 类模板 gamma_distribution template<class RealType = double> class gamma_distribution; // 类模板 weibull_distribution template<class RealType = double> class weibull_distribution; // 类模板 extreme_value_distribution template<class RealType = double> class extreme_value_distribution; // 类模板 normal_distribution template<class RealType = double> class normal_distribution; // 类模板 lognormal_distribution template<class RealType = double> class lognormal_distribution; // 类模板 chi_squared_distribution template<class RealType = double> class chi_squared_distribution; // 类模板 cauchy_distribution template<class RealType = double> class cauchy_distribution; // 类模板 fisher_f_distribution template<class RealType = double> class fisher_f_distribution; // 类模板 student_t_distribution template<class RealType = double> class student_t_distribution; // 类模板 discrete_distribution template<class IntType = int> class discrete_distribution; // 类模板 piecewise_constant_distribution template<class RealType = double> class piecewise_constant_distribution; // 类模板 piecewise_linear_distribution template<class RealType = double> class piecewise_linear_distribution; }
概念 uniform_random_bit_generator
namespace std { template<class G> 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; }; }
类模板 std::linear_congruential_engine
namespace std { template<class UIntType, UIntType a, UIntType c, UIntType m> class linear_congruential_engine { public: // 类型 using result_type = UIntType; // 引擎特征 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; // 构造函数与播种函数 linear_congruential_engine() : linear_congruential_engine(default_seed) {} explicit linear_congruential_engine(result_type s); template<class Sseq> explicit linear_congruential_engine(Sseq& q); void seed(result_type s = default_seed); template<class Sseq> void seed(Sseq& q); // 生成函数 result_type operator()(); void discard(unsigned long long z); }; }
类模板 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: // 类型 using result_type = UIntType; // 引擎特征 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 /* pow(2, w) - 1 */; } static constexpr result_type default_seed = 5489u; // 构造函数与播种函数 mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} explicit mersenne_twister_engine(result_type value); template<class Sseq> explicit mersenne_twister_engine(Sseq& q); void seed(result_type value = default_seed); template<class Sseq> void seed(Sseq& q); // 生成函数 result_type operator()(); void discard(unsigned long long z); }; }
类模板 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: // 类型 using result_type = UIntType; // 引擎特征 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 /* pow(2, w) - 1 */; } static constexpr result_type default_seed = 19780503u; // 构造函数与播种函数 subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} explicit subtract_with_carry_engine(result_type value); template<class Sseq> explicit subtract_with_carry_engine(Sseq& q); void seed(result_type value = default_seed); template<class Sseq> void seed(Sseq& q); // 生成函数 result_type operator()(); void discard(unsigned long long z); }; }
类模板 std::discard_block_engine
namespace std { template<class Engine, size_t p, size_t r> class discard_block_engine { public: // 类型 using result_type = typename Engine::result_type; // 引擎特征 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(); } // 构造函数与播种函数 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); // 生成函数 result_type operator()(); void discard(unsigned long long z); // 属性函数 const Engine& base() const noexcept { return e; }; private: Engine e; // 仅用于阐释 int n; // 仅用于阐释 }; }
类模板 std::independent_bits_engine
namespace std { template<class Engine, size_t w, class UIntType> class independent_bits_engine { public: // 类型 using result_type = UIntType; // 引擎特征 static constexpr result_type min() { return 0; } static constexpr result_type max() { return /* pow(2, w) - 1 */; } // 构造函数与播种函数 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); // 生成函数 result_type operator()(); void discard(unsigned long long z); // 属性函数 const Engine& base() const noexcept { return e; }; private: Engine e; // 仅用于阐释 }; }
类模板 std::shuffle_order_engine
namespace std { template<class Engine, size_t k> class shuffle_order_engine { public: // 类型 using result_type = typename Engine::result_type; // 引擎特征 static constexpr size_t table_size = k; static constexpr result_type min() { return Engine::min(); } static constexpr result_type max() { return Engine::max(); } // 构造函数与播种函数 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); // 生成函数 result_type operator()(); void discard(unsigned long long z); // 属性函数 const Engine& base() const noexcept { return e; }; private: Engine e; // 仅用于阐释 result_type V[k]; // 仅用于阐释 result_type Y; // 仅用于阐释 }; }
带预定义形参的引擎及引擎适配器
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 = /* 由实现定义 */; }
类 std::random_device
namespace std { class random_device { public: // 类型 using result_type = unsigned int; // 生成器特征 static constexpr result_type min() { return numeric_limits<result_type>::min(); } static constexpr result_type max() { return numeric_limits<result_type>::max(); } // 构造函数 random_device() : random_device(/* 由实现定义 */) {} explicit random_device(const string& token); // 生成函数 result_type operator()(); // 属性函数 double entropy() const noexcept; // 无复制函数 random_device(const random_device&) = delete; void operator=(const random_device&) = delete; }; }
类 std::seed_seq
namespace std { class seed_seq { public: // 类型 using result_type = uint_least32_t; // 构造函数 seed_seq(); template<class T> seed_seq(initializer_list<T> il); template<class InputIt> seed_seq(InputIt begin, InputIt end); // 生成函数 template<class RandomAccessIt> void generate(RandomAccessIt begin, RandomAccessIt end); // 属性函数 size_t size() const noexcept; template<class OutputIt> void param(OutputIt dest) const; // 无复制函数 seed_seq(const seed_seq&) = delete; void operator=(const seed_seq&) = delete; private: vector<result_type> v; // 仅用于阐释 }; }
类模板 std::uniform_int_distribution
namespace std { template<class IntType = int> class uniform_int_distribution { public: // 类型 using result_type = IntType; using param_type = /* 未指明 */; // 构造函数与重置函数 uniform_int_distribution() : uniform_int_distribution(0) {} explicit uniform_int_distribution(IntType a, IntType b = numeric_limits<IntType>::max()); explicit uniform_int_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 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; }; }
类模板 std::uniform_real_distribution
namespace std { template<class RealType = double> class uniform_real_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 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(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 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; }; }
类 std::bernoulli_distribution
namespace std { class bernoulli_distribution { public: // 类型 using result_type = bool; using param_type = /* 未指明 */; // 构造函数与重置函数 bernoulli_distribution() : bernoulli_distribution(0.5) {} explicit bernoulli_distribution(double p); explicit bernoulli_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::binomial_distribution
namespace std { template<class IntType = int> class binomial_distribution { public: // 类型 using result_type = IntType; using param_type = /* 未指明 */; // 构造函数与重置函数 binomial_distribution() : binomial_distribution(1) {} explicit binomial_distribution(IntType t, double p = 0.5); explicit binomial_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 IntType t() const; double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::geometric_distribution
namespace std { template<class IntType = int> class geometric_distribution { public: // 类型 using result_type = IntType; using param_type = /* 未指明 */; // 构造函数与重置函数 geometric_distribution() : geometric_distribution(0.5) {} explicit geometric_distribution(double p); explicit geometric_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::negative_binomial_distribution
namespace std { template<class IntType = int> class negative_binomial_distribution { public: // 类型 using result_type = IntType; using param_type = /* 未指明 */; // 构造函数与重置函数 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(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 IntType k() const; double p() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::poisson_distribution
namespace std { template<class IntType = int> class poisson_distribution { public: // 类型 using result_type = IntType; using param_type = /* 未指明 */; // 构造函数与重置函数 poisson_distribution() : poisson_distribution(1.0) {} explicit poisson_distribution(double mean); explicit poisson_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 double mean() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::exponential_distribution
namespace std { template<class RealType = double> class exponential_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 exponential_distribution() : exponential_distribution(1.0) {} explicit exponential_distribution(RealType lambda); explicit exponential_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType lambda() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::gamma_distribution
namespace std { template<class RealType = double> class gamma_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 gamma_distribution() : gamma_distribution(1.0) {} explicit gamma_distribution(RealType alpha, RealType beta = 1.0); explicit gamma_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType alpha() const; RealType beta() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::weibull_distribution
namespace std { template<class RealType = double> class weibull_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 weibull_distribution() : weibull_distribution(1.0) {} explicit weibull_distribution(RealType a, RealType b = 1.0); explicit weibull_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::extreme_value_distribution
namespace std { template<class RealType = double> class extreme_value_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 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(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::normal_distribution
namespace std { template<class RealType = double> class normal_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 normal_distribution() : normal_distribution(0.0) {} explicit normal_distribution(RealType mean, RealType stddev = 1.0); explicit normal_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType mean() const; RealType stddev() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::lognormal_distribution
namespace std { template<class RealType = double> class lognormal_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 lognormal_distribution() : lognormal_distribution(0.0) {} explicit lognormal_distribution(RealType m, RealType s = 1.0); explicit lognormal_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType m() const; RealType s() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::chi_squared_distribution
namespace std { template<class RealType = double> class chi_squared_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 chi_squared_distribution() : chi_squared_distribution(1.0) {} explicit chi_squared_distribution(RealType n); explicit chi_squared_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::cauchy_distribution
namespace std { template<class RealType = double> class cauchy_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 cauchy_distribution() : cauchy_distribution(0.0) {} explicit cauchy_distribution(RealType a, RealType b = 1.0); explicit cauchy_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType a() const; RealType b() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; };
类模板 std::fisher_f_distribution
namespace std { template<class RealType = double> class fisher_f_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 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(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType m() const; RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::student_t_distribution
namespace std { template<class RealType = double> class student_t_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 student_t_distribution() : student_t_distribution(1.0) {} explicit student_t_distribution(RealType n); explicit student_t_distribution(const param_type& parm); void reset(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 RealType n() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::discrete_distribution
namespace std { template<class IntType = int> class discrete_distribution { public: // 类型 using result_type = IntType; using param_type = /* 未指明 */; // 构造函数与重置函数 discrete_distribution(); template<class InputIt> discrete_distribution(InputIt firstW, InputIt 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(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 vector<double> probabilities() const; param_type param() const; void param(const param_type& parm); result_type min() const; result_type max() const; }; }
类模板 std::piecewise_constant_distribution
namespace std { template<class RealType = double> class piecewise_constant_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 piecewise_constant_distribution(); template<class InputItB, class InputItW> piecewise_constant_distribution(InputItB firstB, InputItB lastB, InputItW 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(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 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; }; }
类模板 std::piecewise_linear_distribution
namespace std { template<class RealType = double> class piecewise_linear_distribution { public: // 类型 using result_type = RealType; using param_type = /* 未指明 */; // 构造函数与重置函数 piecewise_linear_distribution(); template<class InputItB, class InputItW> piecewise_linear_distribution(InputItB firstB, InputItB lastB, InputItW 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(); // 生成函数 template<class URBG> result_type operator()(URBG& g); template<class URBG> result_type operator()(URBG& g, const param_type& parm); // 属性函数 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; }; }