C++标准库(十)：随机数

• 程序通常需要一个随机数源。在新标准出现之前，C 和 C++ 都依赖于一个简单的 C 库 函数 rand 来生成随机数。此函数生成均匀分布的伪随机整数， 每个随机数的范围在 0 和一个系统相关的最大值（至少为 32767) 之间
• rand 函数有一些问题： 很多程序需要不同范围的随机数。一些应用需要随机浮点数。一些程序需要非均匀分布的数。而程序员为了解决这些问题而试图转换 rand 生成的随机数的范围、类型或分布时， 常常会引入非随机性
• 定义在头文件 random 中的随机数库通过一组协作的类来解决这些问题：随机数引擎类 (random-number engines) 和 随机数分布类 (random-number distribution)
  

#include <random>

随机数引擎和分布

• 随机数引擎类定义了一个调用运算符，该运算符不接受参数并返回一个随机 unsigned 整数。我们可以通过调用一个随机数引擎对象来生成原始随机数：
  • 调用一个 default_random_engine 对象的输出类似 rand 的输出。随机数引擎生成的 unsigned 整数在一个系统定义的范围内， 而 rand 生成的数的范围在 0 到 RAND_MAX 之间。一个引擎类型的范围可以通过调用该类型对象的 min 和 max 成员来获得
  • C++ 程序不应该使用库函数 rand, 而应使用 default_random_engine 类和恰当的分布类对象

default_random_engine e; 	// 生成随机无符号牧
for (size_t i = 0; i < 10; ++i)
	// e() "调用" 对象来生成下一个随机数
	cout << e() << " ";

---

• 标准库定义了多个随机数引擎类， 区别在于性能和随机性质量不同。每个编译器都会指定其中一个作为 default_random_engine 类型，此类型一般具有最常用的特性
  

分布类型和引擎

• 对于大多数场合， 随机数引擎的输出是不能直接使用的， 这也是为什么早先我们称之为原始随机数。问题出在生成的随机数的值范围通常与我们需要的不符
• 为了得到在一个指定范围内的数， 我们使用一个分布类型的对象。分布类型也是函数对象类。分布类型定义了一个调用运算符， 它接受一个随机数引擎作为参数。分布对象使用它的引擎参数生成随机数， 并将其映射到指定的分布
  

注意，我们传递的是引擎本身， 而不是它生成的下一个值， 原因是某些分布可能需要调用引擎多次才能得到一个值

// 生成 0 到 9 之间（包含）均匀分布的随机数
uniform_int_distribution<unsigned> u(0, 9);
default_random_engine e; 	// 生成无符号随机整数
for (size_t i = 0; i < 10; ++i)
	// 将 u 作为随机数源
	// 每个调用返回在指定范围内并服从均匀分布的值
	cout << u(e) << " "·

当我们说随机数发生器时， 是指分布对象和引擎对象的组合

伪随机数

• 一个给定的随机数发生器一直会生成相同的随机数序列。因此，一个函数如果定义了局部的随机数发生器， 应该将其（包括引擎和分布对象）定义为 static 的。否则， 每次调用函数都会生成相同的序列

// 几乎肯定是生成随机整数 vector 的错误方法
// 每次调用这个函数都会生成相同的 100 个数！
vector<unsigned> bad_randVec()
{
	default_random_engine e;
	uniform_int_distribution<unsigned> u(0,9);
	vector<unsigned> ret;
	
	for (size t i = 0; i < 100; ++i)
		ret.push_back(u(e));
		
	return ret;
}

// 正确方法是将引擎和关联的分布对象定义为 static 的
// 返回一个 vector, 包含 100 个均匀分布的随机数
vector<unsigned> good_randVec()
{
	// 由于我们希望引年和分布对象保持状态， 因此应该将它们
	// 定义为 static 的， 从而每次调用都生成新的数
	static default_random_engine e;
	static uniform_int_distribution<unsigned> u(0,9);
	vector<unsigned> ret;
	
	for (size_t i = 0; i < 100; ++i)
		ret.push_back(u(e));
	return ret;
}

设置随机数发生器种子

• 随机数发生器会生成相同的随机数序列这一特性在调试中很有用。但是， 一旦我们的程序调试完毕， 我们通常希望每次运行程序都会生成不同的随机结果， 可以通过提供一个种子 (seed) 来达到这一目的。种子就是一个数值， 引擎可以利用它从序列中一个新位置重新开始生成随机数
• 为引擎设置种子有两种方式：在创建引擎对象时提供种子， 或者调用引擎的 seed 成员

default_random_engine e1; 	// 使用默认种子
default_random_engine e2(2147483646); // 使用给定的种子值
// e3 和 e4 将生成相同的序列， 因为它们使用了相同的种子
default_random_engine e3; 	// 使用默认种子值
e3.seed(32767); 			// 调用seed设置一个新种子值
default_random_engine e4(32767); // 将种子值设置为32767

• 选择一个好的种子，与生成好的随机数所涉及的其他大多数事情相同，是极其困难的。可能最常用的方法是调用系统函数 time。这个函数定义在头文件 ctime 中，它返回从一个特定时刻到当前经过了多少秒。函数 time 接受单个指针参数， 它指向用于写入时间的数据结构。如果此指针为空， 则函数简单地返回时间；由于 time 返回以秒计的时间， 因此这种方式只适用于生成种子的间隔为秒级或更长的应用，如果程序作为一个自动过程的一部分反复运行，将 time 的返回值作为种子的方式就无效了；它可能多次使用的都是相同的种子：

default_random_engine e1(time(0)); 	// 稍微随机些的种子

随机数分布

• 除了总是生成 bool 类型的 bernoulli_distribution 外， 其他分布类型都是模板。每个模板都接受单个类型参数， 它指出了分布生成的结果类型。分布类与我们已经用过的其他类模板不同，它们限制了我们可以为模板类型指定哪此类型。一些分布模板只能用来生成浮点数， 而其他模板只能用来生成整数
• 分布模板定义了一个默认模板类型参数。整型分布的默认参数是 int, 生成浮点数的模板的默认参数是 double
  • 在下面的描述中， 我们可以用 float、double 或 long double 代替 RealT。用一个内置整型类型， 但不包括 bool 类型或任何 char 类型来代替 IntT （short、int、long、long long、unsigned short、unsigned int、unsigned long 或 unsigned long long)

// 空 <> 表示我们希望使用默认结果类型
uniform_real_distribution<> u(0, 1); 	// 默认生成 double 值

均匀分布

uniform_int_distribution<IntT> u(m, n);		// m, b 默认为 0,  `IntT` 对象可以表示的最大值
uniform_real_distribution<RealT> u(x, y);	// x, y 默认为 0, 1

• 生成指定类型的， 在给定包含范围内的值。m (或 x) 是可以返回的最小值； n (或 y)是最大值

---

生成随机实数

• 程序经常需要 0 到 1 之间的随机数。最常用但不正确的从 rand 获得一个随机浮点数的方法是用 rand() 的结果除以 RAND_MAX。这种方法不正确的原因是随机整数的精度通常低于随机浮点数， 这样， 有一些浮点值就永远不会被生成了
• 使用新标准库设施， 可以很容易地获得随机浮点数。我们可以定义一个 uniform_real_distribution 类型的对象，并让标准库来处理从随机整数到随机浮点数的映射：

default_random_engine e;  	// 生成无符号随机整数
//  0 到 1 (包含）的均匀分布
uniform_real_distribution<double> u(0, 1);
for (size_t i = 0; i < 10; ++i)
	cout << u(e) << " ";

伯努利分布

// 以给定概率 p 生成 true 
// p 的默认值为 0.5
bernoulli_distribution b(p);

// 分布是按采样大小为整型值 t, 概率为 p 生成的
// t 的默认值为 1, p 的默认值为 0.5
binomial_distribution<IntT> b(t, p);

// 每次试验成功的概率为 p
// p 的默认值为 0.5
geometric_distribution<IntT> g(p);

// k (整型值）次试验成功的概率为p
// k 的默认值为 1, p 的默认值为 0.5
negative_binomial_distribution<IntT> nb(k, p);

---

• 作为一个这种分布的例子， 我们可以编写一个程序， 这个程序与用户玩一个游戏。为了进行这个游戏， 其中一个游戏者必须先行。我们可以用一个值范围是 0 到 1 的 uniform_int_distribution 来选择先行的游戏者， 但也可以用伯努利分布来完成这个选择

string resp;
default_random_engine e; 	// e 应保持状态， 所以必须在循环外定义！
bernoulli_distribution b;	// 分布对象也应保持状态，在循环外定义；默认是 50 / 50 的机会
// 使用伯努利分布也可以方便的调整先行一方的概率
// bernoulli_distribution b(.55);

do {
	bool first = b(e); 		// 如果为 true, 则程序先行
	cout << (first ? "We go first" : "You get to go first") << endl;
	// ...
	cout << "play again? Enter 'yes' or 'no'" << endl;
} while (cin >> resp && resp[0] == 'y');

泊松分布

// 均值为 double 值 x 的分布
poisson_distribution<IntT> p(x);

// 指数分布， 参数 lambda 通过浮点值 lam 给出
// lam 的默认值为 1.0
exponential_distribution<RealT> e(lam);

// alpha (形状参数）为 a, beta (尺度参数）为 b
// 两者的默认值均为 1.0
gamma_distribution<RealT> g(a, b);

// 形状参数为 a, 尺度参数为 b 的分布
// 两者的默认值均为 1.0
weibull_distribution<RealT> w(a, b);

// a 的默认值为 0.0, b 的默认值为 1.0
extreme_value_distribution<RealT> e(a, b);

正态分布

// 均值为 m, 标准差为 s
// m 的默认值为 0.0, s 的默认值为 1.0
normal_distribution<RealT> n(m, s);

// 均值为 m, 标准差为 s
// m 的默认值为 0.0, s 的默认值为 1.0
lognormal_distribution<RealT> ln(m, s);

// 自由度为 x
// 默认值为 1.0
chi_squared_distribution<RealT> c(x);

// 位置参数 a 和尺度参数 b 的默认值分别为 0.0 和 1.0
cauchy_distribution<RealT> c(a, b);

// 自由度为 m 和 n; 默认值均为 1
fisher_f_distribution<RealT> f(m, n);

// 自由度为 n; n 的默认值均为 1
student_t_distribution<RealT> s(n);

---

default_random_engine e; 	// 生成随机整数
normal_distribution<> n(4, 1.5); // 均值 4，标准差 1.5 的正态分布 (默认类型为 double)
vector<unsigned> vals(9); 	// 9 个元素均为0

for (size_t i = 0; i != 200; ++i) {
	unsigned v = lround(n(e)); 	// 舍入到最接近的整数 (cmath 头文件中)
	// 由于使用的是正态分布， 我们期望生成的数中大约 99% 都在 0 到 8 之间
	if (v < vals.size()) 	// 如果结果在范围内
		++vals[v];			// 统计每个数出现了多少次
}

抽样分布

discrete_distribution<IntT> d(i, j);
discrete_distribution<IntT> d{il};

• i 和 j 是一个权重序列的输入迭代器， il 是一个权重的花括号列表。权重必须能转换为 double

---

// b、e 和w 是输入迭代器
piecewise_constant_distribution<RealT> pc(b, e, w);
piecewise_linear_distribution<RealT> pl(b, e, w);

随机数引擎

• 标准库定义了三个类，实现了不同的算法来生成随机数。标准库还定义了三个适配器，可以修改给定引擎生成的序列。引擎和引擎适配器类都是模板。与分布的参数不同， 这些引擎的参数更为复杂，且需深入了解特定引擎使用的数学知识。我们在这里列出所有引擎，以便读者对它们有所了解， 但介绍如何生成这些类型超出了本书的范围
• 标准库还定义了几个从引擎和适配器类型构造的类型。default_random_engine 类型是一个参数化的引擎类型的类型别名，参数化所用的变量的目的是在通常情况下获得好的性能。标准库还定义了几个类， 它们都是一个引擎或适配器的完全特例化版本。标准库定义的引擎和特例化版本如下：

// 某个其他引擎类型的类型别名， 目的是用于大多数情况
default_random_engine

// minstd_rand0 的乘数为 16807,  模为 2147483647, 增量为 0
// minstd_rand 的乘数为 48271, 模为 2147483647, 增量为 0
linear_congruential_engine

// mt19937 为 32 位无符号梅森旋转生成器
// mt19937_64 为 64 位无符号梅森旋转生成器
mersenne_twister_engine

// ranlux24_base 为 32 位无符号借位减法生成器
// ranlux48_base 为 64 位无符号借位减法生成器
subtract_with_carry_engine

// 引擎适配器， 将其底层引擎的结果丢弃。用要使用的底层引擎、块大小和旧块大小来参数化
// ranlux24 使用 ranlux24_base 引擎， 块大小为 223, 旧块大小为 23
// ranlux48 使用 ranlux48_base引擎， 块大小为 389, 旧块大小为 11
discard_block_engine

// 引擎适配器， 生成指定位数的随机数。用要使用的底层引擎、结果的位数以及保存生成的
// 二进制位的无符号整型类型来参数化。指定的位数必须小于指定的无符号类型所能保存的位数
independent_bits_engine

// 引擎适配器， 返回的就是底层引擎生成的数，但返回的顺序不同。用要使用的底层引擎和要混洗的元素数目来参数化
// knuth_b 使用 minstd_rand0 和表大小 256
shuffle_order_engine