许多不同的问题领域都需要随机数，例如
Boost 随机数生成器库为随机数生成器提供了一个具有良好定义属性的框架，以便生成器可以用于要求苛刻的数值计算和安全领域。 有关数值计算中随机数的一般介绍，请参阅
“C 数值食谱：科学计算的艺术”，William H. Press，Saul A. Teukolsky，William A. Vetterling，Brian P. Flannery，第二版，1992 年，第 274-328 页
根据问题领域的不同要求，可以使用不同种类的随机数生成器
所有变体都有一些共同的属性，概念（在 STL 意义上）称为 UniformRandomNumberGenerator。 此概念将在后续章节中定义。
此库的目标如下
均匀随机数生成器提供在给定范围内均匀分布的随机数序列。 范围可以是编译时固定的，也可以在对象运行时构造后（才）可用。
某个（有限）集合 S 的紧下界是 S 中的（唯一）成员 l，因此对于 S 中的所有 v，l <= v 成立。 同样，某个（有限）集合 S 的紧上界是 S 中的（唯一）成员 u，因此对于 S 中的所有 v，v <= u 成立。
在下表中，X 表示返回 T 类型对象的数字生成器类，v 是 X 的常量值。
表 31.1. UniformRandomNumberGenerator 要求
|
表达式 |
返回类型 |
先决条件/后置条件 |
|---|---|---|
|
|
|
|
|
|
|
- |
|
|
|
由 |
|
|
|
如果 |
成员函数 min、max 和 operator() 应具有分摊常数时间复杂度。
![[Note]](../../../doc/src/images/note.png) |
注意 |
|---|---|
|
对于整数生成器（即整数 理由：带 min 和 max 的范围描述有两个目的。 首先，它允许将值缩放到一些规范范围，例如 [0..1)。 其次，它描述了值的有效位，这可能与进一步处理相关。 对于整数，范围是闭区间 [min,max]，因为底层类型可能无法表示半开区间 [min,max+1)。 对于非整数，它是半开区间 [min, max)，因为这对于连续分布的边界情况更为实用。 |
|
注意 |
|---|---|
|
UniformRandomNumberGenerator 概念不需要 理由：未提供 |
非确定性均匀随机数生成器是基于某些随机过程的 UniformRandomNumberGenerator。 因此，它提供了一个真随机数序列。 此类过程的示例包括核衰变、齐纳二极管的噪声、量子粒子的隧穿、掷骰子、从瓮中抽签和抛硬币。 根据环境，网络数据包或键盘事件的到达间隔时间可能接近随机过程的近似值。
类 random_device 是非确定性随机数生成器的模型。
|
注意 |
|---|---|
这种类型的随机数生成器对于安全应用程序非常有用，在安全应用程序中，防止外部攻击者猜测数字并因此获得您的加密或身份验证密钥非常重要。 因此，此概念的模型应谨慎，不要泄漏任何信息，这在环境允许的范围内是可能的。 例如，可能建议在不再需要时显式清除任何临时存储。 |
伪随机数生成器是 UniformRandomNumberGenerator，它基于某些算法和内部状态提供确定性的伪随机数序列。 线性同余 和 逆同余 生成器是此类 伪随机数生成器的示例。 通常，这些生成器对其参数非常敏感。 为了防止使用错误的实现，外部测试套件应检查生成的序列和提供的验证值是否确实匹配。
Donald E. Knuth 在他的著作“计算机程序设计艺术，第 2 卷，第 3 版，Addison-Wesley，1997 年”中对伪随机数生成进行了广泛的概述。 特定生成器的描述包含其他参考文献。
|
注意 |
|---|---|
由于伪随机数生成器的状态必然是有限的，因此生成器返回的数字序列最终会循环。 |
除了 UniformRandomNumberGenerator 要求之外，伪随机数生成器还有一些附加要求。 在下表中，X 表示伪随机数生成器类，u 是 X 的值，i 是整数类型的值，s 是对 SeedSeq 进行建模的类型的值，j 是 unsigned long long 类型的值。
表 31.2. PseudoRandomNumberGenerator 要求
|
表达式 |
返回类型 |
先决条件/后置条件 |
|---|---|---|
|
|
- |
创建具有默认种子的生成器。 |
|
|
- |
创建一个生成器，并使用整数 |
|
|
- |
创建一个生成器，并从 SeedSeq |
|
|
|
将当前状态设置为与相应构造函数创建的状态相同。 |
|
|
|
将生成器推进 |
对伪随机数生成器建模的类也应建模 EqualityComparable，即实现 operator==。 如果两个伪随机数生成器从给定状态开始都返回相同的数字序列，则定义为等效。
对伪随机数生成器建模的类也应建模 Streamable 概念，即实现 operator<< 和 operator>>。 operator<< 将伪随机数生成器的所有当前状态写入给定的 ostream，以便 operator>> 可以在稍后时间恢复状态。 状态应以平台无关的方式写入，但假定用于写入和读取的 locales 是相同的。 具有恢复状态的伪随机数生成器和刚刚写入状态的原始生成器应等效。
对伪随机数生成器建模的类也应建模 CopyConstructible 和 Assignable 概念。 但是，请注意，原始副本和副本的序列是强相关的（实际上，它们是相同的），这可能使它们不适合某些问题领域。 因此，不鼓励复制伪随机数生成器； 它们应始终通过（非常量）引用传递。
类 rand48、minstd_rand 和 mt19937 是伪随机数生成器的模型。
|
注意 |
|---|---|
这种类型的随机数生成器对于数值计算、游戏和测试非常有用。 非零参数构造函数和 |
准随机数生成器是 UniformRandomNumberGenerator，它基于某些算法和内部状态提供确定性的准随机数序列。 Niederreiter base 2 生成器是此类 准随机数生成器 的示例。 “准”修饰符更清楚地表明，此类生成器生成的值既不是随机的也不是伪随机的，但它们形成低差异序列。 直观的想法是，低差异序列比伪随机序列分布更均匀。 例如，如果我们生成正方形上的 2D 点的低差异序列，则该正方形将更均匀地覆盖，并且落入正方形任何部分的点的数量将与整个正方形中点的数量成正比。 此类序列共享随机变量的一些属性，并且在某些应用（例如准蒙特卡洛方法）中，它们的较低差异是一个重要的优势。
|
注意 |
|---|---|
准蒙特卡洛方法使用低差异序列，例如 Niederreiter base 2 序列、Sobol 序列或 Faure 序列等。 使用低差异序列的优点是概率收敛速度更快。 准蒙特卡洛的收敛速度为 O(log(N)s/N)，而使用伪随机序列的蒙特卡洛方法的收敛速度为 O(N-0.5)。 |
Harold Niederreiter 在他的著作“随机数生成和准蒙特卡洛方法，工业与应用数学学会，1992 年”中对随机数生成和准蒙特卡洛方法进行了广泛的概述。
除了 UniformRandomNumberGenerator 要求之外，准随机数生成器还有一些附加要求。 在下表中，X 表示准随机数生成器类，u 是 X 的值，v 是 X 的常量值，j 是 unsigned long long 类型的值。
表 31.3. QuasiRandomNumberGenerator 要求
|
表达式 |
返回类型 |
先决条件/后置条件 |
|---|---|---|
|
|
- |
创建具有默认种子的 |
|
|
std::size_t |
准随机域的维度。 |
|
|
|
使用整数 |
|
|
|
将生成器推进 |
|
注意 |
|---|---|
|
对准随机数生成器建模的类也应建模 EqualityComparable，即实现 operator==。 如果两个准随机数生成器从给定状态开始都返回相同的数字序列，则定义为等效。
对准随机数生成器建模的类也应建模 Streamable 概念，即实现 operator<< 和 operator>>。 operator<< 将准随机数生成器的所有当前状态写入给定的 ostream，以便 operator>> 可以在稍后时间恢复状态。 状态应以平台无关的方式写入，但假定用于写入和读取的 locales 是相同的。 具有恢复状态的准随机数生成器和刚刚写入状态的原始生成器应等效。
对准随机数生成器建模的类也应建模 CopyConstructible 和 Assignable 概念。 但是，请注意，原始副本和副本的序列是强相关的（实际上，它们是相同的），这可能使它们不适合某些问题领域。 因此，不鼓励复制准随机数生成器； 它们应始终通过（非常量）引用传递。
类 niederreiter_base2、sobol、faure 是准随机数生成器的模型。
SeedSeq 表示可用于设置 PseudoRandomNumberGenerator 的初始状态的值序列。 i 和 j 是 RandomAccessIterator，其 value_type 是至少具有 32 位的无符号整数类型。
表 31.4. SeedSeq 要求
|
表达式 |
返回类型 |
先决条件/后置条件 |
复杂度 |
|---|---|---|---|
|
|
void |
将 32 位值存储到由 |
O(j - i) |
类 seed_seq 和库提供的每个 UniformRandomNumberGenerator 都是 SeedSeq 的模型。
随机分布根据某些分布生成随机数，并以均匀分布的随机值作为输入。 在下表中，X 表示返回 T 类型对象的随机分布类，u 是 X 的值，x 和 y 是 X 的（可能是常量）值，P 是分布的 param_type，p 是 P 的值，e 是满足 UniformRandomNumberGenerator 要求的任意类型的左值，返回 U 类型的值。
表 31.5. 随机分布要求（除了 CopyConstructible 和 Assignable 之外）
|
表达式 |
返回类型 |
先决条件/后置条件 |
复杂度 |
|---|---|---|---|
|
|
|
- |
编译时 |
|
|
|
一种存储分布参数的类型，但不存储用于生成随机变量的任何状态。 |
编译时 |
|
|
|
从其参数初始化分布 |
O(状态大小) |
|
|
|
|
常量 |
|
|
|
使用同一对象 |
|
|
|
|
等效于 X(p)(e)，但可以使用不同的（并且可能是更有效的）实现 |
|
|
|
|
返回分布的参数 |
O(状态大小) |
|
|
void |
设置分布的参数 |
O(状态大小) |
|
|
|
返回分布的最小值 |
常量 |
|
|
|
返回分布的最大值 |
常量 |
|
|
|
指示如果给定相等的生成器，两个分布是否将产生相同的随机变量序列 |
O(状态大小) |
|
|
|
|
O(状态大小) |
|
|
|
将分布 |
O(状态大小) |
|
|
|
恢复分布 |
O(状态大小) |
附加要求：重复调用 x(e) 生成的数字序列不会因在任何 x(e) 调用之间是否调用 os << x 而改变。 如果使用 os << x 写入文本表示形式，并且该表示形式使用 is >> y 恢复到相同类型或不同类型的对象 y 中，则重复调用 y(e) 将生成与重复调用 x(e) 相同的随机数序列。
此库提供了几个伪随机数生成器。 伪随机数生成器的质量关键取决于算法及其参数。 此库将算法实现为类模板，其中模板值参数隐藏在 namespace boost::random 中。 参数的任何特定选择都表示为 namespace boost 中适当专门化的 typedef。
此库中提供的伪随机数生成器是从少数几个系列中选择的，这些系列具有不同的底层操作原理，基于其性能和质量特征。 对于超过其周期的立方根的时间，没有哪个生成器能够生成与随机数无法区分的序列。 因此，周期为 232 或更小的生成器（它们中的大多数是线性同余生成器）仅适用于只需要几百个随机数的程序或模拟。
伪随机数生成器不应在程序执行期间频繁构造（初始化），原因有两个。 首先，初始化需要生成器内部状态的完全初始化。 因此，具有大量内部状态的生成器（见下文）初始化成本很高。 其次，初始化始终需要一些用作生成序列“种子”的值。 通常很难获得几个好的种子值。 例如，获得种子的一种方法是以可用的最高分辨率（例如，微秒或纳秒）确定当前时间。 当使用当时的时间作为种子再次初始化伪随机数生成器时，很可能它与作为首次初始化种子给出的时间之间的距离接近恒定（非随机）。 如果时钟的分辨率较低，则距离甚至可能为零，因此生成器会重新迭代相同的随机数序列。 对于某些应用程序，这是不合适的。
请注意，下面描述的所有伪随机数生成器都是 CopyConstructible 和 Assignable。 复制或分配生成器将复制其所有内部状态，因此原始生成器和副本生成器将生成相同的随机数序列。 通常，不希望出现这种行为。 特别是，请注意标准库中的算法，例如 std::generate。 它们按值获取 functor 参数，从而在调用时调用复制构造函数。
下表概述了生成器的一些特性。 循环长度是对生成器质量的粗略估计； 近似相对速度是性能指标，数字越高表示随机数生成速度越快。
表 31.6. 生成器
|
生成器 |
循环长度 |
近似内存要求 |
与最快速度相比的近似速度 |
注释 |
|---|---|---|---|---|
|
231-2 |
|
16% |
- |
|
|
231-2 |
|
16% |
- |
|
|
248-1 |
|
64% |
- |
|
|
约 261 |
|
7% |
- |
|
|
231-2 |
|
12% |
- |
|
|
? |
|
37% |
- |
|
|
~288 |
|
100% |
- |
|
|
231-1 |
|
2% |
在多个维度上具有良好的均匀分布 |
|
|
211213-1 |
|
100% |
在高达 350 维的空间中具有良好的均匀分布 |
|
|
219937-1 |
|
93% |
在高达 623 维的空间中具有良好的均匀分布 |
|
|
219937-1 |
|
38% |
在高达 311 维的空间中具有良好的均匀分布 |
|
|
__mixmax |
~10294 |
152 |
|
在高达 17 维的空间中，无条件保证 MC 收敛 |
|
~232000 |
|
59% |
- |
|
|
~267000 |
|
59% |
- |
|
|
~2120000 |
|
61% |
- |
|
|
~2170000 |
|
62% |
- |
|
|
~2230000 |
|
59% |
- |
|
|
~2510000 |
|
61% |
- |
|
|
~21050000 |
|
59% |
- |
|
|
~21200000 |
|
61% |
- |
|
|
~22300000 |
|
59% |
- |
|
|
~10171 |
|
5% |
- |
|
|
~10171 |
|
3% |
- |
|
|
~10171 |
|
5% |
- |
|
|
~10171 |
|
3% |
- |
|
|
~10171 |
|
5% |
- |
|
|
~10171 |
|
3% |
- |
|
|
~10171 |
|
5% |
- |
|
|
~10171 |
|
3% |
- |
|
|
~10171 |
|
5% |
- |
|
|
~10171 |
|
3% |
- |
|
|
264 |
|
155% |
参见：https://prng.di.unimi.it |
|
|
2256 |
|
132% |
来自 https://prng.di.unimi.it 的 xoshiro256++ |
|
|
2256 |
|
139% |
此生成器返回 double 类型而非 uint64_t 类型。它是修改自 https://prng.di.unimi.it 的 xoshiro256+ |
|
|
2256 |
|
116% |
来自 https://prng.di.unimi.it 的 xoshiro256** |
|
|
2512 |
|
133% |
来自 https://prng.di.unimi.it 的 xoshiro512++ |
|
|
2512 |
|
144% |
此生成器返回 double 类型而非 uint64_t 类型。它是修改自 https://prng.di.unimi.it 的 xoshiro512+ |
|
|
2512 |
|
113% |
来自 https://prng.di.unimi.it 的 xoshiro512** |
|
|
2128 |
|
133% |
来自 https://prng.di.unimi.it 的 xoshiro128++。返回 uint32_t 类型 |
|
|
2128 |
|
145% |
此生成器返回 float 类型而非 uint32_t 类型。它是修改自 https://prng.di.unimi.it 的 xoshiro128+ |
|
|
2128 |
|
116% |
来自 https://prng.di.unimi.it 的 xoshiro128**。返回 uint32_t 类型 |
从表格中可以看出，在选择随机数生成器时，通常需要在质量/性能/内存之间进行权衡。此库中提供的多种生成器允许应用程序员针对其应用领域优化权衡。此外，对于给定的蒙特卡罗模拟应用，采用几种从根本上不同的随机数生成器将提高结果的可信度。
如果这些生成器的名称对您来说很陌生，并且您不知道该使用哪个生成器，那么建议首先使用 xoshiro256pp：它速度快且质量高。
如果您需要 32 位返回值而不是 64 位，请优先选择 xoshiro128pp。
如果您需要 double 或 float 作为返回类型，请分别优先选择 xoshiro256d 或 xoshiro128f。
|
注意 |
|---|---|
这些随机数生成器不适用于需要非确定性随机数的应用程序。有关（希望）非确定性随机数生成器的选择，请参阅 |
除了 随机数生成器 之外，此库还提供分布函数，这些函数将一个分布（通常是某些生成器提供的均匀分布）映射到另一个分布。
通常，对于任何给定的映射，都有几种可能的实现方式。通常，可以在使用更多空间、更多次调用底层随机数源或更耗时的算术运算（例如三角函数）之间进行选择。此接口描述不强制要求任何特定的实现方式。但是，无法达到指定分布的某些值或在统计上不收敛到该分布的实现方式是不可接受的。
表 31.7. 均匀分布
|
分布 |
说明 |
示例 |
|---|---|---|
|
小整数集合上的离散均匀分布（远小于底层生成器的范围） |
从瓮中抽签 |
|
|
整数集合上的离散均匀分布；可以多次调用底层生成器以收集足够的随机性用于输出 |
从瓮中抽签 |
|
|
范围 [0,1) 上的连续均匀分布；其他分布的重要基础 |
- |
|
|
实数范围 [min, max) 上的连续均匀分布 |
对于范围 [0, 2pi)：随机抛掷一根棍子并测量其弧度角（假设角度均匀分布） |
表 31.8. 伯努利分布
|
分布 |
说明 |
示例 |
|---|---|---|
|
伯努利实验：具有可配置概率的离散布尔值分布 |
抛硬币（p=0.5） |
|
|
计数重复伯努利实验的结果 |
抛硬币 20 次并计数正面朝上的次数 |
|
|
测量重复伯努利实验结果之间的距离 |
多次掷骰子并计数直到第一次出现“6”的尝试次数 |
|
|
计数获得一定数量的成功所需的重复伯努利实验的失败次数。 |
抛硬币并计数在我们得到 3 次反面之前出现正面的次数 |
表 31.9. 泊松分布
|
分布 |
说明 |
示例 |
|---|---|---|
|
泊松分布 |
计数在固定时间内放射性物质发射的 α 粒子数量 |
|
|
指数分布 |
测量放射性物质发射的 α 粒子的到达间隔时间 |
|
|
伽马分布 |
- |
|
|
超指数分布 |
k 个并行服务器的服务时间，每个服务器具有给定的服务率和被选择的概率 |
|
|
威布尔分布 |
- |
|
|
极值分布 |
- |
|
|
贝塔分布 |
- |
|
|
拉普拉斯分布 |
- |
表 31.10. 正态分布
|
分布 |
说明 |
示例 |
|---|---|---|
|
计数（无限）重复伯努利实验的结果 |
抛硬币 10000 次并计数正面朝上的次数 |
|
|
对数正态分布（有时用于模拟） |
测量装配线工人的工作完成时间 |
|
|
卡方分布 |
- |
|
|
非中心卡方分布 |
- |
|
|
柯西分布 |
- |
|
|
费舍尔 F 分布 |
- |
|
|
学生 t 分布 |
- |
表 31.12. 其他分布
|
分布 |
说明 |
示例 |
|---|---|---|
|
三角形分布 |
- |
|
|
任意维度单位球体上的均匀分布 |
在地球（假设为球体）上选择一个随机点度过下一个假期 |
|
|
|
逆高斯分布 |
该分布用于建模非负、正偏斜数据，并在商业、生存分析、金融、医学甚至劳资纠纷解决中具有广泛的应用。 |
|
广义逆高斯分布 |
- |
namespace boost { namespace random { template<typename MLCG1, typename MLCG2> class additive_combine_engine; typedef additive_combine_engine< linear_congruential_engine< uint32_t, 40014, 0, 2147483563 >, linear_congruential_engine< uint32_t, 40692, 0, 2147483399 > > ecuyer1988; } }
namespace boost { namespace random { template<typename RealType = double> class bernoulli_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class beta_distribution; } }
namespace boost { namespace random { template<typename IntType = int, typename RealType = double> class binomial_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class cauchy_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class chi_squared_distribution; } }
namespace boost { namespace random { template<typename UniformRandomNumberGenerator, std::size_t p, std::size_t r> class discard_block_engine; } }
namespace boost { namespace random { template<typename IntType = int, typename WeightType = double> class discrete_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class exponential_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class extreme_value_distribution; } }
namespace boost { namespace random { template<typename RealType, typename SeqSizeT, typename PrimeTable = default_faure_prime_table> class faure_engine; typedef faure_engine< double, boost::uint_least64_t, default_faure_prime_table > faure; } }
namespace boost { namespace random { template<typename RealType = double> class fisher_f_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class gamma_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class generalized_inverse_gaussian_distribution; } }
namespace boost { namespace random { template<typename RealType, std::size_t bits, typename URNG> RealType generate_canonical(URNG &); } }
namespace boost { namespace random { template<typename IntType = int, typename RealType = double> class geometric_distribution; } }
namespace boost { namespace random { template<typename RealT = double> class hyperexponential_distribution; } }
namespace boost { namespace random { template<typename Engine, std::size_t w, typename UIntType> class independent_bits_engine; } }
namespace boost { namespace random { template<typename IntType, IntType a, IntType b, IntType p> class inversive_congruential_engine; typedef inversive_congruential_engine< uint32_t, 9102, 2147483647-36884165, 2147483647 > hellekalek1995; } }
namespace boost { namespace random { template<typename RealType, int w, unsigned int p, unsigned int q> class lagged_fibonacci_01_engine; template<typename UIntType, int w, unsigned int p, unsigned int q> class lagged_fibonacci_engine; typedef lagged_fibonacci_01_engine< double, 48, 607, 273 > lagged_fibonacci607; typedef lagged_fibonacci_01_engine< double, 48, 1279, 418 > lagged_fibonacci1279; typedef lagged_fibonacci_01_engine< double, 48, 2281, 1252 > lagged_fibonacci2281; typedef lagged_fibonacci_01_engine< double, 48, 3217, 576 > lagged_fibonacci3217; typedef lagged_fibonacci_01_engine< double, 48, 4423, 2098 > lagged_fibonacci4423; typedef lagged_fibonacci_01_engine< double, 48, 9689, 5502 > lagged_fibonacci9689; typedef lagged_fibonacci_01_engine< double, 48, 19937, 9842 > lagged_fibonacci19937; typedef lagged_fibonacci_01_engine< double, 48, 23209, 13470 > lagged_fibonacci23209; typedef lagged_fibonacci_01_engine< double, 48, 44497, 21034 > lagged_fibonacci44497; } }
namespace boost { namespace random { template<typename RealType = double> class laplace_distribution; } }
namespace boost { namespace random { template<typename IntType, IntType a, IntType c, IntType m> class linear_congruential_engine; class rand48; typedef linear_congruential_engine< uint32_t, 16807, 0, 2147483647 > minstd_rand0; typedef linear_congruential_engine< uint32_t, 48271, 0, 2147483647 > minstd_rand; } }
namespace boost { namespace random { template<typename UIntType, int w, int k, int q, int s> class linear_feedback_shift_engine; } }
namespace boost { namespace random { template<typename RealType = double> class lognormal_distribution; } }
BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD
namespace boost { namespace random { template<typename 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; typedef mersenne_twister_engine< uint32_t, 32, 351, 175, 19, 0xccab8ee7, 11, 0xffffffff, 7, 0x31b6ab00, 15, 0xffe50000, 17, 1812433253 > mt11213b; typedef mersenne_twister_engine< uint32_t, 32, 624, 397, 31, 0x9908b0df, 11, 0xffffffff, 7, 0x9d2c5680, 15, 0xefc60000, 18, 1812433253 > mt19937; typedef mersenne_twister_engine< uint64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ull,29, 0x5555555555555555ull,17, 0x71d67fffeda60000ull,37, 0xfff7eee000000000ull,43, 6364136223846793005ull > mt19937_64; } }
namespace boost { namespace random { template<int Ndim, unsigned int SPECIALMUL, std::int64_t SPECIAL> class mixmax_engine; typedef mixmax_engine< 17, 36, 0 > mixmax; } }
namespace boost { namespace random { template<typename IntType = int, typename RealType = double> class negative_binomial_distribution; } }
namespace boost { namespace random { template<typename UIntType, unsigned w, typename Nb2Table = default_niederreiter_base2_table> class niederreiter_base2_engine; typedef niederreiter_base2_engine< boost::uint_least64_t, 64u, default_niederreiter_base2_table > niederreiter_base2; } }
namespace boost { namespace random { template<typename RealType = double> class non_central_chi_squared_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class normal_distribution; } }
namespace boost { namespace random { template<typename RealType = double, typename WeightType = double> class piecewise_constant_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class piecewise_linear_distribution; } }
namespace boost { namespace random { template<typename IntType = int, typename RealType = double> class poisson_distribution; } }
namespace boost { namespace random { class random_device; } }
namespace boost { namespace random { template<typename URNG, typename IntType = long> class random_number_generator; } }
namespace boost { namespace random { typedef subtract_with_carry_engine< uint32_t, 24, 10, 24 > ranlux_base; typedef subtract_with_carry_01_engine< float, 24, 10, 24 > ranlux_base_01; typedef subtract_with_carry_01_engine< double, 48, 10, 24 > ranlux64_base_01; typedef discard_block_engine< ranlux_base, 223, 24 > ranlux3; typedef discard_block_engine< ranlux_base, 389, 24 > ranlux4; typedef discard_block_engine< ranlux_base_01, 223, 24 > ranlux3_01; typedef discard_block_engine< ranlux_base_01, 389, 24 > ranlux4_01; typedef discard_block_engine< ranlux64_base_01, 223, 24 > ranlux64_3_01; typedef discard_block_engine< ranlux64_base_01, 389, 24 > ranlux64_4_01; typedef subtract_with_carry_engine< uint64_t, 48, 10, 24 > ranlux64_base; typedef discard_block_engine< ranlux64_base, 223, 24 > ranlux64_3; typedef discard_block_engine< ranlux64_base, 389, 24 > ranlux64_4; typedef subtract_with_carry_engine< uint32_t, 24, 10, 24 > ranlux24_base; typedef subtract_with_carry_engine< uint64_t, 48, 5, 12 > ranlux48_base; typedef discard_block_engine< ranlux24_base, 223, 23 > ranlux24; typedef discard_block_engine< ranlux48_base, 389, 11 > ranlux48; } }
namespace boost { namespace random { class seed_seq; } }
namespace boost { namespace random { template<typename UniformRandomNumberGenerator, std::size_t k> class shuffle_order_engine; typedef shuffle_order_engine< linear_congruential_engine< uint32_t, 1366, 150889, 714025 >, 97 > kreutzer1986; typedef shuffle_order_engine< minstd_rand0, 256 > knuth_b; } }
namespace boost { namespace random { template<typename UIntType, unsigned w, typename SobolTables = default_sobol_table> class sobol_engine; typedef sobol_engine< boost::uint_least64_t, 64u, default_sobol_table > sobol; } }
namespace boost { namespace random { class splitmix64; } }
namespace boost { namespace random { template<typename RealType = double> class student_t_distribution; } }
namespace boost { namespace random { template<typename RealType, std::size_t w, std::size_t s, std::size_t r> class subtract_with_carry_01_engine; template<typename IntType, std::size_t w, std::size_t s, std::size_t r> class subtract_with_carry_engine; } }
namespace boost { namespace random { typedef xor_combine_engine< xor_combine_engine< linear_feedback_shift_engine< uint32_t, 32, 31, 13, 12 >, 0, linear_feedback_shift_engine< uint32_t, 32, 29, 2, 4 >, 0 >, 0, linear_feedback_shift_engine< uint32_t, 32, 28, 3, 17 >, 0 > taus88; } }
namespace boost { namespace random { namespace traits { template<typename T> struct is_integral; template<typename T> struct is_signed; template<typename T> struct make_unsigned; template<typename T> struct make_unsigned_or_unbounded; } } }
namespace boost { namespace random { template<typename RealType = double> class triangle_distribution; } }
namespace boost { namespace random { template<typename RealType = double> class uniform_01; } }
namespace boost { namespace random { template<typename IntType = int> class uniform_int_distribution; } }
namespace boost { namespace random { template<typename RealType = double, typename Cont = std::vector<RealType> > class uniform_on_sphere; } }
namespace boost { namespace random { template<typename RealType = double> class uniform_real_distribution; } }
namespace boost { namespace random { template<typename IntType = int> class uniform_smallint; } }
namespace boost { template<typename Engine, typename Distribution> class variate_generator; }
namespace boost { namespace random { template<typename RealType = double> class weibull_distribution; } }
namespace boost { namespace random { template<typename URNG1, int s1, typename URNG2, int s2> class xor_combine_engine; } }
namespace boost { namespace random { class xoshiro128f; class xoshiro128mm; class xoshiro128pp; class xoshiro256d; class xoshiro256mm; class xoshiro256pp; class xoshiro512d; class xoshiro512mm; class xoshiro512pp; } }
