C++初学者指南-5.标准库(第二部分)--随机数生成
文章目录
基本概念
#include <random>
random_engine_type engine {seed};
distribution_type distribution {parameters,...};
auto random_value = distribution(engine);
随机性的来源与分布是解耦的。
随机数是由分布产生的
分布使用均匀随机位引擎作为随机性源
此设计的优点没有单个全局状态，可以使用多个独立的随机引擎
新的分发类型可以使用现有引擎
可以更改随机性源，同时保持分布类型 （例如，将确定性引擎更改为使用硬件熵的引擎）
例子
统一随机数
cpp
#include <random>
// fixed seed(固定种子)
auto const seed = 123;
// Mersenne Twister random engine(梅森旋转随机引擎):
std::mt19937 urbg {seed};
// generate random ints ∈ [1,6](生成1-6之间的随机整数)
std::uniform_int_distribution<int> distr1 {1, 6};
auto const value1 = distr1(urbg);
auto const value2 = distr1(urbg);
// generate random floats ∈ [-1.2,6.25)(生成-1.2到6.25之间的随机浮点数)
std::uniform_real_distribution<float> distr2 {-1.2f, 6.25f};
auto const value3 = distr2(urbg);布尔值（"抛硬币"）
cpp
#include <random>
auto const seed = 123;
auto urbg = std::mt19937 {seed};
// unfair coin (40% 'true'):
double const p = 0.4;
auto flip = std::bernoulli_distribution{p};
if (flip(urbg)) // 40% chance
cout << "heads\n";
else // 60% chance
cout << "tails\n";
正态分布
cpp
#include <random>
auto const seed = 123;
auto urbg = std::mt19937 {seed};
double const mu = 4.0;
double const sigma = 0.7;
auto norm = std::normal_distribution<double>{mu,sigma};
auto value = norm(urbg);
具有独立概率的整数
cpp
#include <random>
auto const seed = std::random_device{}();
auto urbg = std::mt19937{seed};
std::vector<double> ws {1.0, 1.5, 0.5, 2.0};
std::discrete_distribution<int> distr {begin(ws), end(ws)};
std::vector<int> histo (ws.size(), 0);
int const N = 100000;
for (int k = 0; k < N; ++k) {
auto const i = distr(urbg);
++histo[i];
}
std::cout << "Histogram:\n";
for (auto x : histo) {
auto const size = int(30 * x/double(N));
cout << std::string(size,'-') << "o\n";
}
怎么做
种子引擎
- 使用一个整数类型的 engine_type::result_type
- 或使用种子序列
- 在构造函数中： engine_type { seed }
- 或者使用成员函数 .seed( seed };
cpp
#include <random>
#include <chrono> // clocks
auto e = std::mt19937{};
// seed engine with a constant
e.seed(123);
// ... or with system clock ticks
auto const ticks = std::chrono::system_clock::now().time_since_epoch().count();
e.seed(ticks);
// ... or with hardware entropy
auto const hes = std::random_device{}();
e.seed(hes);
// ... or with a seed sequence
std::seed_seq s {1,5,3,7,0,9};
e.seed(s);
auto distr = std::uniform_real_distribution{-11.0, 15.3};
cout << distr(e) << '\n';使用自定义生成器
Lambda生成器
- 在 lambda 捕获中初始化引擎和分发
- 重要：lambda 必须标记为 mutable 因为内部状态 引擎和分配需要随着每次调用而改变
cpp
#include <random>
auto const seed = std::random_device{}();
auto coin_flip = [
// init-capture engine + distribution:
urbg = std::mt19937{seed},
distr = std::bernoulli_distribution{0.5}
]() mutable -> bool { return distr(urbg); };
// use generator:
cout << coin_flip() << '\n';
auto roll = [
urbg = std::mt19937{seed},
distr = std::uniform_int_distribution<int>{1,6}
]() mutable -> int { return distr(urbg); };
cout << roll() << '\n';自定义生成器类
如果需要对参数进行更多控制
cpp
#include <random>
class DiceRoll {
using engine_type = std::mt19937;
// engine + distribution as members:
engine_type urbg_;
std::uniform_int_distribution<int> distr_;
public:
using seed_type = engine_type::result_type;
// constructor:
explicit
DiceRoll (int sides, seed_type seed = 0) noexcept:
urbg_{seed}, distr_{1,sides} {}
// allows to re-seed
void seed (seed_type s) noexcept { urbg_.seed(s); }
// call operator:
int operator () () noexcept { return distr_(urbg_); }
};
int main () {
auto const seed = std::random_device{}();
DiceRoll roll_d20 {20, seed};
std::cout << roll_d20() << '\n';
}shuffle算法
cpp
#include <algorithm>
#include <random>
// 32 bit mersenne twister engine
auto const seed = std::random_device{}();
auto reng = std::mt19937{seed};
std::vector<int> v {0,1,2,3,4,5,6,7,8};
shuffle(begin(v)+2, begin(v)+7, reng);
for (int x : v) { cout << x <<' '; } // 0 1 ... 7 8
分布类型概述
通用接口
构造
- distribution_type distr; // with default params
- distribution_type distr { parameter_object };
- distribution_type distr { parameter1, parameter2,... parameterN };
生成值auto random_value = distribution_object(engine_object);
常见访问器
distr.min() → smallest obtainable value(可获得的最小值)
distr.max() → largest obtainable value(可获得的最大值)
distr.param() → parameter object(参数对象)
distr.reset() : reset internal state(复位内部状态)
参数对象distribution_type::param_type pars { parameter1, parameter2,... parameterN };
distribution_type distr1 { pars };
distribution_type distr2 { pars };
distribution_type distr3 { distr1.param() };
分布-特定参数访问器distr.a() .b() .m() .n() .s() .alpha() .beta() .lambda() .mean() .stddev() ...
均匀分布
采样分布
伯努利分布
正态分布
泊松分布
概览表
引擎类型概述
通用引擎接口
线性同余引擎std::minstd_rand0 // 1969 by Lewis, Goodman, Miller
std::minstd_rand // 1993 by Park, Miller, Stockmeyer
std::linear_congruential_engine
梅森旋转引擎std::mt19937 // 32-bit, Matsumoto and Nishimura, 1998
std::mt19937_64 // 64-bit, Matsumoto and Nishimura, 2000
std::mersenne_twister_engine
带进位的减法引擎std::ranlux24_base
std::ranlux48_base
std::subtract_with_carry_engine
引擎适配器
std::discard_block_engine
std::independent_bits_engine
std::shuffle_order_engine基于适配器的引擎：
std::ranlux24 // discard_block_engine
std::ranlux48 // discard_block_engine
std::knuth_b // shuffle_order_engine
std::default_random_engine取决于编译器/平台；通常是线性同余生成器。
非确定性熵源
std::random_device表示一个非确定性随机数生成器，例如，使用硬件熵源。
如果没有可用的非确定性熵源，标准库的实现可以使用伪随机数引擎作为random_device。
测试设备是否真正是非确定性的:
std::random_device rd; bool non_deterministic = rd.entropy() > 0; bool deterministic = rd.entropy() == 0; auto distr = std::uniform_real_distribution{-1.0,1.0}; auto num = distr(rd);注意：一些（较旧的）标准库实现尽管其随机设备是非确定性的，但仍然返回0。
相关内容
Random Generator: Combining Engine + Distribution
Random Number Sequences: Control Reproducibility
cppreference: Pseudo-Random Number Generation
cppreference: std::generate_canonical
What C++ Programmers Need to Know about Header (Walter E. Brown, 2016)
如果文章对您有用，请随手点个赞，谢谢！^_^