标准库标头 <random> (C++11)

 

C++

编译器支持

自立实现与有宿主实现

语言

标准库

标准库标头

具名要求

功能特性测试宏(C++20)

语言支持库

概念库(C++20)

诊断库

内存管理库

元编程库(C++11)

通用工具库

容器库

迭代器库

范围库(C++20)

算法库

字符串库

文本处理库

数值库

日期和时间库

输入/输出库

文件系统库(C++17)

并发支持库(C++11)

执行控制库(C++26)

技术规范

符号索引

外部库

 

标准库头

语言支持 <cfloat> <climits> <compare>(C++20) <contracts>(C++26) <coroutine>(C++20) <csetjmp> <csignal> <cstdarg> <cstddef> <cstdint>(C++11) <cstdlib> <exception> <initializer_list>(C++11)    <limits> <new> <source_location>(C++20) <stdfloat>(C++23) <typeinfo> <version>(C++20) 概念 <concepts>(C++20) 诊断 <cassert> <cerrno> <debugging>(C++26) <stacktrace>(C++23) <stdexcept> <system_error>(C++11) 内存管理 <memory> <memory_resource>(C++17) <scoped_allocator>(C++11) 元编程 <type_traits>(C++11) <ratio>(C++11)

通用工具 <any>(C++17) <bitset> <bit>(C++20) <charconv>(C++17) <expected>(C++23) <format>(C++20) <functional> <optional>(C++17) <stdbit.h>(C++26) <tuple>(C++11) <typeindex>(C++11) <utility> <variant>(C++17) 容器 <array>(C++11) <deque> <flat_map>(C++23) <flat_set>(C++23) <forward_list>(C++11) <hive>(C++26) <inplace_vector>(C++26)    <list> <map> <mdspan>(C++23) <queue> <set> <span>(C++20) <stack> <unordered_map>(C++11) <unordered_set>(C++11) <vector> 迭代器 <iterator> 范围 <generator>(C++23) <ranges>(C++20)

算法 <algorithm> <numeric> 字符串 <cctype> <cstring> <cuchar>(C++11) <cwchar> <cwctype> <string_view>(C++17) <string> 文本处理 <clocale> <codecvt>(C++11/17/26*) <locale> <regex>(C++11) <text_encoding>(C++26)    cpp/header#数值库数值 <cfenv>(C++11) <cmath> <complex> <linalg>(C++26) <numbers>(C++20) <random>(C++11) <simd>(C++26) <stdckdint.h>(C++26) <valarray> 时间 <chrono>(C++11) <ctime> C 兼容性 <ccomplex>(C++11/17/20*) <ciso646>(C++20 前) <cstdalign>(C++11/17/20*) <cstdbool>(C++11/17/20*) <ctgmath>(C++11/17/20*)

输入/输出 <cinttypes>(C++11) <cstdio> <filesystem>(C++17) <fstream> <iomanip> <iosfwd> <iostream> <ios> <istream> <ostream> <print>(C++23) <spanstream>(C++23) <sstream> <streambuf> <strstream>(C++98/26*) <syncstream>(C++20) 并发支持 <atomic>(C++11) <barrier>(C++20) <condition_variable>(C++11) <future>(C++11) <hazard_pointer>(C++26) <latch>(C++20) <mutex>(C++11) <rcu>(C++26) <semaphore>(C++20) <shared_mutex>(C++14) <stdatomic.h>(C++23) <stop_token>(C++20) <thread>(C++11) 执行支持 <execution>(C++17)

 

此头文件是伪随机数生成库的一部分。

包含
<initializer_list> (C++11)	std::initializer_list 类模板
概念
均匀随机位生成器要求
uniform_random_bit_generator (C++20)	指定类型具备作为均匀随机位生成器的资格 (概念)
类
随机数引擎
linear_congruential_engine (C++11)	实现线性同余算法 (类模板)
mersenne_twister_engine (C++11)	实现梅森缠绕器算法 (类模板)
subtract_with_carry_engine (C++11)	实现带进位减（一种延迟斐波那契）算法 (类模板)
philox_engine (C++26)	基于计数器的可并行化引擎 (类模板)
随机数引擎适配器
discard_block_engine (C++11)	舍弃随机数引擎的某些输出 (类模板)
independent_bits_engine (C++11)	打包随机数引擎的输出为指定位数的块 (类模板)
shuffle_order_engine (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,                              0x9908b0df, 11,                              0xffffffff, 7,                              0x9d2c5680, 15,                              0xefc60000, 18, 1812433253> 32 位梅森缠绕器，由松本与西村设计于 1998
mt19937_64(C++11)	std::mersenne_twister_engine<std::uint_fast64_t,                              64, 312, 156, 31,                              0xb5026f5aa96619e9, 29,                              0x5555555555555555, 17,                              0x71d67fffeda60000, 37,                              0xfff7eee000000000, 43,                              6364136223846793005> 64 位梅森缠绕器，由松本与西村设计于 2000
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>
philox4x32(C++26)	std::philox_engine<std::uint_fast32_t, 32, 4, 10,                    0xCD9E8D57, 0x9E3779B9,                    0xD2511F53, 0xBB67AE85>
philox4x64(C++26)	std::philox_engine<std::uint_fast64_t, 64, 4, 10,                    0xCA5A826395121157, 0x9E3779B97F4A7C15,                    0xD2E7470EE14C6C93, 0xBB67AE8584CAA73B>
default_random_engine(C++11)	由实现定义的随机数引擎(RandomNumberEngine) 类型

非确定性随机数
random_device (C++11)	使用硬件熵源的非确定随机数生成器 (类)
均匀分布
uniform_int_distribution (C++11)	产生在范围内均匀分布的整数 (类模板)
uniform_real_distribution (C++11)	产生在范围内均匀分布的实数 (类模板)
伯努利分布
bernoulli_distribution (C++11)	产生伯努利分布上的 bool 值 (类)
binomial_distribution (C++11)	产生服从二项分布的整数 (类模板)
negative_binomial_distribution (C++11)	产生服从负二项分布的整数 (类模板)
geometric_distribution (C++11)	产生服从几何分布的整数 (类模板)
泊松分布
poisson_distribution (C++11)	产生服从泊松分布的整数 (类模板)
exponential_distribution (C++11)	产生服从指数分布的实数 (类模板)
gamma_distribution (C++11)	产生服从 Γ 分布的实数 (类模板)
weibull_distribution (C++11)	产生服从威布尔分布的实数 (类模板)
extreme_value_distribution (C++11)	产生服从极值分布的实数 (类模板)
正态分布
normal_distribution (C++11)	产生服从标准正态（高斯）分布的实数 (类模板)
lognormal_distribution (C++11)	产生服从对数正态分布的实数 (类模板)
chi_squared_distribution (C++11)	产生服从 χ2 分布的实数 (类模板)
cauchy_distribution (C++11)	产生服从柯西分布的实数 (类模板)
fisher_f_distribution (C++11)	产生服从费舍尔 F 分布的实数 (类模板)
student_t_distribution (C++11)	产生服从学生 t 分布的实数 (类模板)
采样分布
discrete_distribution (C++11)	产生离散分布的整数 (类模板)
piecewise_constant_distribution (C++11)	产生分布在常子区间内的实数 (类模板)
piecewise_linear_distribution (C++11)	产生分布在定义的子区间内的实数 (类模板)
工具
seed_seq (C++11)	通用的偏差消除的混淆种子序列生成器 (类)
函数
generate_canonical (C++11)	给定精度的在 [​0​, 1) 内均匀分布的实数 (函数模板)
ranges::generate_random (C++26)	用来自均匀随机位发生器的随机数填充范围 (算法函数对象)

概要

#include <initializer_list>   namespace std {// 均匀随机位生成器要求template<class G> concept uniform_random_bit_generator =/* 见描述 */;// 独立   // 类模板 linear_congruential_enginetemplate<class UIntType, UIntType a, UIntType c, UIntType m>class linear_congruential_engine;// 部分独立   // 类模板 mersenne_twister_enginetemplate<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_enginetemplate<class UIntType, size_t w, size_t s, size_t r>class subtract_with_carry_engine;// 部分独立   // 类模板 discard_block_enginetemplate<class Engine, size_t p, size_t r>class discard_block_engine;// 部分独立   // 类模板 independent_bits_enginetemplate<class Engine, size_t w, class UIntType>class independent_bits_engine;// 部分独立   // 类模板 shuffle_order_enginetemplate<class Engine, size_t k>class shuffle_order_engine;   // 类模板 philox_enginetemplate<class UIntType, size_t w, size_t n, size_t r, UIntType... consts>class philox_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 philox4x32 =/* 见描述 */;// 独立using philox4x64 =/* 见描述 */;// 独立   using default_random_engine =/* 见描述 */;   // 类 random_deviceclass random_device;   // 类 seed_seqclass seed_seq;   // 函数模板 generate_canonicaltemplate<class RealType, size_t bits, class URBG> RealType generate_canonical(URBG& g);   namespace ranges {// generate_randomtemplate<class R, class G> requires output_range<R, invoke_result_t<G&>>&& uniform_random_bit_generator<remove_cvref_t<G>>constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g);   template<class G, output_iterator<invoke_result_t<G&>> O, sentinel_for<O> S> requires uniform_random_bit_generator<remove_cvref_t<G>>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<G>>&& is_arithmetic_v<invoke_result_t<D&, G&>>constexpr borrowed_iterator_t<R> generate_random(R&& r, G&& g, D&& d);   template<class G, class D, output_iterator<invoke_result_t<D&, G&>> O, sentinel_for<O> S> requires invocable<D&, G&>&& uniform_random_bit_generator<remove_cvref_t<G>>&& is_arithmetic_v<invoke_result_t<D&, G&>>constexpr O generate_random(O first, S last, G&& g, D&& d);}   // 类模板 uniform_int_distributiontemplate<class IntType =int>class uniform_int_distribution;// 部分独立   // 类模板 uniform_real_distributiontemplate<class RealType =double>class uniform_real_distribution;   // 类 bernoulli_distributionclass bernoulli_distribution;   // 类模板 binomial_distributiontemplate<class IntType =int>class binomial_distribution;   // 类模板 geometric_distributiontemplate<class IntType =int>class geometric_distribution;   // 类模板 negative_binomial_distributiontemplate<class IntType =int>class negative_binomial_distribution;   // 类模板 poisson_distributiontemplate<class IntType =int>class poisson_distribution;   // 类模板 exponential_distributiontemplate<class RealType =double>class exponential_distribution;   // 类模板 gamma_distributiontemplate<class RealType =double>class gamma_distribution;   // 类模板 weibull_distributiontemplate<class RealType =double>class weibull_distribution;   // 类模板 extreme_value_distributiontemplate<class RealType =double>class extreme_value_distribution;   // 类模板 normal_distributiontemplate<class RealType =double>class normal_distribution;   // 类模板 lognormal_distributiontemplate<class RealType =double>class lognormal_distribution;   // 类模板 chi_squared_distributiontemplate<class RealType =double>class chi_squared_distribution;   // 类模板 cauchy_distributiontemplate<class RealType =double>class cauchy_distribution;   // 类模板 fisher_f_distributiontemplate<class RealType =double>class fisher_f_distribution;   // 类模板 student_t_distributiontemplate<class RealType =double>class student_t_distribution;   // 类模板 discrete_distributiontemplate<class IntType =int>class discrete_distribution;   // 类模板 piecewise_constant_distributiontemplate<class RealType =double>class piecewise_constant_distribution;   // 类模板 piecewise_linear_distributiontemplate<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;   // 引擎特征staticconstexpr result_type multiplier = a;staticconstexpr result_type increment = c;staticconstexpr result_type modulus = m;staticconstexpr result_type min(){return c == 0u ? 1u : 0u;}staticconstexpr result_type max(){return m - 1u;}staticconstexpr 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);   // 相等性运算符friendbool operator==(const linear_congruential_engine& x, const linear_congruential_engine& y);   // 生成函数 result_type operator()();void discard(unsignedlonglong z);   // 插入符和提取符template<class CharT, class Traits>friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // 宿主const linear_congruential_engine& x);template<class CharT, class Traits>friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // 宿主 linear_congruential_engine& x);};}

类模板 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;   // 引擎特征staticconstexpr size_t word_size = w;staticconstexpr size_t state_size = n;staticconstexpr size_t shift_size = m;staticconstexpr size_t mask_bits = r;staticconstexpr UIntType xor_mask = a;staticconstexpr size_t tempering_u = u;staticconstexpr UIntType tempering_d = d;staticconstexpr size_t tempering_s = s;staticconstexpr UIntType tempering_b = b;staticconstexpr size_t tempering_t = t;staticconstexpr UIntType tempering_c = c;staticconstexpr size_t tempering_l = l;staticconstexpr UIntType initialization_multiplier = f;staticconstexpr result_type min(){return0;}staticconstexpr result_type max(){return/*2^w - 1*/;}staticconstexpr 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);   // 相等性运算符friendbool operator==(const mersenne_twister_engine& x, const mersenne_twister_engine& y);   // 生成函数 result_type operator()();void discard(unsignedlonglong z);   // 插入符和提取符template<class CharT, class Traits>friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // 宿主const mersenne_twister_engine& x);template<class CharT, class Traits>friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // 宿主 mersenne_twister_engine& x);};}

类模板 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;   // 引擎特征staticconstexpr size_t word_size = w;staticconstexpr size_t short_lag = s;staticconstexpr size_t long_lag = r;staticconstexpr result_type min(){return0;}staticconstexpr result_type max(){return/*m - 1*/;}staticconstexpr uint_least32_t default_seed = 19780503u;   // 构造函数与播种函数 subtract_with_carry_engine(): subtract_with_carry_engine(0u){}explicit subtract_with_carry_engine(result_type value);template<class Sseq>explicit subtract_with_carry_engine(Sseq& q);void seed(result_type value = 0u);template<class Sseq>void seed(Sseq& q);   // 相等性运算符friendbool operator==(const subtract_with_carry_engine& x, const subtract_with_carry_engine& y);   // 生成函数 result_type operator()();void discard(unsignedlonglong z);   // 插入符和提取符template<class CharT, class Traits>friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // 宿主const subtract_with_carry_engine& x);template<class CharT, class Traits>friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // 宿主 subtract_with_carry_engine& x);};}

类模板 std::philox_engine

namespace std {template<class UIntType, size_t w, size_t n, size_t r, UIntType... consts>class philox_engine {staticconstexpr size_t /*array-size*/= n /2;// 仅用于阐述public:// 类型using result_type = UIntType;   // 引擎特征staticconstexpr size_t word_size = w;staticconstexpr size_t word_count = n;staticconstexpr size_t round_count = r;staticconstexpr array<result_type, /*array-size*/> multipliers;staticconstexpr array < result_type, @exposition onlyid { array - size >} @round_consts;staticconstexpr result_type min(){return0;}staticconstexpr result_type max(){return m -1;}staticconstexpr result_type default_seed = 20111115u;   // 构造函数与播种函数 philox_engine(): philox_engine(default_seed){}explicit philox_engine(result_type value);template<class Sseq>explicit philox_engine(Sseq& q);void seed(result_type value = default_seed);template<class Sseq>void seed(Sseq& q);   void set_counter(const array<result_type, n>& counter);   // 相等性运算符friendbool operator==(const philox_engine& x, const philox_engine& y);   // 生成函数 result_type operator()();void discard(unsignedlonglong z);   // 插入符和提取符template<class CharT, class Traits>friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // 宿主const philox_engine& x);template<class CharT, class Traits>friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // 宿主 philox_engine& x);};}

类模板 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;   // 引擎特征staticconstexpr size_t block_size = p;staticconstexpr size_t used_block = r;staticconstexpr result_type min(){return Engine::min();}staticconstexpr 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);   // 相等性运算符friendbool operator==(const discard_block_engine& x, const discard_block_engine& y);   // 生成函数 result_type operator()();void discard(unsignedlonglong z);   // 属性函数const Engine& base()constnoexcept{return e;}   // 插入符和提取符template<class CharT, class Traits>friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // 宿主const discard_block_engine& x);template<class CharT, class Traits>friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // 宿主 discard_block_engine& x);   private: Engine e;// 仅用于阐述 size_t n;// 仅用于阐述};}

类模板 std::independent_bits_engine

namespace std {template<class Engine, size_t w, class UIntType>class independent_bits_engine {public:// 类型using result_type = UIntType;   // 引擎特征staticconstexpr result_type min(){return0;}staticconstexpr result_type max(){return/*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);   // 相等性运算符friendbool operator==(const independent_bits_engine& x, const independent_bits_engine& y);   // 生成函数 result_type operator()();void discard(unsignedlonglong z);   // 属性函数const Engine& base()constnoexcept{return e;}   // 插入符和提取符template<class CharT, class Traits>friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // 宿主const independent_bits_engine& x);template<class CharT, class Traits>friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // 宿主 independent_bits_engine& x);   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;   // 引擎特征staticconstexpr size_t table_size = k;staticconstexpr result_type min(){return Engine::min();}staticconstexpr 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);   // 相等性运算符friendbool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);   // 生成函数 result_type operator()();void discard(unsignedlonglong z);   // 属性函数const Engine& base()constnoexcept{return e;}   // 插入符和提取符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;// 仅用于阐述 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 =/* 由实现定义 */;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>;}

类 std::random_device

namespace std {class random_device {public:// 类型using result_type =unsignedint;   // 生成器特征staticconstexpr result_type min(){return numeric_limits<result_type>::min();}staticconstexpr result_type max(){return numeric_limits<result_type>::max();}   // 构造函数 random_device(): random_device(/* 由实现定义 */){}explicit random_device(const string& token);   // 生成函数 result_type operator()();   // 属性函数double entropy()constnoexcept;   // 无复制函数 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()noexcept;template<class T> seed_seq(initializer_list<T> il);template<class InputIter> seed_seq(InputIter begin, InputIter end);   // 生成函数template<class RandomAccessIter>void generate(RandomAccessIter begin, RandomAccessIter end);   // 属性函数 size_t size()constnoexcept;template<class OutputIter>void param(OutputIter 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();   // 相等性运算符friendbool operator==(const uniform_int_distribution& x, const uniform_int_distribution& y);   // 生成函数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;   // 插入符和提取符template<class CharT, class Traits>friend basic_ostream<CharT, Traits>& operator<<(basic_ostream<CharT, Traits>& os, // 宿主const uniform_int_distribution& x);template<class CharT, class Traits>friend basic_istream<CharT, Traits>& operator>>(basic_istream<CharT, Traits>& is, // 宿主 uniform_int_distribution& x);};}

类模板 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();   // 相等性运算符friendbool operator==(const uniform_real_distribution& x, const uniform_real_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类 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();   // 相等性运算符friendbool operator==(const bernoulli_distribution& x, const bernoulli_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const binomial_distribution& x, const binomial_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const geometric_distribution& x, const geometric_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const negative_binomial_distribution& x, const negative_binomial_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const poisson_distribution& x, const poisson_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const exponential_distribution& x, const exponential_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const gamma_distribution& x, const gamma_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const weibull_distribution& x, const weibull_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const extreme_value_distribution& x, const extreme_value_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const normal_distribution& x, const normal_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const lognormal_distribution& x, const lognormal_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const chi_squared_distribution& x, const chi_squared_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const cauchy_distribution& x, const cauchy_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const fisher_f_distribution& x, const fisher_f_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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();   // 相等性运算符friendbool operator==(const student_t_distribution& x, const student_t_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 std::discrete_distribution

namespace std {template<class IntType =int>class discrete_distribution {public:// 类型using result_type = IntType;using param_type =/* 未指定 */;   // 构造函数与重置函数 discrete_distribution();template<class InputIter> discrete_distribution(InputIter firstW, InputIter 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();   // 相等性运算符friendbool operator==(const discrete_distribution& x, const discrete_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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 InputIterB, class InputIterW> piecewise_constant_distribution(InputIterB firstB, InputIterB lastB, InputIterW 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();   // 相等性运算符friendbool operator==(const piecewise_constant_distribution& x, const piecewise_constant_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}

类模板 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 InputIterB, class InputIterW> piecewise_linear_distribution(InputIterB firstB, InputIterB lastB, InputIterW 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();   // 相等性运算符friendbool operator==(const piecewise_linear_distribution& x, const piecewise_linear_distribution& y);   // 生成函数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;   // 插入符和提取符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);};}