std::mersenne_twister_engine

在标头 <random> 定义
template<     class UIntType, std::size_t w, std::size_t n, std::size_t m, std::size_t r,     UIntType a, std::size_t u, UIntType d, std::size_t s,     UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f > class mersenne_twister_engine;		(C++11 起)

mersenne_twister_engine 是基于梅森缠绕器算法的随机数生成器。它产生高质量但非密码学安全的，UIntType 类型的区间 \(\scriptsize {[0,2^w)}\)[0, 2w
) 上的无符号整数随机数。

模板形参

UIntType	-	生成器所生成的结果类型。如果它不是 unsigned short、unsigned int、unsigned long 或 unsigned long long 之一，那么效果未定义。
w	-	确定引擎生成的值的范围的2的幂
n	-	递推度
m	-	中间词，即定义状态的递推关系中使用的偏移
r	-	低位掩码的位数，也被称为缠绕值
a	-	条件性异或掩码，即有理范式缠绕矩阵的系数
u, d, s, b, t, c, l	-	位扰乱（调和）矩阵的第一个到第七个组分
f	-	初始化乘数

如果违背了以下任何限制，那么程序非良构：

• m 在范围 [1, n] 中。
• 以下表达式都是 true：

• w >= 3
• w >= r
• w >= u
• w >= s
• w >= t
• w >= l
• w <= std::numeric_limits<UIntType>::digits

• 给定 (1u << w) - 1u 为 w1，以下表达式都是 true：

• a <= w1
• b <= w1
• c <= w1
• d <= w1
• f <= w1

生成器属性

mersenne_twister_engine 的状态的大小是 n，它包含一个包含了 n 个 result_type 值的序列 X。\(\scriptsize X_j\)X
j 表示 X 的第 \(\scriptsize j\mod n\)j mod n 个值（从0开始算起）。

给定以下位操作表示：

• \(\scriptsize \mathsf{bitand}\)bitand，内建的逐位与。
• \(\scriptsize \mathsf{xor}\)xor，内建的逐位异或。
• \(\scriptsize \mathsf{lshift}\)lshift，内建的向左移位。
• \(\scriptsize \mathsf{rshift}\)rshift，内建的向右移位。

mersenne_twister_engine 的变换算法（\(\scriptsize TA(x_i)\)TA(x
i)）定义如下：

1. 拼接 \(\scriptsize X_{i-n}\)X
   i-n 的高 w - r 位和 \(\scriptsize X_{i+1-n}\)X
   i+1-n 的低 r 位，得到无符号整数值 Y。
2. 设 y 为 \(\scriptsize a \cdot (Y\ \mathsf{bitand}\ 1)\)a·(Y bitand 1)，并且将 \(\scriptsize X_i\)X
   i 设置为 \(\scriptsize X_{i+m−n}\ \mathsf{xor}\ (Y\ \mathsf{rshift}\ 1)\ \mathsf{xor}\ y\)X
   i+m−n xor (Y rshift 1) xor y。

mersenne_twister_engine 的生成算法（\(\scriptsize GA(x_i)\)GA(x
i)）定义如下：

1. 设 \(\scriptsize z_1\)z
   1 为 \(\scriptsize X_i\ \mathsf{xor}\ ((X_i\ \mathsf{rshift}\ u)\ \mathsf{bitand}\ d)\)X
   i xor ((X
   i rshift u) bitand d)。
2. 设 \(\scriptsize z_2\)z
   2 为 \(\scriptsize z_1\ \mathsf{xor}\ (((z_1\ \mathsf{lshift}\ s)\mod 2^w)\ \mathsf{bitand}\ b)\)X
   i xor (((X
   i lshift s) mod 2w
   ) bitand b)。
3. 设 \(\scriptsize z_3\)z
   3 为 \(\scriptsize z_2\ \mathsf{xor}\ (((z_2\ \mathsf{lshift}\ t)\mod 2^w)\ \mathsf{bitand}\ c)\)X
   i xor (((X
   i lshift t) mod 2w
   ) bitand c)。
4. 设 \(\scriptsize z_4\)z
   4 为 \(\scriptsize z_3\ \mathsf{xor}\ (z_3\ \mathsf{rshift}\ l)\)z
   3 xor (z
   3 rshift l)。
5. 以 \(\scriptsize z_4\)z
   4 作为生成结果（即 \(\scriptsize GA(x_i)=z_4\)GA(x
   i)=z
   4）。

预定义特化

下列特化定义了两种常用参数集的随机数引擎：

在标头 <random> 定义
类型	定义
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

嵌套类型

类型	定义
result_type	UIntType

数据成员

constexpr size_t word_size [静态]	w (公开静态成员常量)
constexpr size_t state_size [静态]	n (公开静态成员常量)
constexpr size_t shift_size [静态]	m (公开静态成员常量)
constexpr size_t mask_bits [静态]	r (公开静态成员常量)
constexpr UIntType xor_mask [静态]	a (公开静态成员常量)
constexpr size_t tempering_u [静态]	u (公开静态成员常量)
constexpr UIntType tempering_d [静态]	d (公开静态成员常量)
constexpr size_t tempering_s [静态]	s (公开静态成员常量)
constexpr UIntType tempering_b [静态]	b (公开静态成员常量)
constexpr size_t tempering_t [静态]	t (公开静态成员常量)
constexpr UIntType tempering_c [静态]	c (公开静态成员常量)
constexpr size_t tempering_l [静态]	l (公开静态成员常量)
constexpr UIntType initialization_multiplier [静态]	f (公开静态成员常量)
constexpr UIntType default_seed [静态]	5489u (公开静态成员常量)

成员函数

构造与播种
(构造函数) (C++11)	构造引擎 (公开成员函数)
seed (C++11)	设置引擎的当前状态 (公开成员函数)
生成
operator() (C++11)	推进引擎状态并返回生成的值 (公开成员函数)
discard (C++11)	令引擎状态前进指定量 (公开成员函数)
特征
min [静态] (C++11)	获取输出范围中的最小可能值 (公开静态成员函数)
max [静态] (C++11)	获取输出范围中的最大可能值 (公开静态成员函数)

非成员函数

operator==operator!= (C++11)(C++11)(C++20 中移除)	比较两个伪随机数引擎的内部状态 (函数)
operator<<operator>> (C++11)	执行伪随机数引擎的流输入和输出 (函数模板)

示例

本节未完成 原因：暂无示例