標準ライブラリヘッダ <random>

 

C++

言語

標準ライブラリヘッダ

フリースタンディング処理系とホスト処理系

名前付き要件

言語サポートライブラリ

コンセプトライブラリ(C++20)

診断ライブラリ

ユーティリティライブラリ

文字列ライブラリ

コンテナライブラリ

イテレータライブラリ

範囲ライブラリ(C++20)

アルゴリズムライブラリ

数値演算ライブラリ

ローカライゼーションライブラリ

入出力ライブラリ

ファイルシステムライブラリ(C++17)

正規表現ライブラリ(C++11)

アトミック操作ライブラリ(C++11)

スレッドサポートライブラリ(C++11)

技術仕様書

 

標準ライブラリヘッダ

言語サポート
<cstddef> <cstdlib> <version> <limits> <climits>	<cfloat> <cstdint> <new> <typeinfo>	<source_location> <exception> <initializer_list> <compare>	<coroutine> <csignal> <csetjmp> <cstdarg>
コンセプト
<concepts>
診断
<stdexcept>	<cassert>	<cerrno>	<system_error>
汎用ユーティリティ
<utility> <memory> <memory_resource> <scoped_allocator>	<bitset> <tuple> <optional> <any>	<variant> <type_traits> <ratio> <chrono>	<typeindex> <functional> <ctime>
文字列
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
ローカライゼーション
<locale>	<codecvt>	<clocale>
コンテナ
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
イテレータ
<iterator>
範囲
<ranges>
アルゴリズム
<algorithm>	<execution>
数値演算
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
入出力
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <spanstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
正規表現
<regex>
ファイルシステムサポート
<filesystem>
スレッドサポート
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable> <future>	<stop_token> <semaphore>	<latch> <barrier>
C互換
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath> <stdatomic.h>

 

このヘッダは擬似乱数生成ライブラリの一部です。

インクルード
<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)	キャリー付き減算 (ラグ付きフィボナッチ法) のアルゴリズムを実装します (クラステンプレート)
乱数エンジンアダプタ
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> Martin Lüscher と Fred James による24ビットの RANLUX ジェネレータ (1994年)
ranlux48(C++11)	std::discard_block_engine<std::ranlux48_base, 389, 11> Martin Lüscher と Fred James による48ビットの RANLUX ジェネレータ (1994年)
knuth_b(C++11)	std::shuffle_order_engine<std::minstd_rand0, 256>
default_random_engine(C++11)	処理系定義
非決定的な乱数
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) 内に一様に分布した、与えられた精度における実数値 (関数テンプレート)

概要

#include <initializer_list>   namespace std {// uniform random bit generator requirementstemplate<class G> concept uniform_random_bit_generator =/* see description */;   // class template linear_congruential_enginetemplate<class UIntType, UIntType a, UIntType c, UIntType m>class linear_congruential_engine;   // class template mersenne_twister_enginetemplate<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;   // class template subtract_with_carry_enginetemplate<class UIntType, size_t w, size_t s, size_t r>class subtract_with_carry_engine;   // class template discard_block_enginetemplate<class Engine, size_t p, size_t r>class discard_block_engine;   // class template independent_bits_enginetemplate<class Engine, size_t w, class UIntType>class independent_bits_engine;   // class template shuffle_order_enginetemplate<class Engine, size_t k>class shuffle_order_engine;   // engines and engine adaptors with predefined parametersusing minstd_rand0 =/* see description */;using minstd_rand =/* see description */;using mt19937 =/* see description */;using mt19937_64 =/* see description */;using ranlux24_base =/* see description */;using ranlux48_base =/* see description */;using ranlux24 =/* see description */;using ranlux48 =/* see description */;using knuth_b =/* see description */;   using default_random_engine =/* see description */;   // class random_deviceclass random_device;   // class seed_seqclass seed_seq;   // function template generate_canonicaltemplate<class RealType, size_t bits, class URBG> RealType generate_canonical(URBG& g);   // class template uniform_int_distributiontemplate<class IntType =int>class uniform_int_distribution;   // class template uniform_real_distributiontemplate<class RealType =double>class uniform_real_distribution;   // class bernoulli_distributionclass bernoulli_distribution;   // class template binomial_distributiontemplate<class IntType =int>class binomial_distribution;   // class template geometric_distributiontemplate<class IntType =int>class geometric_distribution;   // class template negative_binomial_distributiontemplate<class IntType =int>class negative_binomial_distribution;   // class template poisson_distributiontemplate<class IntType =int>class poisson_distribution;   // class template exponential_distributiontemplate<class RealType =double>class exponential_distribution;   // class template gamma_distributiontemplate<class RealType =double>class gamma_distribution;   // class template weibull_distributiontemplate<class RealType =double>class weibull_distribution;   // class template extreme_value_distributiontemplate<class RealType =double>class extreme_value_distribution;   // class template normal_distributiontemplate<class RealType =double>class normal_distribution;   // class template lognormal_distributiontemplate<class RealType =double>class lognormal_distribution;   // class template chi_squared_distributiontemplate<class RealType =double>class chi_squared_distribution;   // class template cauchy_distributiontemplate<class RealType =double>class cauchy_distribution;   // class template fisher_f_distributiontemplate<class RealType =double>class fisher_f_distribution;   // class template student_t_distributiontemplate<class RealType =double>class student_t_distribution;   // class template discrete_distributiontemplate<class IntType =int>class discrete_distribution;   // class template piecewise_constant_distributiontemplate<class RealType =double>class piecewise_constant_distribution;   // class template piecewise_linear_distributiontemplate<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:// typesusing result_type = UIntType;   // engine characteristicsstaticconstexpr result_type multiplier = a;staticconstexpr result_type increment = c;staticconstexpr result_type modulus = m;staticconstexpr result_type min(){return c == 0u ? 1u: 0u;}staticconstexpr result_type max(){return m - 1u;}staticconstexpr result_type default_seed = 1u;   // constructors and seeding functions 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);   // generating functions result_type operator()();void discard(unsignedlonglong z);};}

クラステンプレート 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:// typesusing result_type = UIntType;   // engine characteristicsstaticconstexpr size_t word_size = w;staticconstexpr size_t state_size = n;staticconstexpr size_t shift_size = m;staticconstexpr size_t mask_bits = r;staticconstexpr UIntType xor_mask = a;staticconstexpr size_t tempering_u = u;staticconstexpr UIntType tempering_d = d;staticconstexpr size_t tempering_s = s;staticconstexpr UIntType tempering_b = b;staticconstexpr size_t tempering_t = t;staticconstexpr UIntType tempering_c = c;staticconstexpr size_t tempering_l = l;staticconstexpr UIntType initialization_multiplier = f;staticconstexpr result_type min(){return0;}staticconstexpr result_type max(){return/* pow(2, w) - 1 */;}staticconstexpr result_type default_seed = 5489u;   // constructors and seeding functions 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);   // generating functions result_type operator()();void discard(unsignedlonglong z);};}

クラステンプレート 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:// typesusing result_type = UIntType;   // engine characteristicsstaticconstexpr size_t word_size = w;staticconstexpr size_t short_lag = s;staticconstexpr size_t long_lag = r;staticconstexpr result_type min(){return0;}staticconstexpr result_type max(){return/* pow(2, w) - 1 */;}staticconstexpr result_type default_seed = 19780503u;   // constructors and seeding functions subtract_with_carry_engine(): subtract_with_carry_engine(default_seed){}explicit subtract_with_carry_engine(result_type value);template<class Sseq>explicit subtract_with_carry_engine(Sseq& q);void seed(result_type value = default_seed);template<class Sseq>void seed(Sseq& q);   // generating functions result_type operator()();void discard(unsignedlonglong z);};}

クラステンプレート std::discard_block_engine

namespace std {template<class Engine, size_t p, size_t r>class discard_block_engine {public:// typesusing result_type =typename Engine::result_type;   // engine characteristicsstaticconstexpr size_t block_size = p;staticconstexpr size_t used_block = r;staticconstexpr result_type min(){return Engine::min();}staticconstexpr result_type max(){return Engine::max();}   // constructors and seeding functions 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);   // generating functions result_type operator()();void discard(unsignedlonglong z);   // property functionsconst Engine& base()constnoexcept{return e;};   private: Engine e;// exposition onlyint n;// exposition only};}

クラステンプレート std::independent_bits_engine

namespace std {template<class Engine, size_t w, class UIntType>class independent_bits_engine {public:// typesusing result_type = UIntType;   // engine characteristicsstaticconstexpr result_type min(){return0;}staticconstexpr result_type max(){return/* pow(2, w) - 1 */;}   // constructors and seeding functions 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);   // generating functions result_type operator()();void discard(unsignedlonglong z);   // property functionsconst Engine& base()constnoexcept{return e;};   private: Engine e;// exposition only};}

クラステンプレート std::shuffle_order_engine

namespace std {template<class Engine, size_t k>class shuffle_order_engine {public:// typesusing result_type =typename Engine::result_type;   // engine characteristicsstaticconstexpr size_t table_size = k;staticconstexpr result_type min(){return Engine::min();}staticconstexpr result_type max(){return Engine::max();}   // constructors and seeding functions 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);   // generating functions result_type operator()();void discard(unsignedlonglong z);   // property functionsconst Engine& base()constnoexcept{return e;};   private: Engine e;// exposition only result_type V[k];// exposition only result_type Y;// exposition only};}

定義済みのパラメータを持つエンジンおよびエンジンアダプタ

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 = /* implementation-defined */; }

クラス std::random_device

namespace std {class random_device {public:// typesusing result_type =unsignedint;   // generator characteristicsstaticconstexpr result_type min(){return numeric_limits<result_type>::min();}staticconstexpr result_type max(){return numeric_limits<result_type>::max();}   // constructors random_device(): random_device(/* implementation-defined */){}explicit random_device(const string& token);   // generating functions result_type operator()();   // property functionsdouble entropy()constnoexcept;   // no copy functions random_device(const random_device&)= delete;void operator=(const random_device&)= delete;};}

クラス std::seed_seq

namespace std {class seed_seq {public:// typesusing result_type = uint_least32_t;   // constructors seed_seq();template<class T> seed_seq(initializer_list<T> il);template<class InputIt> seed_seq(InputIt begin, InputIt end);   // generating functionstemplate<class RandomAccessIt>void generate(RandomAccessIt begin, RandomAccessIt end);   // property functions size_t size()constnoexcept;template<class OutputIt>void param(OutputIt dest)const;   // no copy functions seed_seq(const seed_seq&)= delete;void operator=(const seed_seq&)= delete;   private: vector<result_type> v;// exposition only};}

クラステンプレート std::uniform_int_distribution

namespace std {template<class IntType =int>class uniform_int_distribution {public:// typesusing result_type = IntType;using param_type =/* unspecified */;   // constructors and reset functions 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions 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;};}

クラステンプレート std::uniform_real_distribution

namespace std {template<class RealType =double>class uniform_real_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructors and reset functions 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions 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;};}

クラス std::bernoulli_distribution

namespace std {class bernoulli_distribution {public:// typesusing result_type =bool;using param_type =/* unspecified */;   // constructors and reset functions bernoulli_distribution(): bernoulli_distribution(0.5){}explicit bernoulli_distribution(double p);explicit bernoulli_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functionsdouble p()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::binomial_distribution

namespace std {template<class IntType =int>class binomial_distribution {public:// typesusing result_type = IntType;using param_type =/* unspecified */;   // constructors and reset functions binomial_distribution(): binomial_distribution(1){}explicit binomial_distribution(IntType t, double p =0.5);explicit binomial_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions IntType t()const;double p()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::geometric_distribution

namespace std {template<class IntType =int>class geometric_distribution {public:// typesusing result_type = IntType;using param_type =/* unspecified */;   // constructors and reset functions geometric_distribution(): geometric_distribution(0.5){}explicit geometric_distribution(double p);explicit geometric_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functionsdouble p()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::negative_binomial_distribution

namespace std {template<class IntType =int>class negative_binomial_distribution {public:// typesusing result_type = IntType;using param_type =/* unspecified */;   // constructor and reset functions 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions IntType k()const;double p()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::poisson_distribution

namespace std {template<class IntType =int>class poisson_distribution {public:// typesusing result_type = IntType;using param_type =/* unspecified */;   // constructors and reset functions poisson_distribution(): poisson_distribution(1.0){}explicit poisson_distribution(double mean);explicit poisson_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functionsdouble mean()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::exponential_distribution

namespace std {template<class RealType =double>class exponential_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructors and reset functions exponential_distribution(): exponential_distribution(1.0){}explicit exponential_distribution(RealType lambda);explicit exponential_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType lambda()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::gamma_distribution

namespace std {template<class RealType =double>class gamma_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructors and reset functions gamma_distribution(): gamma_distribution(1.0){}explicit gamma_distribution(RealType alpha, RealType beta =1.0);explicit gamma_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType alpha()const; RealType beta()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::weibull_distribution

namespace std {template<class RealType =double>class weibull_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions weibull_distribution(): weibull_distribution(1.0){}explicit weibull_distribution(RealType a, RealType b =1.0);explicit weibull_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType a()const; RealType b()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::extreme_value_distribution

namespace std {template<class RealType =double>class extreme_value_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType a()const; RealType b()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::normal_distribution

namespace std {template<class RealType =double>class normal_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructors and reset functions normal_distribution(): normal_distribution(0.0){}explicit normal_distribution(RealType mean, RealType stddev =1.0);explicit normal_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType mean()const; RealType stddev()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::lognormal_distribution

namespace std {template<class RealType =double>class lognormal_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions lognormal_distribution(): lognormal_distribution(0.0){}explicit lognormal_distribution(RealType m, RealType s =1.0);explicit lognormal_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType m()const; RealType s()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::chi_squared_distribution

namespace std {template<class RealType =double>class chi_squared_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions chi_squared_distribution(): chi_squared_distribution(1.0){}explicit chi_squared_distribution(RealType n);explicit chi_squared_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType n()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::cauchy_distribution

namespace std {template<class RealType =double>class cauchy_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions cauchy_distribution(): cauchy_distribution(0.0){}explicit cauchy_distribution(RealType a, RealType b =1.0);explicit cauchy_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType a()const; RealType b()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};

クラステンプレート std::fisher_f_distribution

namespace std {template<class RealType =double>class fisher_f_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType m()const; RealType n()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::student_t_distribution

namespace std {template<class RealType =double>class student_t_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions student_t_distribution(): student_t_distribution(1.0){}explicit student_t_distribution(RealType n);explicit student_t_distribution(const param_type& parm);void reset();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions RealType n()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::discrete_distribution

namespace std {template<class IntType =int>class discrete_distribution {public:// typesusing result_type = IntType;using param_type =/* unspecified */;   // constructor and reset functions discrete_distribution();template<class InputIt> discrete_distribution(InputIt firstW, InputIt 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions vector<double> probabilities()const; param_type param()const;void param(const param_type& parm); result_type min()const; result_type max()const;};}

クラステンプレート std::piecewise_constant_distribution

namespace std {template<class RealType =double>class piecewise_constant_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions piecewise_constant_distribution();template<class InputItB, class InputItW> piecewise_constant_distribution(InputItB firstB, InputItB lastB, InputItW 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions 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;};}

クラステンプレート std::piecewise_linear_distribution

namespace std {template<class RealType =double>class piecewise_linear_distribution {public:// typesusing result_type = RealType;using param_type =/* unspecified */;   // constructor and reset functions piecewise_linear_distribution();template<class InputItB, class InputItW> piecewise_linear_distribution(InputItB firstB, InputItB lastB, InputItW 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();   // generating functionstemplate<class URBG> result_type operator()(URBG& g);template<class URBG> result_type operator()(URBG& g, const param_type& parm);   // property functions 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;};}