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

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

目录 1 包含 2 概念 2.1 均匀随机位生成器要求 3 类 3.1 随机数引擎 3.2 随机数引擎适配器 3.3 预定义生成器 3.4 非确定性随机数 3.5 均匀分布 3.6 伯努利分布 3.7 泊松分布 3.8 正态分布 3.9 采样分布 3.10 工具 4 函数 5 概要 5.1 概念 uniform_random_bit_generator 5.2 类模板 std::linear_congruential_engine 5.3 类模板 std::mersenne_twister_engine 5.4 类模板 std::subtract_with_carry_engine 5.5 类模板 std::philox_engine 5.6 类模板 std::discard_block_engine 5.7 类模板 std::independent_bits_engine 5.8 类模板 std::shuffle_order_engine 5.9 带预定义形参的引擎及引擎适配器 5.10 类 std::random_device 5.11 类 std::seed_seq 5.12 类模板 std::uniform_int_distribution 5.13 类模板 std::uniform_real_distribution 5.14 类 std::bernoulli_distribution 5.15 类模板 std::binomial_distribution 5.16 类模板 std::geometric_distribution 5.17 类模板 std::negative_binomial_distribution 5.18 类模板 std::poisson_distribution 5.19 类模板 std::exponential_distribution 5.20 类模板 std::gamma_distribution 5.21 类模板 std::weibull_distribution 5.22 类模板 std::extreme_value_distribution 5.23 类模板 std::normal_distribution 5.24 类模板 std::lognormal_distribution 5.25 类模板 std::chi_squared_distribution 5.26 类模板 std::cauchy_distribution 5.27 类模板 std::fisher_f_distribution 5.28 类模板 std::student_t_distribution 5.29 类模板 std::discrete_distribution 5.30 类模板 std::piecewise_constant_distribution 5.31 类模板 std::piecewise_linear_distribution 包含
<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)	产生服从 χ² 分布的实数 (类模板) [编辑]
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_engine
  template<class UIntType, UIntType a, UIntType c, UIntType m>
  class linear_congruential_engine;                             // 部分独立

  // 类模板 mersenne_twister_engine
  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;                                // 部分独立

  // 类模板 subtract_with_carry_engine
  template<class UIntType, size_t w, size_t s, size_t r>
  class subtract_with_carry_engine;                             // 部分独立

  // 类模板 discard_block_engine
  template<class Engine, size_t p, size_t r>
  class discard_block_engine;                                   // 部分独立

  // 类模板 independent_bits_engine
  template<class Engine, size_t w, class UIntType>
  class independent_bits_engine;                                // 部分独立

  // 类模板 shuffle_order_engine
  template<class Engine, size_t k>
  class shuffle_order_engine;

  // 类模板 philox_engine
  template<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_device
  class random_device;

  // 类 seed_seq
  class seed_seq;

  // 函数模板 generate_canonical
  template<class RealType, size_t bits, class URBG>
  RealType generate_canonical(URBG& g);

  namespace ranges {
    // generate_random
    template<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_distribution
  template<class IntType = int>
  class uniform_int_distribution;                               // 部分独立

  // 类模板 uniform_real_distribution
  template<class RealType = double>
  class uniform_real_distribution;

  // 类 bernoulli_distribution
  class bernoulli_distribution;

  // 类模板 binomial_distribution
  template<class IntType = int>
  class binomial_distribution;

  // 类模板 geometric_distribution
  template<class IntType = int>
  class geometric_distribution;

  // 类模板 negative_binomial_distribution
  template<class IntType = int>
  class negative_binomial_distribution;

  // 类模板 poisson_distribution
  template<class IntType = int>
  class poisson_distribution;

  // 类模板 exponential_distribution
  template<class RealType = double>
  class exponential_distribution;

  // 类模板 gamma_distribution
  template<class RealType = double>
  class gamma_distribution;

  // 类模板 weibull_distribution
  template<class RealType = double>
  class weibull_distribution;

  // 类模板 extreme_value_distribution
  template<class RealType = double>
  class extreme_value_distribution;

  // 类模板 normal_distribution
  template<class RealType = double>
  class normal_distribution;

  // 类模板 lognormal_distribution
  template<class RealType = double>
  class lognormal_distribution;

  // 类模板 chi_squared_distribution
  template<class RealType = double>
  class chi_squared_distribution;

  // 类模板 cauchy_distribution
  template<class RealType = double>
  class cauchy_distribution;

  // 类模板 fisher_f_distribution
  template<class RealType = double>
  class fisher_f_distribution;

  // 类模板 student_t_distribution
  template<class RealType = double>
  class student_t_distribution;

  // 类模板 discrete_distribution
  template<class IntType = int>
  class discrete_distribution;

  // 类模板 piecewise_constant_distribution
  template<class RealType = double>
  class piecewise_constant_distribution;

  // 类模板 piecewise_linear_distribution
  template<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;

    // 引擎特征
    static constexpr result_type multiplier = a;
    static constexpr result_type increment  = c;
    static constexpr result_type modulus    = m;
    static constexpr result_type min() { return c == 0u ? 1u : 0u; }
    static constexpr result_type max() { return m - 1u; }
    static constexpr 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);

    // 相等性运算符
    friend bool operator==(const linear_congruential_engine& x,
                           const linear_congruential_engine& y);

    // 生成函数
    result_type operator()();
    void discard(unsigned long long 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;

    // 引擎特征
    static constexpr size_t word_size                   = w;
    static constexpr size_t state_size                  = n;
    static constexpr size_t shift_size                  = m;
    static constexpr size_t mask_bits                   = r;
    static constexpr UIntType xor_mask                  = a;
    static constexpr size_t tempering_u                 = u;
    static constexpr UIntType tempering_d               = d;
    static constexpr size_t tempering_s                 = s;
    static constexpr UIntType tempering_b               = b;
    static constexpr size_t tempering_t                 = t;
    static constexpr UIntType tempering_c               = c;
    static constexpr size_t tempering_l                 = l;
    static constexpr UIntType initialization_multiplier = f;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return /*2^w - 1*/; }
    static constexpr 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);

    // 相等性运算符
    friend bool operator==(const mersenne_twister_engine& x,
                           const mersenne_twister_engine& y);

    // 生成函数
    result_type operator()();
    void discard(unsigned long long 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;

    // 引擎特征
    static constexpr size_t word_size = w;
    static constexpr size_t short_lag = s;
    static constexpr size_t long_lag  = r;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return /*m - 1*/; }
    static constexpr 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);

    // 相等性运算符
    friend bool operator==(const subtract_with_carry_engine& x,
                           const subtract_with_carry_engine& y);

    // 生成函数
    result_type operator()();
    void discard(unsigned long long 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
  {
    static constexpr size_t /*array-size*/ = n / 2; // 仅用于阐述
  public:
    // 类型
    using result_type = UIntType;

    // 引擎特征
    static constexpr size_t word_size   = w;
    static constexpr size_t word_count  = n;
    static constexpr size_t round_count = r;
    static constexpr array<result_type, /*array-size*/> multipliers;
    static constexpr array < result_type, @exposition onlyid { array - size > }
    @round_consts;
    static constexpr result_type min() { return 0; }
    static constexpr result_type max() { return m - 1; }
    static constexpr 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);

    // 相等性运算符
    friend bool operator==(const philox_engine& x, const philox_engine& y);

    // 生成函数
    result_type operator()();
    void discard(unsigned long long 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;

    // 引擎特征
    static constexpr size_t block_size = p;
    static constexpr size_t used_block = r;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr 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);

    // 相等性运算符
    friend bool operator==(const discard_block_engine& x, const discard_block_engine& y);

    // 生成函数
    result_type operator()();
    void discard(unsigned long long z);

    // 属性函数
    const Engine& base() const noexcept { 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;

    // 引擎特征
    static constexpr result_type min() { return 0; }
    static constexpr 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);

    // 相等性运算符
    friend bool operator==(const independent_bits_engine& x,
                           const independent_bits_engine& y);

    // 生成函数
    result_type operator()();
    void discard(unsigned long long z);

    // 属性函数
    const Engine& base() const noexcept { 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;

    // 引擎特征
    static constexpr size_t table_size = k;
    static constexpr result_type min() { return Engine::min(); }
    static constexpr 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);

    // 相等性运算符
    friend bool operator==(const shuffle_order_engine& x, const shuffle_order_engine& y);

    // 生成函数
    result_type operator()();
    void discard(unsigned long long z);

    // 属性函数
    const Engine& base() const noexcept { 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 = unsigned int;

    // 生成器特征
    static constexpr result_type min() { return numeric_limits<result_type>::min(); }
    static constexpr result_type max() { return numeric_limits<result_type>::max(); }

    // 构造函数
    random_device()
      : random_device(/* 由实现定义 */)
    {
    }
    explicit random_device(const string& token);

    // 生成函数
    result_type operator()();

    // 属性函数
    double entropy() const noexcept;

    // 无复制函数
    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() const noexcept;
    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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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();

    // 相等性运算符
    friend bool 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);
  };
}

编译器支持
自立实现与有宿主实现
语言
标准库
标准库标头
具名要求
功能特性测试宏 (C++20)
语言支持库
概念库 (C++20)
诊断库
内存管理库
元编程库 (C++11)
通用工具库
容器库
迭代器库
范围库 (C++20)
算法库
字符串库
文本处理库
数值库
日期和时间库
输入/输出库
文件系统库 (C++17)
并发支持库 (C++11)
执行控制库 (C++26)
技术规范
符号索引
外部库

cppreference.com

搜索

命名空间

语言变体

查看

操作

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

包含

概念

均匀随机位生成器要求

类

随机数引擎

随机数引擎适配器

预定义生成器

非确定性随机数

均匀分布

伯努利分布

泊松分布

正态分布

采样分布

工具

函数

概要

概念 uniform_random_bit_generator

类模板 std::linear_congruential_engine

类模板 std::mersenne_twister_engine

类模板 std::subtract_with_carry_engine

类模板 std::philox_engine

类模板 std::discard_block_engine

类模板 std::independent_bits_engine

类模板 std::shuffle_order_engine

带预定义形参的引擎及引擎适配器

类 std::random_device

类 std::seed_seq

类模板 std::uniform_int_distribution

类模板 std::uniform_real_distribution

类 std::bernoulli_distribution

类模板 std::binomial_distribution

类模板 std::geometric_distribution

类模板 std::negative_binomial_distribution

类模板 std::poisson_distribution

类模板 std::exponential_distribution

类模板 std::gamma_distribution

类模板 std::weibull_distribution

类模板 std::extreme_value_distribution

类模板 std::normal_distribution

类模板 std::lognormal_distribution

类模板 std::chi_squared_distribution

类模板 std::cauchy_distribution

类模板 std::fisher_f_distribution

类模板 std::student_t_distribution

类模板 std::discrete_distribution

类模板 std::piecewise_constant_distribution

类模板 std::piecewise_linear_distribution

导航

工具

概念 `uniform_random_bit_generator`