37namespace std _GLIBCXX_VISIBILITY(default)
39_GLIBCXX_BEGIN_NAMESPACE_VERSION
56 template<
typename _RealType,
size_t __bits,
57 typename _UniformRandomNumberGenerator>
61_GLIBCXX_END_NAMESPACE_VERSION
68 _GLIBCXX_BEGIN_NAMESPACE_VERSION
70 template<
typename _UIntType,
size_t __w,
71 bool = __w < static_cast<size_t>
74 {
static const _UIntType __value = 0; };
76 template<
typename _UIntType,
size_t __w>
77 struct _Shift<_UIntType, __w, true>
78 {
static const _UIntType __value = _UIntType(1) << __w; };
81 int __which = ((__s <= __CHAR_BIT__ *
sizeof (int))
82 + (__s <= __CHAR_BIT__ *
sizeof (long))
83 + (__s <= __CHAR_BIT__ *
sizeof (
long long))
86 struct _Select_uint_least_t
88 static_assert(__which < 0,
89 "sorry, would be too much trouble for a slow result");
93 struct _Select_uint_least_t<__s, 4>
94 {
typedef unsigned int type; };
97 struct _Select_uint_least_t<__s, 3>
98 {
typedef unsigned long type; };
101 struct _Select_uint_least_t<__s, 2>
102 {
typedef unsigned long long type; };
104#ifdef _GLIBCXX_USE_INT128
106 struct _Select_uint_least_t<__s, 1>
107 {
typedef unsigned __int128 type; };
111 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
112 bool __big_enough = (!(__m & (__m - 1))
113 || (_Tp(-1) - __c) / __a >= __m - 1),
114 bool __schrage_ok = __m % __a < __m / __a>
117 typedef typename _Select_uint_least_t<
std::__lg(__a)
121 {
return static_cast<_Tp
>((_Tp2(__a) * __x + __c) % __m); }
125 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
126 struct _Mod<_Tp, __m, __a, __c, false, true>
135 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
136 struct _Mod<_Tp, __m, __a, __c, true, __s>
141 _Tp __res = __a * __x + __c;
148 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
151 {
return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
157 template<
typename _Engine,
typename _DInputType>
161 "template argument not a floating point type");
164 _Adaptor(_Engine& __g)
169 {
return _DInputType(0); }
173 {
return _DInputType(1); }
192 _GLIBCXX_END_NAMESPACE_VERSION
195_GLIBCXX_BEGIN_NAMESPACE_VERSION
235 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
239 "substituting _UIntType not an unsigned integral type");
240 static_assert(__m == 0
u || (__a < __m && __c < __m),
241 "template argument substituting __m out of bounds");
272 template<
typename _Sseq,
typename =
typename
295 template<
typename _Sseq>
307 {
return __c == 0
u ? 1u : 0
u; }
332 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
402 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
439 template<
typename _UIntType,
size_t __w,
440 size_t __n,
size_t __m,
size_t __r,
441 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
442 _UIntType __b,
size_t __t,
443 _UIntType __c,
size_t __l, _UIntType __f>
447 "substituting _UIntType not an unsigned integral type");
448 static_assert(1u <= __m && __m <= __n,
449 "template argument substituting __m out of bounds");
450 static_assert(__r <=
__w,
"template argument substituting "
452 static_assert(
__u <=
__w,
"template argument substituting "
454 static_assert(
__s <=
__w,
"template argument substituting "
456 static_assert(__t <=
__w,
"template argument substituting "
458 static_assert(
__l <=
__w,
"template argument substituting "
461 "template argument substituting __w out of bound");
462 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
463 "template argument substituting __a out of bound");
464 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
465 "template argument substituting __b out of bound");
466 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
467 "template argument substituting __c out of bound");
468 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
469 "template argument substituting __d out of bound");
470 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
471 "template argument substituting __f out of bound");
478 static constexpr size_t word_size =
__w;
479 static constexpr size_t state_size = __n;
480 static constexpr size_t shift_size = __m;
481 static constexpr size_t mask_bits = __r;
483 static constexpr size_t tempering_u =
__u;
485 static constexpr size_t tempering_s =
__s;
487 static constexpr size_t tempering_t = __t;
489 static constexpr size_t tempering_l =
__l;
490 static constexpr result_type initialization_multiplier = __f;
504 template<
typename _Sseq,
typename =
typename
514 template<
typename _Sseq>
530 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
573 size_t __m1,
size_t __r1,
578 typename _CharT,
typename _Traits>
599 size_t __m1,
size_t __r1,
604 typename _CharT,
typename _Traits>
614 _UIntType _M_x[state_size];
630 template<
typename _UIntType,
size_t __w,
631 size_t __n,
size_t __m,
size_t __r,
632 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
633 _UIntType __b,
size_t __t,
634 _UIntType __c,
size_t __l, _UIntType __f>
637 __r, __a,
__u, __d,
__s, __b, __t, __c,
__l, __f>&
__lhs,
658 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
662 "substituting _UIntType not an unsigned integral type");
663 static_assert(0
u <
__s &&
__s < __r,
664 "template argument substituting __s out of bounds");
666 "template argument substituting __w out of bounds");
673 static constexpr size_t word_size =
__w;
674 static constexpr size_t short_lag =
__s;
675 static constexpr size_t long_lag = __r;
676 static constexpr result_type default_seed = 19780503u;
692 template<
typename _Sseq,
typename =
typename
718 template<
typename _Sseq>
736 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
786 typename _CharT,
typename _Traits>
805 typename _CharT,
typename _Traits>
813 _UIntType _M_x[long_lag];
830 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
845 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
848 static_assert(1 <= __r && __r <= __p,
849 "template argument substituting __r out of bounds");
856 static constexpr size_t block_size = __p;
857 static constexpr size_t used_block = __r;
865 : _M_b(), _M_n(0) { }
875 : _M_b(
__rng), _M_n(0) { }
885 : _M_b(
std::move(
__rng)), _M_n(0) { }
895 : _M_b(
__s), _M_n(0) { }
902 template<
typename _Sseq,
typename =
typename
904 && !std::is_same<_Sseq, _RandomNumberEngine>::value>
938 template<
typename _Sseq>
950 const _RandomNumberEngine&
959 {
return _RandomNumberEngine::min(); }
966 {
return _RandomNumberEngine::max(); }
1012 typename _CharT,
typename _Traits>
1030 typename _CharT,
typename _Traits>
1037 _RandomNumberEngine _M_b;
1052 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1065 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1069 "substituting _UIntType not an unsigned integral type");
1071 "template argument substituting __w out of bounds");
1120 template<
typename _Sseq,
typename =
typename
1122 && !std::is_same<_Sseq, _RandomNumberEngine>::value>
1150 template<
typename _Sseq>
1159 const _RandomNumberEngine&
1175 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1222 template<
typename _CharT,
typename _Traits>
1226 __w, _UIntType>& __x)
1233 _RandomNumberEngine _M_b;
1248 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1266 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1267 typename _CharT,
typename _Traits>
1271 __w, _UIntType>& __x)
1283 template<
typename _RandomNumberEngine,
size_t __k>
1286 static_assert(1u <=
__k,
"template argument substituting "
1287 "__k out of bound");
1293 static constexpr size_t table_size =
__k;
1302 { _M_initialize(); }
1313 { _M_initialize(); }
1324 { _M_initialize(); }
1335 { _M_initialize(); }
1342 template<
typename _Sseq,
typename =
typename
1344 && !std::is_same<_Sseq, _RandomNumberEngine>::value>
1349 { _M_initialize(); }
1378 template<
typename _Sseq>
1389 const _RandomNumberEngine&
1398 {
return _RandomNumberEngine::min(); }
1405 {
return _RandomNumberEngine::max(); }
1453 typename _CharT,
typename _Traits>
1471 typename _CharT,
typename _Traits>
1477 void _M_initialize()
1479 for (
size_t __i = 0; __i <
__k; ++__i)
1484 _RandomNumberEngine _M_b;
1500 template<
typename _RandomNumberEngine,
size_t __k>
1512 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1543 0xb5026f5aa96619e9ULL, 29,
1544 0x5555555555555555ULL, 17,
1545 0x71d67fffeda60000ULL, 37,
1546 0xfff7eee000000000ULL, 43,
1575#ifdef _GLIBCXX_USE_RANDOM_TR1
1589 random_device(
const std::string& __token =
"mt19937")
1590 { _M_init_pretr1(__token); }
1605 entropy() const noexcept
1611#ifdef _GLIBCXX_USE_RANDOM_TR1
1612 return this->_M_getval();
1614 return this->_M_getval_pretr1();
1619 random_device(
const random_device&) =
delete;
1620 void operator=(
const random_device&) =
delete;
1658 template<
typename _IntType>
1662 {
return !(__d1 ==
__d2); }
1674 template<
typename _IntType,
typename _CharT,
typename _Traits>
1688 template<
typename _IntType,
typename _CharT,
typename _Traits>
1701 template<
typename _RealType =
double>
1705 "template argument not a floating point type");
1717 _RealType __b = _RealType(1))
1718 : _M_a(__a), _M_b(__b)
1720 __glibcxx_assert(_M_a <= _M_b);
1749 _RealType __b = _RealType(1))
1750 : _M_param(__a, __b)
1768 {
return _M_param.a(); }
1772 {
return _M_param.b(); }
1779 {
return _M_param; }
1794 {
return this->a(); }
1801 {
return this->b(); }
1806 template<
typename _UniformRandomNumberGenerator>
1809 {
return this->
operator()(__urng, _M_param); }
1811 template<
typename _UniformRandomNumberGenerator>
1814 const param_type& __p)
1816 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1818 return (
__aurng() * (__p.b() - __p.a())) + __p.a();
1821 template<
typename _ForwardIterator,
1822 typename _UniformRandomNumberGenerator>
1824 __generate(_ForwardIterator __f, _ForwardIterator __t,
1825 _UniformRandomNumberGenerator& __urng)
1826 { this->__generate(__f, __t, __urng, _M_param); }
1828 template<
typename _ForwardIterator,
1829 typename _UniformRandomNumberGenerator>
1831 __generate(_ForwardIterator __f, _ForwardIterator __t,
1832 _UniformRandomNumberGenerator& __urng,
1833 const param_type& __p)
1834 { this->__generate_impl(__f, __t, __urng, __p); }
1836 template<
typename _UniformRandomNumberGenerator>
1839 _UniformRandomNumberGenerator& __urng,
1840 const param_type& __p)
1841 { this->__generate_impl(__f, __t, __urng, __p); }
1850 {
return __d1._M_param ==
__d2._M_param; }
1858 const param_type& __p);
1860 param_type _M_param;
1867 template<
typename _IntType>
1871 {
return !(__d1 ==
__d2); }
1883 template<
typename _RealType,
typename _CharT,
typename _Traits>
1897 template<
typename _RealType,
typename _CharT,
typename _Traits>
1919 template<
typename _RealType =
double>
1923 "template argument not a floating point type");
1938 __glibcxx_assert(_M_stddev > _RealType(0));
1947 {
return _M_stddev; }
1951 {
return (
__p1._M_mean ==
__p2._M_mean
1952 &&
__p1._M_stddev ==
__p2._M_stddev); }
1956 _RealType _M_stddev;
1972 : _M_param(__p), _M_saved_available(
false)
1980 { _M_saved_available =
false; }
1987 {
return _M_param.mean(); }
1994 {
return _M_param.stddev(); }
2001 {
return _M_param; }
2028 template<
typename _UniformRandomNumberGenerator>
2031 {
return this->
operator()(__urng, _M_param); }
2033 template<
typename _UniformRandomNumberGenerator>
2036 const param_type& __p);
2043 { this->__generate(__f, __t,
__urng, _M_param); }
2045 template<
typename _ForwardIterator,
2046 typename _UniformRandomNumberGenerator>
2048 __generate(_ForwardIterator __f, _ForwardIterator __t,
2049 _UniformRandomNumberGenerator& __urng,
2050 const param_type& __p)
2051 { this->__generate_impl(__f, __t, __urng, __p); }
2053 template<
typename _UniformRandomNumberGenerator>
2056 _UniformRandomNumberGenerator& __urng,
2057 const param_type& __p)
2058 { this->__generate_impl(__f, __t, __urng, __p); }
2065 template<
typename _RealType1>
2080 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2095 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2110 bool _M_saved_available;
2116 template<
typename _RealType>
2120 {
return !(__d1 ==
__d2); }
2132 template<
typename _RealType =
double>
2136 "template argument not a floating point type");
2148 _RealType
__s = _RealType(1))
2149 : _M_m(__m), _M_s(
__s)
2171 _RealType
__s = _RealType(1))
2172 : _M_param(__m,
__s), _M_nd()
2177 : _M_param(__p), _M_nd()
2192 {
return _M_param.m(); }
2196 {
return _M_param.s(); }
2203 {
return _M_param; }
2230 template<
typename _UniformRandomNumberGenerator>
2233 {
return this->
operator()(__urng, _M_param); }
2235 template<
typename _UniformRandomNumberGenerator>
2238 const param_type& __p)
2241 template<
typename _ForwardIterator,
2242 typename _UniformRandomNumberGenerator>
2244 __generate(_ForwardIterator __f, _ForwardIterator __t,
2245 _UniformRandomNumberGenerator& __urng)
2246 { this->__generate(__f, __t, __urng, _M_param); }
2248 template<
typename _ForwardIterator,
2249 typename _UniformRandomNumberGenerator>
2251 __generate(_ForwardIterator __f, _ForwardIterator __t,
2252 _UniformRandomNumberGenerator& __urng,
2253 const param_type& __p)
2254 { this->__generate_impl(__f, __t, __urng, __p); }
2256 template<
typename _UniformRandomNumberGenerator>
2259 _UniformRandomNumberGenerator& __urng,
2260 const param_type& __p)
2261 { this->__generate_impl(__f, __t, __urng, __p); }
2271 {
return (__d1._M_param ==
__d2._M_param
2272 && __d1._M_nd ==
__d2._M_nd); }
2284 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2299 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2320 template<
typename _RealType>
2324 {
return !(__d1 ==
__d2); }
2336 template<
typename _RealType =
double>
2340 "template argument not a floating point type");
2356 __glibcxx_assert(_M_alpha > _RealType(0));
2362 {
return _M_alpha; }
2370 {
return (
__p1._M_alpha ==
__p2._M_alpha
2371 &&
__p1._M_beta ==
__p2._M_beta); }
2380 _RealType _M_malpha, _M_a2;
2396 : _M_param(__p), _M_nd()
2411 {
return _M_param.alpha(); }
2418 {
return _M_param.beta(); }
2425 {
return _M_param; }
2452 template<
typename _UniformRandomNumberGenerator>
2455 {
return this->
operator()(__urng, _M_param); }
2457 template<
typename _UniformRandomNumberGenerator>
2460 const param_type& __p);
2467 { this->__generate(__f, __t,
__urng, _M_param); }
2469 template<
typename _ForwardIterator,
2470 typename _UniformRandomNumberGenerator>
2472 __generate(_ForwardIterator __f, _ForwardIterator __t,
2473 _UniformRandomNumberGenerator& __urng,
2474 const param_type& __p)
2475 { this->__generate_impl(__f, __t, __urng, __p); }
2477 template<
typename _UniformRandomNumberGenerator>
2480 _UniformRandomNumberGenerator& __urng,
2481 const param_type& __p)
2482 { this->__generate_impl(__f, __t, __urng, __p); }
2492 {
return (__d1._M_param ==
__d2._M_param
2493 && __d1._M_nd ==
__d2._M_nd); }
2505 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2519 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2540 template<
typename _RealType>
2544 {
return !(__d1 ==
__d2); }
2553 template<
typename _RealType =
double>
2557 "template argument not a floating point type");
2586 : _M_param(__n), _M_gd(__n / 2)
2591 : _M_param(__p), _M_gd(__p.n() / 2)
2606 {
return _M_param.n(); }
2613 {
return _M_param; }
2645 template<
typename _UniformRandomNumberGenerator>
2648 {
return 2 * _M_gd(
__urng); }
2650 template<
typename _UniformRandomNumberGenerator>
2653 const param_type& __p)
2657 return 2 * _M_gd(
__urng, param_type(__p.n() / 2));
2660 template<
typename _ForwardIterator,
2661 typename _UniformRandomNumberGenerator>
2663 __generate(_ForwardIterator __f, _ForwardIterator __t,
2664 _UniformRandomNumberGenerator& __urng)
2665 { this->__generate_impl(__f, __t, __urng); }
2667 template<
typename _ForwardIterator,
2668 typename _UniformRandomNumberGenerator>
2670 __generate(_ForwardIterator __f, _ForwardIterator __t,
2671 _UniformRandomNumberGenerator& __urng,
2672 const param_type& __p)
2675 this->__generate_impl(__f, __t, __urng, __p2); }
2677 template<
typename _UniformRandomNumberGenerator>
2680 _UniformRandomNumberGenerator& __urng)
2681 { this->__generate_impl(__f, __t, __urng); }
2683 template<
typename _UniformRandomNumberGenerator>
2686 _UniformRandomNumberGenerator& __urng,
2687 const param_type& __p)
2690 this->__generate_impl(__f, __t, __urng, __p2); }
2700 {
return __d1._M_param ==
__d2._M_param && __d1._M_gd ==
__d2._M_gd; }
2712 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2727 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2755 template<
typename _RealType>
2759 {
return !(__d1 ==
__d2); }
2768 template<
typename _RealType =
double>
2772 "template argument not a floating point type");
2784 _RealType __b = _RealType(1))
2785 : _M_a(__a), _M_b(__b)
2807 _RealType __b = _RealType(1))
2808 : _M_param(__a, __b)
2828 {
return _M_param.a(); }
2832 {
return _M_param.b(); }
2839 {
return _M_param; }
2866 template<
typename _UniformRandomNumberGenerator>
2869 {
return this->
operator()(__urng, _M_param); }
2871 template<
typename _UniformRandomNumberGenerator>
2874 const param_type& __p);
2881 { this->__generate(__f, __t,
__urng, _M_param); }
2883 template<
typename _ForwardIterator,
2884 typename _UniformRandomNumberGenerator>
2886 __generate(_ForwardIterator __f, _ForwardIterator __t,
2887 _UniformRandomNumberGenerator& __urng,
2888 const param_type& __p)
2889 { this->__generate_impl(__f, __t, __urng, __p); }
2891 template<
typename _UniformRandomNumberGenerator>
2894 _UniformRandomNumberGenerator& __urng,
2895 const param_type& __p)
2896 { this->__generate_impl(__f, __t, __urng, __p); }
2905 {
return __d1._M_param ==
__d2._M_param; }
2913 const param_type& __p);
2915 param_type _M_param;
2922 template<
typename _RealType>
2926 {
return !(__d1 ==
__d2); }
2938 template<
typename _RealType,
typename _CharT,
typename _Traits>
2953 template<
typename _RealType,
typename _CharT,
typename _Traits>
2969 template<
typename _RealType =
double>
2973 "template argument not a floating point type");
2985 _RealType __n = _RealType(1))
2986 : _M_m(__m), _M_n(__n)
3008 _RealType __n = _RealType(1))
3009 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3014 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3032 {
return _M_param.m(); }
3036 {
return _M_param.n(); }
3043 {
return _M_param; }
3070 template<
typename _UniformRandomNumberGenerator>
3073 {
return (_M_gd_x(
__urng) * n()) / (_M_gd_y(
__urng) * m()); }
3075 template<
typename _UniformRandomNumberGenerator>
3078 const param_type& __p)
3082 return ((_M_gd_x(
__urng, param_type(__p.m() / 2)) * n())
3083 / (_M_gd_y(
__urng, param_type(__p.n() / 2)) * m()));
3086 template<
typename _ForwardIterator,
3087 typename _UniformRandomNumberGenerator>
3089 __generate(_ForwardIterator __f, _ForwardIterator __t,
3090 _UniformRandomNumberGenerator& __urng)
3091 { this->__generate_impl(__f, __t, __urng); }
3093 template<
typename _ForwardIterator,
3094 typename _UniformRandomNumberGenerator>
3096 __generate(_ForwardIterator __f, _ForwardIterator __t,
3097 _UniformRandomNumberGenerator& __urng,
3098 const param_type& __p)
3099 { this->__generate_impl(__f, __t, __urng, __p); }
3101 template<
typename _UniformRandomNumberGenerator>
3104 _UniformRandomNumberGenerator& __urng)
3105 { this->__generate_impl(__f, __t, __urng); }
3107 template<
typename _UniformRandomNumberGenerator>
3110 _UniformRandomNumberGenerator& __urng,
3111 const param_type& __p)
3112 { this->__generate_impl(__f, __t, __urng, __p); }
3122 {
return (__d1._M_param ==
__d2._M_param
3123 && __d1._M_gd_x ==
__d2._M_gd_x
3124 && __d1._M_gd_y ==
__d2._M_gd_y); }
3136 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3151 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3178 template<
typename _RealType>
3182 {
return !(__d1 ==
__d2); }
3193 template<
typename _RealType =
double>
3197 "template argument not a floating point type");
3226 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3231 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3249 {
return _M_param.n(); }
3256 {
return _M_param; }
3283 template<
typename _UniformRandomNumberGenerator>
3288 template<
typename _UniformRandomNumberGenerator>
3291 const param_type& __p)
3300 template<
typename _ForwardIterator,
3301 typename _UniformRandomNumberGenerator>
3303 __generate(_ForwardIterator __f, _ForwardIterator __t,
3304 _UniformRandomNumberGenerator& __urng)
3305 { this->__generate_impl(__f, __t, __urng); }
3307 template<
typename _ForwardIterator,
3308 typename _UniformRandomNumberGenerator>
3310 __generate(_ForwardIterator __f, _ForwardIterator __t,
3311 _UniformRandomNumberGenerator& __urng,
3312 const param_type& __p)
3313 { this->__generate_impl(__f, __t, __urng, __p); }
3315 template<
typename _UniformRandomNumberGenerator>
3318 _UniformRandomNumberGenerator& __urng)
3319 { this->__generate_impl(__f, __t, __urng); }
3321 template<
typename _UniformRandomNumberGenerator>
3324 _UniformRandomNumberGenerator& __urng,
3325 const param_type& __p)
3326 { this->__generate_impl(__f, __t, __urng, __p); }
3336 {
return (__d1._M_param ==
__d2._M_param
3337 && __d1._M_nd ==
__d2._M_nd && __d1._M_gd ==
__d2._M_gd); }
3349 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3364 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3391 template<
typename _RealType>
3395 {
return !(__d1 ==
__d2); }
3426 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3471 {
return _M_param.p(); }
3478 {
return _M_param; }
3505 template<
typename _UniformRandomNumberGenerator>
3508 {
return this->
operator()(__urng, _M_param); }
3510 template<
typename _UniformRandomNumberGenerator>
3513 const param_type& __p)
3515 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3523 template<
typename _ForwardIterator,
3524 typename _UniformRandomNumberGenerator>
3526 __generate(_ForwardIterator __f, _ForwardIterator __t,
3527 _UniformRandomNumberGenerator& __urng)
3528 { this->__generate(__f, __t, __urng, _M_param); }
3530 template<
typename _ForwardIterator,
3531 typename _UniformRandomNumberGenerator>
3533 __generate(_ForwardIterator __f, _ForwardIterator __t,
3534 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3535 { this->__generate_impl(__f, __t, __urng, __p); }
3537 template<
typename _UniformRandomNumberGenerator>
3540 _UniformRandomNumberGenerator& __urng,
3541 const param_type& __p)
3542 { this->__generate_impl(__f, __t, __urng, __p); }
3551 {
return __d1._M_param ==
__d2._M_param; }
3559 const param_type& __p);
3561 param_type _M_param;
3571 {
return !(__d1 ==
__d2); }
3583 template<
typename _CharT,
typename _Traits>
3597 template<
typename _CharT,
typename _Traits>
3616 template<
typename _IntType =
int>
3620 "template argument not an integral type");
3632 param_type(_IntType __t = _IntType(1),
double __p = 0.5)
3633 : _M_t(__t), _M_p(__p)
3635 __glibcxx_assert((_M_t >= _IntType(0))
3661#if _GLIBCXX_USE_C99_MATH_TR1
3672 : _M_param(__t, __p), _M_nd()
3677 : _M_param(__p), _M_nd()
3692 {
return _M_param.t(); }
3699 {
return _M_param.p(); }
3706 {
return _M_param; }
3728 {
return _M_param.t(); }
3733 template<
typename _UniformRandomNumberGenerator>
3736 {
return this->
operator()(__urng, _M_param); }
3738 template<
typename _UniformRandomNumberGenerator>
3741 const param_type& __p);
3748 { this->__generate(__f, __t,
__urng, _M_param); }
3750 template<
typename _ForwardIterator,
3751 typename _UniformRandomNumberGenerator>
3753 __generate(_ForwardIterator __f, _ForwardIterator __t,
3754 _UniformRandomNumberGenerator& __urng,
3755 const param_type& __p)
3756 { this->__generate_impl(__f, __t, __urng, __p); }
3758 template<
typename _UniformRandomNumberGenerator>
3761 _UniformRandomNumberGenerator& __urng,
3762 const param_type& __p)
3763 { this->__generate_impl(__f, __t, __urng, __p); }
3773#ifdef _GLIBCXX_USE_C99_MATH_TR1
3774 {
return __d1._M_param ==
__d2._M_param && __d1._M_nd ==
__d2._M_nd; }
3776 {
return __d1._M_param ==
__d2._M_param; }
3789 template<
typename _IntType1,
3790 typename _CharT,
typename _Traits>
3806 typename _CharT,
typename _Traits>
3819 template<
typename _UniformRandomNumberGenerator>
3822 _IntType __t,
double __q);
3833 template<
typename _IntType>
3837 {
return !(__d1 ==
__d2); }
3847 template<
typename _IntType =
int>
3851 "template argument not an integral type");
3866 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
3881 { _M_log_1_p =
std::log(1.0 - _M_p); }
3912 {
return _M_param.p(); }
3919 {
return _M_param; }
3946 template<
typename _UniformRandomNumberGenerator>
3949 {
return this->
operator()(__urng, _M_param); }
3951 template<
typename _UniformRandomNumberGenerator>
3954 const param_type& __p);
3961 { this->__generate(__f, __t,
__urng, _M_param); }
3963 template<
typename _ForwardIterator,
3964 typename _UniformRandomNumberGenerator>
3966 __generate(_ForwardIterator __f, _ForwardIterator __t,
3967 _UniformRandomNumberGenerator& __urng,
3968 const param_type& __p)
3969 { this->__generate_impl(__f, __t, __urng, __p); }
3971 template<
typename _UniformRandomNumberGenerator>
3974 _UniformRandomNumberGenerator& __urng,
3975 const param_type& __p)
3976 { this->__generate_impl(__f, __t, __urng, __p); }
3985 {
return __d1._M_param ==
__d2._M_param; }
3993 const param_type& __p);
3995 param_type _M_param;
4002 template<
typename _IntType>
4006 {
return !(__d1 ==
__d2); }
4018 template<
typename _IntType,
4019 typename _CharT,
typename _Traits>
4033 template<
typename _IntType,
4034 typename _CharT,
typename _Traits>
4047 template<
typename _IntType =
int>
4051 "template argument not an integral type");
4063 : _M_k(
__k), _M_p(__p)
4065 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4087 : _M_param(
__k, __p), _M_gd(
__k, (1.0 - __p) / __p)
4092 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4107 {
return _M_param.k(); }
4114 {
return _M_param.p(); }
4121 {
return _M_param; }
4148 template<
typename _UniformRandomNumberGenerator>
4152 template<
typename _UniformRandomNumberGenerator>
4155 const param_type& __p);
4162 { this->__generate_impl(__f, __t,
__urng); }
4164 template<
typename _ForwardIterator,
4165 typename _UniformRandomNumberGenerator>
4167 __generate(_ForwardIterator __f, _ForwardIterator __t,
4168 _UniformRandomNumberGenerator& __urng,
4169 const param_type& __p)
4170 { this->__generate_impl(__f, __t, __urng, __p); }
4172 template<
typename _UniformRandomNumberGenerator>
4175 _UniformRandomNumberGenerator& __urng)
4176 { this->__generate_impl(__f, __t, __urng); }
4178 template<
typename _UniformRandomNumberGenerator>
4181 _UniformRandomNumberGenerator& __urng,
4182 const param_type& __p)
4183 { this->__generate_impl(__f, __t, __urng, __p); }
4193 {
return __d1._M_param ==
__d2._M_param && __d1._M_gd ==
__d2._M_gd; }
4206 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4221 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4247 template<
typename _IntType>
4251 {
return !(__d1 ==
__d2); }
4269 template<
typename _IntType =
int>
4273 "template argument not an integral type");
4288 __glibcxx_assert(_M_mean > 0.0);
4298 {
return __p1._M_mean ==
__p2._M_mean; }
4308#if _GLIBCXX_USE_C99_MATH_TR1
4316 : _M_param(
__mean), _M_nd()
4321 : _M_param(__p), _M_nd()
4336 {
return _M_param.mean(); }
4343 {
return _M_param; }
4370 template<
typename _UniformRandomNumberGenerator>
4373 {
return this->
operator()(__urng, _M_param); }
4375 template<
typename _UniformRandomNumberGenerator>
4378 const param_type& __p);
4385 { this->__generate(__f, __t,
__urng, _M_param); }
4387 template<
typename _ForwardIterator,
4388 typename _UniformRandomNumberGenerator>
4390 __generate(_ForwardIterator __f, _ForwardIterator __t,
4391 _UniformRandomNumberGenerator& __urng,
4392 const param_type& __p)
4393 { this->__generate_impl(__f, __t, __urng, __p); }
4395 template<
typename _UniformRandomNumberGenerator>
4398 _UniformRandomNumberGenerator& __urng,
4399 const param_type& __p)
4400 { this->__generate_impl(__f, __t, __urng, __p); }
4410#ifdef _GLIBCXX_USE_C99_MATH_TR1
4411 {
return __d1._M_param ==
__d2._M_param && __d1._M_nd ==
__d2._M_nd; }
4413 {
return __d1._M_param ==
__d2._M_param; }
4426 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4441 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4463 template<
typename _IntType>
4467 {
return !(__d1 ==
__d2); }
4485 template<
typename _RealType =
double>
4489 "template argument not a floating point type");
4503 __glibcxx_assert(_M_lambda > _RealType(0));
4508 {
return _M_lambda; }
4512 {
return __p1._M_lambda ==
__p2._M_lambda; }
4515 _RealType _M_lambda;
4546 {
return _M_param.lambda(); }
4553 {
return _M_param; }
4580 template<
typename _UniformRandomNumberGenerator>
4583 {
return this->
operator()(__urng, _M_param); }
4585 template<
typename _UniformRandomNumberGenerator>
4588 const param_type& __p)
4590 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4595 template<
typename _ForwardIterator,
4596 typename _UniformRandomNumberGenerator>
4598 __generate(_ForwardIterator __f, _ForwardIterator __t,
4599 _UniformRandomNumberGenerator& __urng)
4600 { this->__generate(__f, __t, __urng, _M_param); }
4602 template<
typename _ForwardIterator,
4603 typename _UniformRandomNumberGenerator>
4605 __generate(_ForwardIterator __f, _ForwardIterator __t,
4606 _UniformRandomNumberGenerator& __urng,
4607 const param_type& __p)
4608 { this->__generate_impl(__f, __t, __urng, __p); }
4610 template<
typename _UniformRandomNumberGenerator>
4613 _UniformRandomNumberGenerator& __urng,
4614 const param_type& __p)
4615 { this->__generate_impl(__f, __t, __urng, __p); }
4624 {
return __d1._M_param ==
__d2._M_param; }
4632 const param_type& __p);
4634 param_type _M_param;
4641 template<
typename _RealType>
4645 {
return !(__d1 ==
__d2); }
4657 template<
typename _RealType,
typename _CharT,
typename _Traits>
4672 template<
typename _RealType,
typename _CharT,
typename _Traits>
4687 template<
typename _RealType =
double>
4691 "template argument not a floating point type");
4703 _RealType __b = _RealType(1))
4704 : _M_a(__a), _M_b(__b)
4726 _RealType __b = _RealType(1))
4727 : _M_param(__a, __b)
4747 {
return _M_param.a(); }
4754 {
return _M_param.b(); }
4761 {
return _M_param; }
4788 template<
typename _UniformRandomNumberGenerator>
4791 {
return this->
operator()(__urng, _M_param); }
4793 template<
typename _UniformRandomNumberGenerator>
4796 const param_type& __p);
4803 { this->__generate(__f, __t,
__urng, _M_param); }
4805 template<
typename _ForwardIterator,
4806 typename _UniformRandomNumberGenerator>
4808 __generate(_ForwardIterator __f, _ForwardIterator __t,
4809 _UniformRandomNumberGenerator& __urng,
4810 const param_type& __p)
4811 { this->__generate_impl(__f, __t, __urng, __p); }
4813 template<
typename _UniformRandomNumberGenerator>
4816 _UniformRandomNumberGenerator& __urng,
4817 const param_type& __p)
4818 { this->__generate_impl(__f, __t, __urng, __p); }
4827 {
return __d1._M_param ==
__d2._M_param; }
4835 const param_type& __p);
4837 param_type _M_param;
4844 template<
typename _RealType>
4848 {
return !(__d1 ==
__d2); }
4860 template<
typename _RealType,
typename _CharT,
typename _Traits>
4875 template<
typename _RealType,
typename _CharT,
typename _Traits>
4890 template<
typename _RealType =
double>
4894 "template argument not a floating point type");
4906 _RealType __b = _RealType(1))
4907 : _M_a(__a), _M_b(__b)
4929 _RealType __b = _RealType(1))
4930 : _M_param(__a, __b)
4950 {
return _M_param.a(); }
4957 {
return _M_param.b(); }
4964 {
return _M_param; }
4991 template<
typename _UniformRandomNumberGenerator>
4994 {
return this->
operator()(__urng, _M_param); }
4996 template<
typename _UniformRandomNumberGenerator>
4999 const param_type& __p);
5006 { this->__generate(__f, __t,
__urng, _M_param); }
5008 template<
typename _ForwardIterator,
5009 typename _UniformRandomNumberGenerator>
5011 __generate(_ForwardIterator __f, _ForwardIterator __t,
5012 _UniformRandomNumberGenerator& __urng,
5013 const param_type& __p)
5014 { this->__generate_impl(__f, __t, __urng, __p); }
5016 template<
typename _UniformRandomNumberGenerator>
5019 _UniformRandomNumberGenerator& __urng,
5020 const param_type& __p)
5021 { this->__generate_impl(__f, __t, __urng, __p); }
5030 {
return __d1._M_param ==
__d2._M_param; }
5038 const param_type& __p);
5040 param_type _M_param;
5047 template<
typename _RealType>
5051 {
return !(__d1 ==
__d2); }
5063 template<
typename _RealType,
typename _CharT,
typename _Traits>
5078 template<
typename _RealType,
typename _CharT,
typename _Traits>
5090 template<
typename _IntType =
int>
5094 "template argument not an integral type");
5106 : _M_prob(), _M_cp()
5109 template<
typename _InputIterator>
5113 { _M_initialize(); }
5116 : _M_prob(
__wil.begin(),
__wil.end()), _M_cp()
5117 { _M_initialize(); }
5119 template<
typename _Func>
5128 probabilities()
const
5133 {
return __p1._M_prob ==
__p2._M_prob; }
5147 template<
typename _InputIterator>
5153 discrete_distribution(initializer_list<double> __wl)
5157 template<
typename _Func>
5158 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5160 : _M_param(__nw, __xmin, __xmax, __fw)
5164 discrete_distribution(
const param_type& __p)
5181 return _M_param._M_prob.
empty()
5190 {
return _M_param; }
5213 return _M_param._M_prob.
empty()
5220 template<
typename _UniformRandomNumberGenerator>
5223 {
return this->
operator()(__urng, _M_param); }
5225 template<
typename _UniformRandomNumberGenerator>
5228 const param_type& __p);
5235 { this->__generate(__f, __t,
__urng, _M_param); }
5237 template<
typename _ForwardIterator,
5238 typename _UniformRandomNumberGenerator>
5240 __generate(_ForwardIterator __f, _ForwardIterator __t,
5241 _UniformRandomNumberGenerator& __urng,
5242 const param_type& __p)
5243 { this->__generate_impl(__f, __t, __urng, __p); }
5245 template<
typename _UniformRandomNumberGenerator>
5248 _UniformRandomNumberGenerator& __urng,
5249 const param_type& __p)
5250 { this->__generate_impl(__f, __t, __urng, __p); }
5259 {
return __d1._M_param ==
__d2._M_param; }
5271 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5287 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5307 template<
typename _IntType>
5311 {
return !(__d1 ==
__d2); }
5320 template<
typename _RealType =
double>
5324 "template argument not a floating point type");
5336 : _M_int(), _M_den(), _M_cp()
5339 template<
typename _InputIteratorB,
typename _InputIteratorW>
5344 template<
typename _Func>
5347 template<
typename _Func>
5361 __tmp[1] = _RealType(1);
5390 template<
typename _InputIteratorB,
typename _InputIteratorW>
5397 template<
typename _Func>
5398 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5400 : _M_param(__bl, __fw)
5403 template<
typename _Func>
5404 piecewise_constant_distribution(
size_t __nw,
5405 _RealType __xmin, _RealType __xmax,
5407 : _M_param(__nw, __xmin, __xmax, __fw)
5411 piecewise_constant_distribution(
const param_type& __p)
5428 if (_M_param._M_int.
empty())
5431 __tmp[1] = _RealType(1);
5435 return _M_param._M_int;
5444 return _M_param._M_den.
empty()
5453 {
return _M_param; }
5469 return _M_param._M_int.
empty()
5479 return _M_param._M_int.
empty()
5486 template<
typename _UniformRandomNumberGenerator>
5489 {
return this->
operator()(__urng, _M_param); }
5491 template<
typename _UniformRandomNumberGenerator>
5494 const param_type& __p);
5501 { this->__generate(__f, __t,
__urng, _M_param); }
5503 template<
typename _ForwardIterator,
5504 typename _UniformRandomNumberGenerator>
5506 __generate(_ForwardIterator __f, _ForwardIterator __t,
5507 _UniformRandomNumberGenerator& __urng,
5508 const param_type& __p)
5509 { this->__generate_impl(__f, __t, __urng, __p); }
5511 template<
typename _UniformRandomNumberGenerator>
5514 _UniformRandomNumberGenerator& __urng,
5515 const param_type& __p)
5516 { this->__generate_impl(__f, __t, __urng, __p); }
5525 {
return __d1._M_param ==
__d2._M_param; }
5538 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5554 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5574 template<
typename _RealType>
5578 {
return !(__d1 ==
__d2); }
5587 template<
typename _RealType =
double>
5591 "template argument not a floating point type");
5603 : _M_int(), _M_den(), _M_cp(), _M_m()
5606 template<
typename _InputIteratorB,
typename _InputIteratorW>
5611 template<
typename _Func>
5614 template<
typename _Func>
5628 __tmp[1] = _RealType(1);
5641 {
return (
__p1._M_int ==
__p2._M_int
5659 template<
typename _InputIteratorB,
typename _InputIteratorW>
5666 template<
typename _Func>
5667 piecewise_linear_distribution(initializer_list<_RealType> __bl,
5669 : _M_param(__bl, __fw)
5672 template<
typename _Func>
5673 piecewise_linear_distribution(
size_t __nw,
5674 _RealType __xmin, _RealType __xmax,
5676 : _M_param(__nw, __xmin, __xmax, __fw)
5680 piecewise_linear_distribution(
const param_type& __p)
5697 if (_M_param._M_int.
empty())
5700 __tmp[1] = _RealType(1);
5704 return _M_param._M_int;
5714 return _M_param._M_den.
empty()
5723 {
return _M_param; }
5739 return _M_param._M_int.
empty()
5749 return _M_param._M_int.
empty()
5756 template<
typename _UniformRandomNumberGenerator>
5759 {
return this->
operator()(__urng, _M_param); }
5761 template<
typename _UniformRandomNumberGenerator>
5764 const param_type& __p);
5771 { this->__generate(__f, __t,
__urng, _M_param); }
5773 template<
typename _ForwardIterator,
5774 typename _UniformRandomNumberGenerator>
5776 __generate(_ForwardIterator __f, _ForwardIterator __t,
5777 _UniformRandomNumberGenerator& __urng,
5778 const param_type& __p)
5779 { this->__generate_impl(__f, __t, __urng, __p); }
5781 template<
typename _UniformRandomNumberGenerator>
5784 _UniformRandomNumberGenerator& __urng,
5785 const param_type& __p)
5786 { this->__generate_impl(__f, __t, __urng, __p); }
5795 {
return __d1._M_param ==
__d2._M_param; }
5808 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5824 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5844 template<
typename _RealType>
5848 {
return !(__d1 ==
__d2); }
5876 template<
typename _IntType>
5879 template<
typename _InputIterator>
5883 template<
typename _RandomAccessIterator>
5889 {
return _M_v.
size(); }
5891 template<
typename OutputIterator>
5893 param(OutputIterator __dest)
const
5894 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
5908_GLIBCXX_END_NAMESPACE_VERSION
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
_RealType generate_canonical(_UniformRandomNumberGenerator &__g)
A function template for converting the output of a (integral) uniform random number generator to a fl...
linear_congruential_engine< uint_fast32_t, 48271UL, 0UL, 2147483647UL > minstd_rand
linear_congruential_engine< uint_fast32_t, 16807UL, 0UL, 2147483647UL > minstd_rand0
mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > mt19937
mersenne_twister_engine< uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL > mt19937_64
_RealType lambda() const
Returns the inverse scale parameter of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::negative_binomial_distribution< _IntType1 > &__x)
Inserts a negative_binomial_distribution random number distribution __x into the output stream __os.
std::vector< double > densities() const
Returns a vector of the probability densities.
void param(const param_type &__param)
Sets the parameter set of the distribution.
param_type param() const
Returns the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
linear_congruential_engine(result_type __s=default_seed)
Constructs a linear_congruential_engine random number generator engine with seed __s....
void seed(result_type __s)
Reseeds the discard_block_engine object with the default seed for the underlying base class generator...
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
static constexpr result_type min()
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
static constexpr result_type min()
Gets the minimum value in the generated random number range.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::discard_block_engine< _RandomNumberEngine1, __p1, __r1 > &__x)
Inserts the current state of a discard_block_engine random number generator engine __x into the outpu...
void reset()
Resets the distribution state.
independent_bits_engine(_Sseq &__q)
Generator construct a independent_bits_engine engine.
shuffle_order_engine()
Constructs a default shuffle_order_engine engine.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
static constexpr result_type max()
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
result_type min() const
Returns the greatest lower bound value of the distribution.
shuffle_order_engine(const _RandomNumberEngine &__rng)
Copy constructs a shuffle_order_engine engine.
void reset()
Resets the distribution state.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::linear_congruential_engine< _UIntType1, __a1, __c1, __m1 > &__lcr)
Sets the state of the engine by reading its textual representation from __is.
const _RandomNumberEngine & base() const noexcept
Gets a const reference to the underlying generator engine object.
void seed()
Reseeds the discard_block_engine object with the default seed for the underlying base class generator...
shuffle_order_engine(_Sseq &__q)
Generator construct a shuffle_order_engine engine.
const _RandomNumberEngine & base() const noexcept
exponential_distribution(const result_type &__lambda=result_type(1))
Constructs an exponential distribution with inverse scale parameter .
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::discrete_distribution< _IntType1 > &__x)
Inserts a discrete_distribution random number distribution __x into the output stream __os.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend bool operator==(const lognormal_distribution &__d1, const lognormal_distribution &__d2)
Return true if two lognormal distributions have the same parameters and the sequences that would be g...
result_type min() const
Returns the greatest lower bound value of the distribution.
discard_block_engine(const _RandomNumberEngine &__rng)
Copy constructs a discard_block_engine engine.
void reset()
Resets the distribution state.
result_type min() const
Returns the greatest lower bound value of the distribution.
uint_least32_t result_type
friend bool operator==(const bernoulli_distribution &__d1, const bernoulli_distribution &__d2)
Return true if two Bernoulli distributions have the same parameters.
param_type param() const
Returns the parameter set of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::subtract_with_carry_engine< _UIntType1, __w1, __s1, __r1 > &__x)
Inserts the current state of a % subtract_with_carry_engine random number generator engine __x into t...
void reset()
Resets the distribution state.
void reset()
Resets the distribution state.
result_type max() const
Returns the least upper bound value of the distribution.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
param_type param() const
Returns the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::discrete_distribution< _IntType1 > &__x)
Extracts a discrete_distribution random number distribution __x from the input stream __is.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type max() const
Returns the least upper bound value of the distribution.
void reset()
Resets the distribution state.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::gamma_distribution< _RealType1 > &__x)
Inserts a gamma_distribution random number distribution __x into the output stream __os.
linear_congruential_engine(_Sseq &__q)
Constructs a linear_congruential_engine random number generator engine seeded from the seed sequence ...
result_type max() const
Returns the least upper bound value of the distribution.
double p() const
Returns the distribution parameter p.
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
_RealType stddev() const
Returns the standard deviation of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
void reset()
Resets the distribution state.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
shuffle_order_engine(_RandomNumberEngine &&__rng)
Move constructs a shuffle_order_engine engine.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void reset()
Resets the distribution state.
independent_bits_engine(const _RandomNumberEngine &__rng)
Copy constructs a independent_bits_engine engine.
friend bool operator==(const student_t_distribution &__d1, const student_t_distribution &__d2)
Return true if two Student t distributions have the same parameters and the sequences that would be g...
result_type max() const
Returns the least upper bound value of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::piecewise_constant_distribution< _RealType1 > &__x)
Inserts a piecewise_constant_distribution random number distribution __x into the output stream __os.
void seed(result_type __sd=default_seed)
Seeds the initial state of the random number generator.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::piecewise_linear_distribution< _RealType1 > &__x)
Extracts a piecewise_linear_distribution random number distribution __x from the input stream __is.
param_type param() const
Returns the parameter set of the distribution.
static constexpr result_type min()
Gets the smallest possible value in the output range.
static constexpr result_type min()
Gets the minimum value in the generated random number range.
_RealType b() const
Return the parameter of the distribution.
discard_block_engine(_RandomNumberEngine &&__rng)
Move constructs a discard_block_engine engine.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::discard_block_engine< _RandomNumberEngine1, __p1, __r1 > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
void discard(unsigned long long __z)
Discard a sequence of random numbers.
static constexpr result_type multiplier
result_type operator()()
Gets the next value in the generated random number sequence.
friend bool operator==(const discrete_distribution &__d1, const discrete_distribution &__d2)
Return true if two discrete distributions have the same parameters.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const geometric_distribution &__d1, const geometric_distribution &__d2)
Return true if two geometric distributions have the same parameters.
param_type param() const
Returns the parameter set of the distribution.
normal_distribution(result_type __mean=result_type(0), result_type __stddev=result_type(1))
void seed()
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
void seed()
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const chi_squared_distribution &__d1, const chi_squared_distribution &__d2)
Return true if two Chi-squared distributions have the same parameters and the sequences that would be...
void discard(unsigned long long __z)
Discard a sequence of random numbers.
friend bool operator==(const fisher_f_distribution &__d1, const fisher_f_distribution &__d2)
Return true if two Fisher f distributions have the same parameters and the sequences that would be ge...
bernoulli_distribution(double __p=0.5)
Constructs a Bernoulli distribution with likelihood p.
param_type param() const
Returns the parameter set of the distribution.
shuffle_order_engine(result_type __s)
Seed constructs a shuffle_order_engine engine.
result_type min() const
Returns the greatest lower bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
std::vector< _RealType > intervals() const
Return the intervals of the distribution.
void reset()
Resets the distribution state.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
void param(const param_type &__param)
Sets the parameter set of the distribution.
param_type param() const
Returns the parameter set of the distribution.
std::vector< double > probabilities() const
Returns the probabilities of the distribution.
param_type param() const
Returns the parameter set of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type min() const
Returns the greatest lower bound value of the distribution.
result_type operator()()
Gets the next random number in the sequence.
result_type min() const
Returns the greatest lower bound value of the distribution.
result_type min() const
Returns the inclusive lower bound of the distribution range.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
_RandomNumberEngine::result_type result_type
friend bool operator==(const weibull_distribution &__d1, const weibull_distribution &__d2)
Return true if two Weibull distributions have the same parameters.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::chi_squared_distribution< _RealType1 > &__x)
Inserts a chi_squared_distribution random number distribution __x into the output stream __os.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
param_type param() const
Returns the parameter set of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
_RealType alpha() const
Returns the of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
mersenne_twister_engine(_Sseq &__q)
Constructs a mersenne_twister_engine random number generator engine seeded from the seed sequence __q...
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::normal_distribution< _RealType1 > &__x)
Extracts a normal_distribution random number distribution __x from the input stream __is.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::lognormal_distribution< _RealType1 > &__x)
Extracts a lognormal_distribution random number distribution __x from the input stream __is.
_RealType b() const
Return the parameter of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::mersenne_twister_engine< _UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1 > &__x)
Extracts the current state of a % mersenne_twister_engine random number generator engine __x from the...
static constexpr result_type max()
Gets the largest possible value in the output range.
friend bool operator==(const piecewise_constant_distribution &__d1, const piecewise_constant_distribution &__d2)
Return true if two piecewise constant distributions have the same parameters.
double mean() const
Returns the distribution parameter mean.
result_type min() const
Returns the greatest lower bound value of the distribution.
static constexpr result_type min()
Gets the inclusive minimum value of the range of random integers returned by this generator.
friend bool operator==(const mersenne_twister_engine &__lhs, const mersenne_twister_engine &__rhs)
Compares two % mersenne_twister_engine random number generator objects of the same type for equality.
friend bool operator==(const uniform_real_distribution &__d1, const uniform_real_distribution &__d2)
Return true if two uniform real distributions have the same parameters.
friend bool operator==(const poisson_distribution &__d1, const poisson_distribution &__d2)
Return true if two Poisson distributions have the same parameters and the sequences that would be gen...
void reset()
Resets the distribution state.
friend bool operator==(const binomial_distribution &__d1, const binomial_distribution &__d2)
Return true if two binomial distributions have the same parameters and the sequences that would be ge...
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::mersenne_twister_engine< _UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1 > &__x)
Inserts the current state of a % mersenne_twister_engine random number generator engine __x into the ...
param_type param() const
Returns the parameter set of the distribution.
static constexpr result_type max()
Gets the maximum value in the generated random number range.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void seed(result_type __s)
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
friend bool operator==(const cauchy_distribution &__d1, const cauchy_distribution &__d2)
Return true if two Cauchy distributions have the same parameters.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void seed(result_type __s=default_seed)
Reseeds the linear_congruential_engine random number generator engine sequence to the seed __s.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void seed(_Sseq &__q)
Reseeds the discard_block_engine object with the given seed sequence.
discard_block_engine()
Constructs a default discard_block_engine engine.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::binomial_distribution< _IntType1 > &__x)
Extracts a binomial_distribution random number distribution __x from the input stream __is.
result_type max() const
Returns the inclusive upper bound of the distribution range.
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
_IntType t() const
Returns the distribution t parameter.
result_type min() const
Returns the greatest lower bound value of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
result_type min() const
Returns the greatest lower bound value of the distribution.
friend bool operator==(const discard_block_engine &__lhs, const discard_block_engine &__rhs)
Compares two discard_block_engine random number generator objects of the same type for equality.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::negative_binomial_distribution< _IntType1 > &__x)
Extracts a negative_binomial_distribution random number distribution __x from the input stream __is.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::lognormal_distribution< _RealType1 > &__x)
Inserts a lognormal_distribution random number distribution __x into the output stream __os.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::subtract_with_carry_engine< _UIntType1, __w1, __s1, __r1 > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
friend bool operator==(const subtract_with_carry_engine &__lhs, const subtract_with_carry_engine &__rhs)
Compares two % subtract_with_carry_engine random number generator objects of the same type for equali...
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::student_t_distribution< _RealType1 > &__x)
Inserts a student_t_distribution random number distribution __x into the output stream __os.
friend bool operator==(const piecewise_linear_distribution &__d1, const piecewise_linear_distribution &__d2)
Return true if two piecewise linear distributions have the same parameters.
gamma_distribution(_RealType __alpha_val=_RealType(1), _RealType __beta_val=_RealType(1))
Constructs a gamma distribution with parameters and .
static constexpr result_type min()
Gets the smallest possible value in the output range.
friend bool operator==(const linear_congruential_engine &__lhs, const linear_congruential_engine &__rhs)
Compares two linear congruential random number generator objects of the same type for equality.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type max() const
Returns the least upper bound value of the distribution.
uniform_real_distribution(_RealType __a=_RealType(0), _RealType __b=_RealType(1))
Constructs a uniform_real_distribution object.
result_type max() const
Returns the least upper bound value of the distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
discard_block_engine(_Sseq &__q)
Generator construct a discard_block_engine engine.
friend bool operator==(const independent_bits_engine &__lhs, const independent_bits_engine &__rhs)
Compares two independent_bits_engine random number generator objects of the same type for equality.
friend bool operator==(const gamma_distribution &__d1, const gamma_distribution &__d2)
Return true if two gamma distributions have the same parameters and the sequences that would be gener...
result_type max() const
Returns the least upper bound value of the distribution.
result_type operator()()
Gets the next value in the generated random number sequence.
double p() const
Return the parameter of the distribution.
_RealType mean() const
Returns the mean of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void seed(_Sseq &__q)
Reseeds the shuffle_order_engine object with the given seed sequence.
static constexpr result_type max()
Gets the maximum value in the generated random number range.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::normal_distribution< _RealType1 > &__x)
Inserts a normal_distribution random number distribution __x into the output stream __os.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void seed(_Sseq &__q)
Reseeds the independent_bits_engine object with the given seed sequence.
independent_bits_engine()
Constructs a default independent_bits_engine engine.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::poisson_distribution< _IntType1 > &__x)
Inserts a poisson_distribution random number distribution __x into the output stream __os.
const _RandomNumberEngine & base() const noexcept
Gets a const reference to the underlying generator engine object.
result_type max() const
Returns the least upper bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend bool operator==(const shuffle_order_engine &__lhs, const shuffle_order_engine &__rhs)
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::binomial_distribution< _IntType1 > &__x)
Inserts a binomial_distribution random number distribution __x into the output stream __os.
_RealType beta() const
Returns the of the distribution.
param_type param() const
Returns the parameter set of the distribution.
void reset()
Resets the distribution state.
friend bool operator==(const exponential_distribution &__d1, const exponential_distribution &__d2)
Return true if two exponential distributions have the same parameters.
subtract_with_carry_engine(result_type __sd=default_seed)
Constructs an explicitly seeded % subtract_with_carry_engine random number generator.
result_type min() const
Returns the greatest lower bound value of the distribution.
void discard(unsigned long long __z)
_RealType a() const
Return the parameter of the distribution.
void reset()
Resets the distribution state.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::gamma_distribution< _RealType1 > &__x)
Extracts a gamma_distribution random number distribution __x from the input stream __is.
void param(const param_type &__param)
Sets the parameter set of the distribution.
param_type param() const
Returns the parameter set of the distribution.
static constexpr result_type increment
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::chi_squared_distribution< _RealType1 > &__x)
Extracts a chi_squared_distribution random number distribution __x from the input stream __is.
independent_bits_engine(result_type __s)
Seed constructs a independent_bits_engine engine.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::poisson_distribution< _IntType1 > &__x)
Extracts a poisson_distribution random number distribution __x from the input stream __is.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::linear_congruential_engine< _UIntType1, __a1, __c1, __m1 > &__lcr)
Writes the textual representation of the state x(i) of x to __os.
param_type param() const
Returns the parameter set of the distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::student_t_distribution< _RealType1 > &__x)
Extracts a student_t_distribution random number distribution __x from the input stream __is.
double p() const
Returns the p parameter of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::piecewise_constant_distribution< _RealType1 > &__x)
Extracts a piecewise_constant_distribution random number distribution __x from the input stream __is.
result_type max() const
Returns the least upper bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type operator()()
Gets the next random number in the sequence.
result_type max() const
Returns the least upper bound value of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
independent_bits_engine(_RandomNumberEngine &&__rng)
Move constructs a independent_bits_engine engine.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
std::vector< _RealType > intervals() const
Returns a vector of the intervals.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::fisher_f_distribution< _RealType1 > &__x)
Inserts a fisher_f_distribution random number distribution __x into the output stream __os.
friend bool operator==(const negative_binomial_distribution &__d1, const negative_binomial_distribution &__d2)
Return true if two negative binomial distributions have the same parameters and the sequences that wo...
void seed(result_type __s)
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
std::vector< double > densities() const
Return a vector of the probability densities of the distribution.
subtract_with_carry_engine(_Sseq &__q)
Constructs a subtract_with_carry_engine random number engine seeded from the seed sequence __q.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
static constexpr result_type max()
Gets the inclusive maximum value of the range of random integers returned by this generator.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::shuffle_order_engine< _RandomNumberEngine1, __k1 > &__x)
Inserts the current state of a shuffle_order_engine random number generator engine __x into the outpu...
_RealType a() const
Return the parameter of the distribution.
double p() const
Returns the distribution p parameter.
discard_block_engine(result_type __s)
Seed constructs a discard_block_engine engine.
static constexpr result_type max()
Gets the largest possible value in the output range.
param_type param() const
Returns the parameter set of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::shuffle_order_engine< _RandomNumberEngine1, __k1 > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
result_type min() const
Returns the greatest lower bound value of the distribution.
param_type param() const
Returns the parameter set of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::fisher_f_distribution< _RealType1 > &__x)
Extracts a fisher_f_distribution random number distribution __x from the input stream __is.
_IntType k() const
Return the parameter of the distribution.
_RandomNumberEngine::result_type result_type
friend bool operator==(const std::normal_distribution< _RealType1 > &__d1, const std::normal_distribution< _RealType1 > &__d2)
Return true if two normal distributions have the same parameters and the sequences that would be gene...
void reset()
Resets the distribution state.
result_type min() const
Returns the greatest lower bound value of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::piecewise_linear_distribution< _RealType1 > &__x)
Inserts a piecewise_linear_distribution random number distribution __x into the output stream __os.
friend bool operator==(const extreme_value_distribution &__d1, const extreme_value_distribution &__d2)
Return true if two extreme value distributions have the same parameters.
param_type param() const
Returns the parameter set of the distribution.
ISO C++ entities toplevel namespace is std.
constexpr int __lg(int __n)
This is a helper function for the sort routines and for random.tcc.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
Properties of fundamental types.
static constexpr _Tp max() noexcept
static constexpr _Tp lowest() noexcept
static constexpr _Tp min() noexcept
A model of a linear congruential random number generator.
The Marsaglia-Zaman generator.
Produces random numbers by combining random numbers from some base engine to produce random numbers w...
Uniform continuous distribution for random numbers.
A normal continuous distribution for random numbers.
A lognormal_distribution random number distribution.
A gamma continuous distribution for random numbers.
A chi_squared_distribution random number distribution.
A cauchy_distribution random number distribution.
A fisher_f_distribution random number distribution.
A student_t_distribution random number distribution.
A Bernoulli random number distribution.
A discrete binomial random number distribution.
A discrete geometric random number distribution.
A negative_binomial_distribution random number distribution.
A discrete Poisson random number distribution.
An exponential continuous distribution for random numbers.
A weibull_distribution random number distribution.
A extreme_value_distribution random number distribution.
A discrete_distribution random number distribution.
A piecewise_constant_distribution random number distribution.
A piecewise_linear_distribution random number distribution.
The seed_seq class generates sequences of seeds for random number generators.
One of the math functors.
bool empty() const noexcept
reference front() noexcept
iterator begin() noexcept
reference back() noexcept
size_type size() const noexcept