37namespace std _GLIBCXX_VISIBILITY(default)
39_GLIBCXX_BEGIN_NAMESPACE_VERSION
58 template<
typename _RealType,
size_t __bits,
59 typename _UniformRandomNumberGenerator>
67#pragma GCC diagnostic push
68#pragma GCC diagnostic ignored "-Wc++17-extensions"
70 template<
typename _UIntType,
size_t __w,
74 {
static constexpr _UIntType __value = 0; };
76 template<
typename _UIntType,
size_t __w>
77 struct _Shift<_UIntType, __w, true>
78 {
static constexpr _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 {
using type =
unsigned int; };
97 struct _Select_uint_least_t<__s, 3>
98 {
using type =
unsigned long; };
101 struct _Select_uint_least_t<__s, 2>
102 {
using type =
unsigned long long; };
104#if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
106 struct _Select_uint_least_t<__s, 1>
107 { __extension__
using type =
unsigned __int128; };
108#elif __has_builtin(__builtin_add_overflow) \
109 && __has_builtin(__builtin_sub_overflow) \
110 && defined __UINT64_TYPE__
112 struct _Select_uint_least_t<__s, 1>
119 type(uint64_t __a) noexcept : _M_lo(__a), _M_hi(0) { }
123 operator*(type __l, uint64_t __x)
noexcept
129 constexpr uint64_t __mask = 0xffffffff;
130 uint64_t __ll[2] = { __l._M_lo >> 32, __l._M_lo & __mask };
131 uint64_t __xx[2] = { __x >> 32, __x & __mask };
132 uint64_t __l0x0 = __ll[0] * __xx[0];
133 uint64_t __l0x1 = __ll[0] * __xx[1];
134 uint64_t __l1x0 = __ll[1] * __xx[0];
135 uint64_t __l1x1 = __ll[1] * __xx[1];
139 = (__l0x1 & __mask) + (__l1x0 & __mask) + (__l1x1 >> 32);
140 __l._M_hi = __l0x0 + (__l0x1 >> 32) + (__l1x0 >> 32) + (__mid >> 32);
141 __l._M_lo = (__mid << 32) + (__l1x1 & __mask);
146 operator+(type __l, uint64_t __c)
noexcept
148 __l._M_hi += __builtin_add_overflow(__l._M_lo, __c, &__l._M_lo);
153 operator%(type __l, uint64_t __m)
noexcept
155 if (__builtin_expect(__l._M_hi == 0, 0))
161 int __shift = __builtin_clzll(__m) + 64
162 - __builtin_clzll(__l._M_hi);
166 __x._M_hi = __m << (__shift - 64);
171 __x._M_hi = __m >> (64 - __shift);
172 __x._M_lo = __m << __shift;
175 while (__l._M_hi != 0 || __l._M_lo >= __m)
179 __l._M_hi -= __x._M_hi;
180 __l._M_hi -= __builtin_sub_overflow(__l._M_lo, __x._M_lo,
183 __x._M_lo = (__x._M_lo >> 1) | (__x._M_hi << 63);
190 explicit operator uint64_t() const noexcept
193 friend bool operator<(
const type& __l,
const type& __r)
noexcept
195 if (__l._M_hi < __r._M_hi)
197 else if (__l._M_hi == __r._M_hi)
198 return __l._M_lo < __r._M_lo;
203 friend bool operator<=(
const type& __l,
const type& __r)
noexcept
204 {
return !(__r < __l); }
213 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
214 bool __big_enough = (!(__m & (__m - 1))
215 || (_Tp(-1) - __c) / __a >= __m - 1),
216 bool __schrage_ok = __m % __a < __m / __a>
223 =
typename _Select_uint_least_t<
std::__lg(__a)
225 return static_cast<_Tp
>((_Tp2(__a) * __x + __c) % __m);
230 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
231 struct _Mod<_Tp, __m, __a, __c, false, true>
240 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
241 struct _Mod<_Tp, __m, __a, __c, true, __s>
246 _Tp __res = __a * __x + __c;
253 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
257 if constexpr (__a == 0)
260 return _Mod<_Tp, __m, __a, __c>::__calc(__x);
267 template<
typename _Engine,
typename _DInputType>
271 "template argument must be a floating point type");
274 _Adaptor(_Engine& __g)
279 {
return _DInputType(0); }
283 {
return _DInputType(1); }
307 template<
typename _Sseq>
308 using __seed_seq_generate_t =
decltype(
312 template<
typename _Sseq,
typename _Engine,
typename _Res,
313 typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
314 using _If_seed_seq_for = _Require<
315 __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
316 is_unsigned<typename _Sseq::result_type>,
317 __not_<is_convertible<_Sseq, _Res>>
320#pragma GCC diagnostic pop
365 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
369 "result_type must be an unsigned integral type");
370 static_assert(
__m == 0
u || (__a <
__m && __c <
__m),
371 "template argument substituting __m out of bounds");
373 template<
typename _Sseq>
414 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
435 template<
typename _Sseq>
447 {
return __c == 0
u ? 1u : 0
u; }
472 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
531#if __cpp_impl_three_way_comparison < 201907L
543 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
583 template<
typename _UIntType,
size_t __w,
584 size_t __n,
size_t __m,
size_t __r,
585 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
586 _UIntType __b,
size_t __t,
587 _UIntType __c,
size_t __l, _UIntType __f>
591 "result_type must be an unsigned integral type");
592 static_assert(1u <=
__m &&
__m <= __n,
593 "template argument substituting __m out of bounds");
594 static_assert(__r <=
__w,
"template argument substituting "
596 static_assert(
__u <=
__w,
"template argument substituting "
598 static_assert(
__s <=
__w,
"template argument substituting "
600 static_assert(__t <=
__w,
"template argument substituting "
602 static_assert(
__l <=
__w,
"template argument substituting "
605 "template argument substituting __w out of bound");
606 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
607 "template argument substituting __a out of bound");
608 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
609 "template argument substituting __b out of bound");
610 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
611 "template argument substituting __c out of bound");
612 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
613 "template argument substituting __d out of bound");
614 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
615 "template argument substituting __f out of bound");
617 template<
typename _Sseq>
627 static constexpr size_t word_size =
__w;
628 static constexpr size_t state_size = __n;
629 static constexpr size_t shift_size =
__m;
630 static constexpr size_t mask_bits = __r;
632 static constexpr size_t tempering_u =
__u;
634 static constexpr size_t tempering_s =
__s;
636 static constexpr size_t tempering_t = __t;
638 static constexpr size_t tempering_l =
__l;
639 static constexpr result_type initialization_multiplier = __f;
656 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
664 template<
typename _Sseq>
680 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
728 typename _CharT,
typename _Traits>
754 typename _CharT,
typename _Traits>
764 _UIntType _M_x[state_size];
768#if __cpp_impl_three_way_comparison < 201907L
781 template<
typename _UIntType,
size_t __w,
782 size_t __n,
size_t __m,
size_t __r,
783 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
784 _UIntType __b,
size_t __t,
785 _UIntType __c,
size_t __l, _UIntType __f>
788 __r, __a,
__u, __d,
__s, __b, __t, __c,
__l, __f>&
__lhs,
812 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
816 "result_type must be an unsigned integral type");
817 static_assert(0
u <
__s &&
__s < __r,
820 "template argument substituting __w out of bounds");
822 template<
typename _Sseq>
832 static constexpr size_t word_size =
__w;
833 static constexpr size_t short_lag =
__s;
834 static constexpr size_t long_lag = __r;
835 static constexpr uint_least32_t default_seed = 19780503u;
854 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
878 template<
typename _Sseq>
896 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
946 typename _CharT,
typename _Traits>
965 typename _CharT,
typename _Traits>
973 _UIntType _M_x[long_lag];
978#if __cpp_impl_three_way_comparison < 201907L
991 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
1009 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1012 static_assert(1 <= __r && __r <= __p,
1013 "template argument substituting __r out of bounds");
1019 template<
typename _Sseq>
1025 static constexpr size_t block_size = __p;
1026 static constexpr size_t used_block = __r;
1034 : _M_b(), _M_n(0) { }
1044 : _M_b(
__rng), _M_n(0) { }
1064 : _M_b(
__s), _M_n(0) { }
1071 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1074 : _M_b(__q), _M_n(0)
1104 template<
typename _Sseq>
1116 const _RandomNumberEngine&
1125 {
return _RandomNumberEngine::min(); }
1132 {
return _RandomNumberEngine::max(); }
1178 typename _CharT,
typename _Traits>
1196 typename _CharT,
typename _Traits>
1203 _RandomNumberEngine _M_b;
1207#if __cpp_impl_three_way_comparison < 201907L
1219 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1235 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1239 "result_type must be an unsigned integral type");
1241 "template argument substituting __w out of bounds");
1243 template<
typename _Sseq>
1295 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1322 template<
typename _Sseq>
1331 const _RandomNumberEngine&
1347 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1394 template<
typename _CharT,
typename _Traits>
1398 __w, _UIntType>& __x)
1405 _RandomNumberEngine _M_b;
1408#if __cpp_impl_three_way_comparison < 201907L
1421 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1427 {
return !(__lhs == __rhs); }
1440 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1441 typename _CharT,
typename _Traits>
1445 __w, _UIntType>& __x)
1462 template<
typename _RandomNumberEngine,
size_t __k>
1465 static_assert(1u <=
__k,
"template argument substituting "
1466 "__k out of bound");
1472 template<
typename _Sseq>
1477 static constexpr size_t table_size =
__k;
1486 { _M_initialize(); }
1497 { _M_initialize(); }
1508 { _M_initialize(); }
1519 { _M_initialize(); }
1526 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1530 { _M_initialize(); }
1559 template<
typename _Sseq>
1570 const _RandomNumberEngine&
1579 {
return _RandomNumberEngine::min(); }
1586 {
return _RandomNumberEngine::max(); }
1634 typename _CharT,
typename _Traits>
1652 typename _CharT,
typename _Traits>
1658 void _M_initialize()
1660 for (
size_t __i = 0; __i <
__k; ++__i)
1665 _RandomNumberEngine _M_b;
1670#if __cpp_impl_three_way_comparison < 201907L
1682 template<
typename _RandomNumberEngine,
size_t __k>
1688 {
return !(__lhs == __rhs); }
1694 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1725 0xb5026f5aa96619e9ULL, 29,
1726 0x5555555555555555ULL, 17,
1727 0x71d67fffeda60000ULL, 37,
1728 0xfff7eee000000000ULL, 43,
1777 entropy() const noexcept
1778 {
return this->_M_getentropy(); }
1782 {
return this->_M_getval(); }
1785 random_device(
const random_device&) =
delete;
1786 void operator=(
const random_device&) =
delete;
1796 double _M_getentropy() const noexcept;
1798 void _M_init(const
char*,
size_t);
1828#if __cpp_impl_three_way_comparison < 201907L
1833 template<
typename _IntType>
1837 {
return !(__d1 == __d2); }
1850 template<
typename _IntType,
typename _CharT,
typename _Traits>
1864 template<
typename _IntType,
typename _CharT,
typename _Traits>
1880 template<
typename _RealType =
double>
1884 "result_type must be a floating point type");
1898 param_type(_RealType __a, _RealType __b = _RealType(1))
1899 : _M_a(__a), _M_b(__b)
1901 __glibcxx_assert(_M_a <= _M_b);
1916#if __cpp_impl_three_way_comparison < 201907L
1943 : _M_param(__a, __b)
1961 {
return _M_param.a(); }
1965 {
return _M_param.b(); }
1972 {
return _M_param; }
1987 {
return this->a(); }
1994 {
return this->b(); }
1999 template<
typename _UniformRandomNumberGenerator>
2002 {
return this->
operator()(__urng, _M_param); }
2004 template<
typename _UniformRandomNumberGenerator>
2007 const param_type& __p)
2009 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2011 return (
__aurng() * (__p.b() - __p.a())) + __p.a();
2014 template<
typename _ForwardIterator,
2015 typename _UniformRandomNumberGenerator>
2017 __generate(_ForwardIterator __f, _ForwardIterator __t,
2018 _UniformRandomNumberGenerator& __urng)
2019 { this->__generate(__f, __t, __urng, _M_param); }
2021 template<
typename _ForwardIterator,
2022 typename _UniformRandomNumberGenerator>
2024 __generate(_ForwardIterator __f, _ForwardIterator __t,
2025 _UniformRandomNumberGenerator& __urng,
2026 const param_type& __p)
2027 { this->__generate_impl(__f, __t, __urng, __p); }
2029 template<
typename _UniformRandomNumberGenerator>
2032 _UniformRandomNumberGenerator& __urng,
2033 const param_type& __p)
2034 { this->__generate_impl(__f, __t, __urng, __p); }
2043 {
return __d1._M_param ==
__d2._M_param; }
2051 const param_type& __p);
2053 param_type _M_param;
2056#if __cpp_impl_three_way_comparison < 201907L
2061 template<
typename _IntType>
2065 {
return !(__d1 == __d2); }
2078 template<
typename _RealType,
typename _CharT,
typename _Traits>
2092 template<
typename _RealType,
typename _CharT,
typename _Traits>
2117 template<
typename _RealType =
double>
2121 "result_type must be a floating point type");
2138 __glibcxx_assert(_M_stddev > _RealType(0));
2147 {
return _M_stddev; }
2151 {
return (
__p1._M_mean ==
__p2._M_mean
2152 &&
__p1._M_stddev ==
__p2._M_stddev); }
2154#if __cpp_impl_three_way_comparison < 201907L
2162 _RealType _M_stddev;
2188 { _M_saved_available =
false; }
2195 {
return _M_param.mean(); }
2202 {
return _M_param.stddev(); }
2209 {
return _M_param; }
2236 template<
typename _UniformRandomNumberGenerator>
2239 {
return this->
operator()(__urng, _M_param); }
2241 template<
typename _UniformRandomNumberGenerator>
2244 const param_type& __p);
2251 { this->__generate(__f, __t,
__urng, _M_param); }
2253 template<
typename _ForwardIterator,
2254 typename _UniformRandomNumberGenerator>
2256 __generate(_ForwardIterator __f, _ForwardIterator __t,
2257 _UniformRandomNumberGenerator& __urng,
2258 const param_type& __p)
2259 { this->__generate_impl(__f, __t, __urng, __p); }
2261 template<
typename _UniformRandomNumberGenerator>
2264 _UniformRandomNumberGenerator& __urng,
2265 const param_type& __p)
2266 { this->__generate_impl(__f, __t, __urng, __p); }
2273 template<
typename _RealType1>
2288 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2303 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2318 bool _M_saved_available =
false;
2321#if __cpp_impl_three_way_comparison < 201907L
2325 template<
typename _RealType>
2344 template<
typename _RealType =
double>
2348 "result_type must be a floating point type");
2378#if __cpp_impl_three_way_comparison < 201907L
2393 : _M_param(
__m,
__s), _M_nd()
2397 lognormal_distribution(
const param_type& __p)
2398 : _M_param(__p), _M_nd()
2413 {
return _M_param.m(); }
2417 {
return _M_param.s(); }
2424 {
return _M_param; }
2451 template<
typename _UniformRandomNumberGenerator>
2454 {
return this->
operator()(__urng, _M_param); }
2456 template<
typename _UniformRandomNumberGenerator>
2459 const param_type& __p)
2462 template<
typename _ForwardIterator,
2463 typename _UniformRandomNumberGenerator>
2465 __generate(_ForwardIterator __f, _ForwardIterator __t,
2466 _UniformRandomNumberGenerator& __urng)
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
2505 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2520 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2538#if __cpp_impl_three_way_comparison < 201907L
2542 template<
typename _RealType>
2569 template<
typename _RealType =
double>
2573 "result_type must be a floating point type");
2591 __glibcxx_assert(_M_alpha > _RealType(0));
2597 {
return _M_alpha; }
2605 {
return (
__p1._M_alpha ==
__p2._M_alpha
2606 &&
__p1._M_beta ==
__p2._M_beta); }
2608#if __cpp_impl_three_way_comparison < 201907L
2621 _RealType _M_malpha, _M_a2;
2642 : _M_param(__p), _M_nd()
2657 {
return _M_param.alpha(); }
2664 {
return _M_param.beta(); }
2671 {
return _M_param; }
2698 template<
typename _UniformRandomNumberGenerator>
2701 {
return this->
operator()(__urng, _M_param); }
2703 template<
typename _UniformRandomNumberGenerator>
2706 const param_type& __p);
2713 { this->__generate(__f, __t,
__urng, _M_param); }
2715 template<
typename _ForwardIterator,
2716 typename _UniformRandomNumberGenerator>
2718 __generate(_ForwardIterator __f, _ForwardIterator __t,
2719 _UniformRandomNumberGenerator& __urng,
2720 const param_type& __p)
2721 { this->__generate_impl(__f, __t, __urng, __p); }
2723 template<
typename _UniformRandomNumberGenerator>
2726 _UniformRandomNumberGenerator& __urng,
2727 const param_type& __p)
2728 { this->__generate_impl(__f, __t, __urng, __p); }
2738 {
return (
__d1._M_param ==
__d2._M_param
2751 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2765 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2783#if __cpp_impl_three_way_comparison < 201907L
2787 template<
typename _RealType>
2811 template<
typename _RealType =
double>
2815 "result_type must be a floating point type");
2841#if __cpp_impl_three_way_comparison < 201907L
2855 : _M_param(__n), _M_gd(__n / 2)
2859 chi_squared_distribution(
const param_type& __p)
2860 : _M_param(__p), _M_gd(__p.n() / 2)
2875 {
return _M_param.n(); }
2882 {
return _M_param; }
2914 template<
typename _UniformRandomNumberGenerator>
2917 {
return 2 * _M_gd(
__urng); }
2919 template<
typename _UniformRandomNumberGenerator>
2922 const param_type& __p)
2926 return 2 * _M_gd(
__urng, param_type(__p.n() / 2));
2929 template<
typename _ForwardIterator,
2930 typename _UniformRandomNumberGenerator>
2932 __generate(_ForwardIterator __f, _ForwardIterator __t,
2933 _UniformRandomNumberGenerator& __urng)
2934 { this->__generate_impl(__f, __t, __urng); }
2936 template<
typename _ForwardIterator,
2937 typename _UniformRandomNumberGenerator>
2939 __generate(_ForwardIterator __f, _ForwardIterator __t,
2940 _UniformRandomNumberGenerator& __urng,
2941 const param_type& __p)
2944 this->__generate_impl(__f, __t, __urng, __p2); }
2946 template<
typename _UniformRandomNumberGenerator>
2949 _UniformRandomNumberGenerator& __urng)
2950 { this->__generate_impl(__f, __t, __urng); }
2952 template<
typename _UniformRandomNumberGenerator>
2955 _UniformRandomNumberGenerator& __urng,
2956 const param_type& __p)
2959 this->__generate_impl(__f, __t, __urng, __p2); }
2981 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2996 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3021#if __cpp_impl_three_way_comparison < 201907L
3025 template<
typename _RealType>
3041 template<
typename _RealType =
double>
3045 "result_type must be a floating point type");
3059 param_type(_RealType __a, _RealType __b = _RealType(1))
3060 : _M_a(__a), _M_b(__b)
3075#if __cpp_impl_three_way_comparison < 201907L
3090 : _M_param(__a, __b)
3094 cauchy_distribution(
const param_type& __p)
3110 {
return _M_param.a(); }
3114 {
return _M_param.b(); }
3121 {
return _M_param; }
3148 template<
typename _UniformRandomNumberGenerator>
3151 {
return this->
operator()(__urng, _M_param); }
3153 template<
typename _UniformRandomNumberGenerator>
3156 const param_type& __p);
3163 { this->__generate(__f, __t,
__urng, _M_param); }
3165 template<
typename _ForwardIterator,
3166 typename _UniformRandomNumberGenerator>
3168 __generate(_ForwardIterator __f, _ForwardIterator __t,
3169 _UniformRandomNumberGenerator& __urng,
3170 const param_type& __p)
3171 { this->__generate_impl(__f, __t, __urng, __p); }
3173 template<
typename _UniformRandomNumberGenerator>
3176 _UniformRandomNumberGenerator& __urng,
3177 const param_type& __p)
3178 { this->__generate_impl(__f, __t, __urng, __p); }
3187 {
return __d1._M_param ==
__d2._M_param; }
3195 const param_type& __p);
3197 param_type _M_param;
3200#if __cpp_impl_three_way_comparison < 201907L
3205 template<
typename _RealType>
3209 {
return !(__d1 == __d2); }
3222 template<
typename _RealType,
typename _CharT,
typename _Traits>
3237 template<
typename _RealType,
typename _CharT,
typename _Traits>
3256 template<
typename _RealType =
double>
3260 "result_type must be a floating point type");
3275 : _M_m(
__m), _M_n(__n)
3290#if __cpp_impl_three_way_comparison < 201907L
3305 _RealType __n = _RealType(1))
3306 : _M_param(
__m, __n), _M_gd_x(
__m / 2), _M_gd_y(__n / 2)
3310 fisher_f_distribution(
const param_type& __p)
3311 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3329 {
return _M_param.m(); }
3333 {
return _M_param.n(); }
3340 {
return _M_param; }
3367 template<
typename _UniformRandomNumberGenerator>
3370 {
return (_M_gd_x(
__urng) * n()) / (_M_gd_y(
__urng) * m()); }
3372 template<
typename _UniformRandomNumberGenerator>
3375 const param_type& __p)
3379 return ((_M_gd_x(
__urng, param_type(__p.m() / 2)) * n())
3380 / (_M_gd_y(
__urng, param_type(__p.n() / 2)) * m()));
3383 template<
typename _ForwardIterator,
3384 typename _UniformRandomNumberGenerator>
3386 __generate(_ForwardIterator __f, _ForwardIterator __t,
3387 _UniformRandomNumberGenerator& __urng)
3388 { this->__generate_impl(__f, __t, __urng); }
3390 template<
typename _ForwardIterator,
3391 typename _UniformRandomNumberGenerator>
3393 __generate(_ForwardIterator __f, _ForwardIterator __t,
3394 _UniformRandomNumberGenerator& __urng,
3395 const param_type& __p)
3396 { this->__generate_impl(__f, __t, __urng, __p); }
3398 template<
typename _UniformRandomNumberGenerator>
3401 _UniformRandomNumberGenerator& __urng)
3402 { this->__generate_impl(__f, __t, __urng); }
3404 template<
typename _UniformRandomNumberGenerator>
3407 _UniformRandomNumberGenerator& __urng,
3408 const param_type& __p)
3409 { this->__generate_impl(__f, __t, __urng, __p); }
3419 {
return (
__d1._M_param ==
__d2._M_param
3421 &&
__d1._M_gd_y ==
__d2._M_gd_y); }
3433 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3448 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3472#if __cpp_impl_three_way_comparison < 201907L
3476 template<
typename _RealType>
3495 template<
typename _RealType =
double>
3499 "result_type must be a floating point type");
3525#if __cpp_impl_three_way_comparison < 201907L
3539 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3543 student_t_distribution(
const param_type& __p)
3544 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3562 {
return _M_param.n(); }
3569 {
return _M_param; }
3596 template<
typename _UniformRandomNumberGenerator>
3601 template<
typename _UniformRandomNumberGenerator>
3604 const param_type& __p)
3613 template<
typename _ForwardIterator,
3614 typename _UniformRandomNumberGenerator>
3616 __generate(_ForwardIterator __f, _ForwardIterator __t,
3617 _UniformRandomNumberGenerator& __urng)
3618 { this->__generate_impl(__f, __t, __urng); }
3620 template<
typename _ForwardIterator,
3621 typename _UniformRandomNumberGenerator>
3623 __generate(_ForwardIterator __f, _ForwardIterator __t,
3624 _UniformRandomNumberGenerator& __urng,
3625 const param_type& __p)
3626 { this->__generate_impl(__f, __t, __urng, __p); }
3628 template<
typename _UniformRandomNumberGenerator>
3631 _UniformRandomNumberGenerator& __urng)
3632 { this->__generate_impl(__f, __t, __urng); }
3634 template<
typename _UniformRandomNumberGenerator>
3637 _UniformRandomNumberGenerator& __urng,
3638 const param_type& __p)
3639 { this->__generate_impl(__f, __t, __urng, __p); }
3649 {
return (
__d1._M_param ==
__d2._M_param
3662 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3677 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3701#if __cpp_impl_three_way_comparison < 201907L
3705 template<
typename _RealType>
3746 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3757#if __cpp_impl_three_way_comparison < 201907L
3802 {
return _M_param.p(); }
3809 {
return _M_param; }
3836 template<
typename _UniformRandomNumberGenerator>
3839 {
return this->
operator()(__urng, _M_param); }
3841 template<
typename _UniformRandomNumberGenerator>
3844 const param_type& __p)
3846 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3854 template<
typename _ForwardIterator,
3855 typename _UniformRandomNumberGenerator>
3857 __generate(_ForwardIterator __f, _ForwardIterator __t,
3858 _UniformRandomNumberGenerator& __urng)
3859 { this->__generate(__f, __t, __urng, _M_param); }
3861 template<
typename _ForwardIterator,
3862 typename _UniformRandomNumberGenerator>
3864 __generate(_ForwardIterator __f, _ForwardIterator __t,
3865 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3866 { this->__generate_impl(__f, __t, __urng, __p); }
3868 template<
typename _UniformRandomNumberGenerator>
3871 _UniformRandomNumberGenerator& __urng,
3872 const param_type& __p)
3873 { this->__generate_impl(__f, __t, __urng, __p); }
3882 {
return __d1._M_param ==
__d2._M_param; }
3890 const param_type& __p);
3892 param_type _M_param;
3895#if __cpp_impl_three_way_comparison < 201907L
3903 {
return !(__d1 == __d2); }
3916 template<
typename _CharT,
typename _Traits>
3930 template<
typename _CharT,
typename _Traits>
3952 template<
typename _IntType =
int>
3956 "result_type must be an integral type");
3972 : _M_t(__t), _M_p(__p)
3974 __glibcxx_assert((_M_t >= _IntType(0))
3992#if __cpp_impl_three_way_comparison < 201907L
4006#if _GLIBCXX_USE_C99_MATH_FUNCS
4019 : _M_param(__t, __p), _M_nd()
4023 binomial_distribution(
const param_type& __p)
4024 : _M_param(__p), _M_nd()
4039 {
return _M_param.t(); }
4046 {
return _M_param.p(); }
4053 {
return _M_param; }
4075 {
return _M_param.t(); }
4080 template<
typename _UniformRandomNumberGenerator>
4083 {
return this->
operator()(__urng, _M_param); }
4085 template<
typename _UniformRandomNumberGenerator>
4088 const param_type& __p);
4095 { this->__generate(__f, __t,
__urng, _M_param); }
4097 template<
typename _ForwardIterator,
4098 typename _UniformRandomNumberGenerator>
4100 __generate(_ForwardIterator __f, _ForwardIterator __t,
4101 _UniformRandomNumberGenerator& __urng,
4102 const param_type& __p)
4103 { this->__generate_impl(__f, __t, __urng, __p); }
4105 template<
typename _UniformRandomNumberGenerator>
4108 _UniformRandomNumberGenerator& __urng,
4109 const param_type& __p)
4110 { this->__generate_impl(__f, __t, __urng, __p); }
4120#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
4123 {
return __d1._M_param ==
__d2._M_param; }
4136 template<
typename _IntType1,
4137 typename _CharT,
typename _Traits>
4153 typename _CharT,
typename _Traits>
4166 template<
typename _UniformRandomNumberGenerator>
4169 _IntType __t,
double __q);
4177#if __cpp_impl_three_way_comparison < 201907L
4181 template<
typename _IntType>
4198 template<
typename _IntType =
int>
4202 "result_type must be an integral type");
4220 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4232#if __cpp_impl_three_way_comparison < 201907L
4241 { _M_log_1_p =
std::log(1.0 - _M_p); }
4258 geometric_distribution(
const param_type& __p)
4275 {
return _M_param.p(); }
4282 {
return _M_param; }
4309 template<
typename _UniformRandomNumberGenerator>
4312 {
return this->
operator()(__urng, _M_param); }
4314 template<
typename _UniformRandomNumberGenerator>
4317 const param_type& __p);
4324 { this->__generate(__f, __t,
__urng, _M_param); }
4326 template<
typename _ForwardIterator,
4327 typename _UniformRandomNumberGenerator>
4329 __generate(_ForwardIterator __f, _ForwardIterator __t,
4330 _UniformRandomNumberGenerator& __urng,
4331 const param_type& __p)
4332 { this->__generate_impl(__f, __t, __urng, __p); }
4334 template<
typename _UniformRandomNumberGenerator>
4337 _UniformRandomNumberGenerator& __urng,
4338 const param_type& __p)
4339 { this->__generate_impl(__f, __t, __urng, __p); }
4348 {
return __d1._M_param ==
__d2._M_param; }
4356 const param_type& __p);
4358 param_type _M_param;
4361#if __cpp_impl_three_way_comparison < 201907L
4366 template<
typename _IntType>
4370 {
return !(__d1 == __d2); }
4383 template<
typename _IntType,
4384 typename _CharT,
typename _Traits>
4398 template<
typename _IntType,
4399 typename _CharT,
typename _Traits>
4415 template<
typename _IntType =
int>
4419 "result_type must be an integral type");
4434 : _M_k(
__k), _M_p(__p)
4436 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4451#if __cpp_impl_three_way_comparison < 201907L
4466 : _M_param(
__k, __p), _M_gd(
__k, (1.0 - __p) / __p)
4470 negative_binomial_distribution(
const param_type& __p)
4471 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4486 {
return _M_param.k(); }
4493 {
return _M_param.p(); }
4500 {
return _M_param; }
4527 template<
typename _UniformRandomNumberGenerator>
4531 template<
typename _UniformRandomNumberGenerator>
4534 const param_type& __p);
4541 { this->__generate_impl(__f, __t,
__urng); }
4543 template<
typename _ForwardIterator,
4544 typename _UniformRandomNumberGenerator>
4546 __generate(_ForwardIterator __f, _ForwardIterator __t,
4547 _UniformRandomNumberGenerator& __urng,
4548 const param_type& __p)
4549 { this->__generate_impl(__f, __t, __urng, __p); }
4551 template<
typename _UniformRandomNumberGenerator>
4554 _UniformRandomNumberGenerator& __urng)
4555 { this->__generate_impl(__f, __t, __urng); }
4557 template<
typename _UniformRandomNumberGenerator>
4560 _UniformRandomNumberGenerator& __urng,
4561 const param_type& __p)
4562 { this->__generate_impl(__f, __t, __urng, __p); }
4585 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4600 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4623#if __cpp_impl_three_way_comparison < 201907L
4627 template<
typename _IntType>
4652 template<
typename _IntType =
int>
4656 "result_type must be an integral type");
4674 __glibcxx_assert(_M_mean > 0.0);
4684 {
return __p1._M_mean ==
__p2._M_mean; }
4686#if __cpp_impl_three_way_comparison < 201907L
4700#if _GLIBCXX_USE_C99_MATH_FUNCS
4711 : _M_param(
__mean), _M_nd()
4715 poisson_distribution(
const param_type& __p)
4716 : _M_param(__p), _M_nd()
4731 {
return _M_param.mean(); }
4738 {
return _M_param; }
4765 template<
typename _UniformRandomNumberGenerator>
4768 {
return this->
operator()(__urng, _M_param); }
4770 template<
typename _UniformRandomNumberGenerator>
4773 const param_type& __p);
4780 { this->__generate(__f, __t,
__urng, _M_param); }
4782 template<
typename _ForwardIterator,
4783 typename _UniformRandomNumberGenerator>
4785 __generate(_ForwardIterator __f, _ForwardIterator __t,
4786 _UniformRandomNumberGenerator& __urng,
4787 const param_type& __p)
4788 { this->__generate_impl(__f, __t, __urng, __p); }
4790 template<
typename _UniformRandomNumberGenerator>
4793 _UniformRandomNumberGenerator& __urng,
4794 const param_type& __p)
4795 { this->__generate_impl(__f, __t, __urng, __p); }
4805#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
4808 {
return __d1._M_param ==
__d2._M_param; }
4821 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4836 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4855#if __cpp_impl_three_way_comparison < 201907L
4859 template<
typename _IntType>
4884 template<
typename _RealType =
double>
4888 "result_type must be a floating point type");
4905 __glibcxx_assert(_M_lambda > _RealType(0));
4910 {
return _M_lambda; }
4914 {
return __p1._M_lambda ==
__p2._M_lambda; }
4916#if __cpp_impl_three_way_comparison < 201907L
4923 _RealType _M_lambda;
4960 {
return _M_param.lambda(); }
4967 {
return _M_param; }
4994 template<
typename _UniformRandomNumberGenerator>
4997 {
return this->
operator()(__urng, _M_param); }
4999 template<
typename _UniformRandomNumberGenerator>
5002 const param_type& __p)
5004 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
5009 template<
typename _ForwardIterator,
5010 typename _UniformRandomNumberGenerator>
5012 __generate(_ForwardIterator __f, _ForwardIterator __t,
5013 _UniformRandomNumberGenerator& __urng)
5014 { this->__generate(__f, __t, __urng, _M_param); }
5016 template<
typename _ForwardIterator,
5017 typename _UniformRandomNumberGenerator>
5019 __generate(_ForwardIterator __f, _ForwardIterator __t,
5020 _UniformRandomNumberGenerator& __urng,
5021 const param_type& __p)
5022 { this->__generate_impl(__f, __t, __urng, __p); }
5024 template<
typename _UniformRandomNumberGenerator>
5027 _UniformRandomNumberGenerator& __urng,
5028 const param_type& __p)
5029 { this->__generate_impl(__f, __t, __urng, __p); }
5038 {
return __d1._M_param ==
__d2._M_param; }
5046 const param_type& __p);
5048 param_type _M_param;
5051#if __cpp_impl_three_way_comparison < 201907L
5056 template<
typename _RealType>
5060 {
return !(__d1 == __d2); }
5073 template<
typename _RealType,
typename _CharT,
typename _Traits>
5088 template<
typename _RealType,
typename _CharT,
typename _Traits>
5106 template<
typename _RealType =
double>
5110 "result_type must be a floating point type");
5124 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5125 : _M_a(__a), _M_b(__b)
5140#if __cpp_impl_three_way_comparison < 201907L
5155 : _M_param(__a, __b)
5159 weibull_distribution(
const param_type& __p)
5175 {
return _M_param.a(); }
5182 {
return _M_param.b(); }
5189 {
return _M_param; }
5216 template<
typename _UniformRandomNumberGenerator>
5219 {
return this->
operator()(__urng, _M_param); }
5221 template<
typename _UniformRandomNumberGenerator>
5224 const param_type& __p);
5231 { this->__generate(__f, __t,
__urng, _M_param); }
5233 template<
typename _ForwardIterator,
5234 typename _UniformRandomNumberGenerator>
5236 __generate(_ForwardIterator __f, _ForwardIterator __t,
5237 _UniformRandomNumberGenerator& __urng,
5238 const param_type& __p)
5239 { this->__generate_impl(__f, __t, __urng, __p); }
5241 template<
typename _UniformRandomNumberGenerator>
5244 _UniformRandomNumberGenerator& __urng,
5245 const param_type& __p)
5246 { this->__generate_impl(__f, __t, __urng, __p); }
5255 {
return __d1._M_param ==
__d2._M_param; }
5263 const param_type& __p);
5265 param_type _M_param;
5268#if __cpp_impl_three_way_comparison < 201907L
5273 template<
typename _RealType>
5277 {
return !(__d1 == __d2); }
5290 template<
typename _RealType,
typename _CharT,
typename _Traits>
5305 template<
typename _RealType,
typename _CharT,
typename _Traits>
5323 template<
typename _RealType =
double>
5327 "result_type must be a floating point type");
5341 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5342 : _M_a(__a), _M_b(__b)
5357#if __cpp_impl_three_way_comparison < 201907L
5372 : _M_param(__a, __b)
5376 extreme_value_distribution(
const param_type& __p)
5392 {
return _M_param.a(); }
5399 {
return _M_param.b(); }
5406 {
return _M_param; }
5433 template<
typename _UniformRandomNumberGenerator>
5436 {
return this->
operator()(__urng, _M_param); }
5438 template<
typename _UniformRandomNumberGenerator>
5441 const param_type& __p);
5448 { this->__generate(__f, __t,
__urng, _M_param); }
5450 template<
typename _ForwardIterator,
5451 typename _UniformRandomNumberGenerator>
5453 __generate(_ForwardIterator __f, _ForwardIterator __t,
5454 _UniformRandomNumberGenerator& __urng,
5455 const param_type& __p)
5456 { this->__generate_impl(__f, __t, __urng, __p); }
5458 template<
typename _UniformRandomNumberGenerator>
5461 _UniformRandomNumberGenerator& __urng,
5462 const param_type& __p)
5463 { this->__generate_impl(__f, __t, __urng, __p); }
5472 {
return __d1._M_param ==
__d2._M_param; }
5480 const param_type& __p);
5482 param_type _M_param;
5485#if __cpp_impl_three_way_comparison < 201907L
5490 template<
typename _RealType>
5494 {
return !(__d1 == __d2); }
5507 template<
typename _RealType,
typename _CharT,
typename _Traits>
5522 template<
typename _RealType,
typename _CharT,
typename _Traits>
5545 template<
typename _IntType =
int>
5549 "result_type must be an integral type");
5562 : _M_prob(), _M_cp()
5565 template<
typename _InputIterator>
5569 { _M_initialize(); }
5572 : _M_prob(
__wil.begin(),
__wil.end()), _M_cp()
5573 { _M_initialize(); }
5575 template<
typename _Func>
5584 probabilities()
const
5589 {
return __p1._M_prob ==
__p2._M_prob; }
5591#if __cpp_impl_three_way_comparison < 201907L
5609 template<
typename _InputIterator>
5615 discrete_distribution(initializer_list<double> __wl)
5619 template<
typename _Func>
5620 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5622 : _M_param(__nw, __xmin, __xmax, __fw)
5626 discrete_distribution(
const param_type& __p)
5643 return _M_param._M_prob.
empty()
5652 {
return _M_param; }
5675 return _M_param._M_prob.
empty()
5682 template<
typename _UniformRandomNumberGenerator>
5685 {
return this->
operator()(__urng, _M_param); }
5687 template<
typename _UniformRandomNumberGenerator>
5690 const param_type& __p);
5697 { this->__generate(__f, __t,
__urng, _M_param); }
5699 template<
typename _ForwardIterator,
5700 typename _UniformRandomNumberGenerator>
5702 __generate(_ForwardIterator __f, _ForwardIterator __t,
5703 _UniformRandomNumberGenerator& __urng,
5704 const param_type& __p)
5705 { this->__generate_impl(__f, __t, __urng, __p); }
5707 template<
typename _UniformRandomNumberGenerator>
5710 _UniformRandomNumberGenerator& __urng,
5711 const param_type& __p)
5712 { this->__generate_impl(__f, __t, __urng, __p); }
5721 {
return __d1._M_param ==
__d2._M_param; }
5733 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5749 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5765#if __cpp_impl_three_way_comparison < 201907L
5770 template<
typename _IntType>
5793 template<
typename _RealType =
double>
5797 "result_type must be a floating point type");
5810 : _M_int(), _M_den(), _M_cp()
5813 template<
typename _InputIteratorB,
typename _InputIteratorW>
5818 template<
typename _Func>
5821 template<
typename _Func>
5835 __tmp[1] = _RealType(1);
5850#if __cpp_impl_three_way_comparison < 201907L
5869 template<
typename _InputIteratorB,
typename _InputIteratorW>
5876 template<
typename _Func>
5877 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5879 : _M_param(__bl, __fw)
5882 template<
typename _Func>
5883 piecewise_constant_distribution(
size_t __nw,
5884 _RealType __xmin, _RealType __xmax,
5886 : _M_param(__nw, __xmin, __xmax, __fw)
5890 piecewise_constant_distribution(
const param_type& __p)
5907 if (_M_param._M_int.
empty())
5910 __tmp[1] = _RealType(1);
5914 return _M_param._M_int;
5923 return _M_param._M_den.
empty()
5932 {
return _M_param; }
5948 return _M_param._M_int.
empty()
5958 return _M_param._M_int.
empty()
5965 template<
typename _UniformRandomNumberGenerator>
5968 {
return this->
operator()(__urng, _M_param); }
5970 template<
typename _UniformRandomNumberGenerator>
5973 const param_type& __p);
5980 { this->__generate(__f, __t,
__urng, _M_param); }
5982 template<
typename _ForwardIterator,
5983 typename _UniformRandomNumberGenerator>
5985 __generate(_ForwardIterator __f, _ForwardIterator __t,
5986 _UniformRandomNumberGenerator& __urng,
5987 const param_type& __p)
5988 { this->__generate_impl(__f, __t, __urng, __p); }
5990 template<
typename _UniformRandomNumberGenerator>
5993 _UniformRandomNumberGenerator& __urng,
5994 const param_type& __p)
5995 { this->__generate_impl(__f, __t, __urng, __p); }
6004 {
return __d1._M_param ==
__d2._M_param; }
6017 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6033 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6049#if __cpp_impl_three_way_comparison < 201907L
6054 template<
typename _RealType>
6073 template<
typename _RealType =
double>
6077 "result_type must be a floating point type");
6090 : _M_int(), _M_den(), _M_cp(), _M_m()
6093 template<
typename _InputIteratorB,
typename _InputIteratorW>
6098 template<
typename _Func>
6101 template<
typename _Func>
6115 __tmp[1] = _RealType(1);
6130#if __cpp_impl_three_way_comparison < 201907L
6150 template<
typename _InputIteratorB,
typename _InputIteratorW>
6157 template<
typename _Func>
6158 piecewise_linear_distribution(initializer_list<_RealType> __bl,
6160 : _M_param(__bl, __fw)
6163 template<
typename _Func>
6164 piecewise_linear_distribution(
size_t __nw,
6165 _RealType __xmin, _RealType __xmax,
6167 : _M_param(__nw, __xmin, __xmax, __fw)
6171 piecewise_linear_distribution(
const param_type& __p)
6188 if (_M_param._M_int.
empty())
6191 __tmp[1] = _RealType(1);
6195 return _M_param._M_int;
6205 return _M_param._M_den.
empty()
6214 {
return _M_param; }
6230 return _M_param._M_int.
empty()
6240 return _M_param._M_int.
empty()
6247 template<
typename _UniformRandomNumberGenerator>
6250 {
return this->
operator()(__urng, _M_param); }
6252 template<
typename _UniformRandomNumberGenerator>
6255 const param_type& __p);
6262 { this->__generate(__f, __t,
__urng, _M_param); }
6264 template<
typename _ForwardIterator,
6265 typename _UniformRandomNumberGenerator>
6267 __generate(_ForwardIterator __f, _ForwardIterator __t,
6268 _UniformRandomNumberGenerator& __urng,
6269 const param_type& __p)
6270 { this->__generate_impl(__f, __t, __urng, __p); }
6272 template<
typename _UniformRandomNumberGenerator>
6275 _UniformRandomNumberGenerator& __urng,
6276 const param_type& __p)
6277 { this->__generate_impl(__f, __t, __urng, __p); }
6286 {
return __d1._M_param ==
__d2._M_param; }
6299 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6315 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6331#if __cpp_impl_three_way_comparison < 201907L
6336 template<
typename _RealType>
6371 template<
typename _IntType,
typename = _Require<is_
integral<_IntType>>>
6374 template<
typename _InputIterator>
6378 template<
typename _RandomAccessIterator>
6383 size_t size()
const noexcept
6384 {
return _M_v.
size(); }
6386 template<
typename _OutputIterator>
6388 param(_OutputIterator __dest)
const
6389 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
6403_GLIBCXX_END_NAMESPACE_VERSION
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr duration< __common_rep_t< _Rep1, __disable_if_is_duration< _Rep2 > >, _Period > operator%(const duration< _Rep1, _Period > &__d, const _Rep2 &__s)
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
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.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
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
ISO C++ entities toplevel namespace is std.
constexpr _Tp __lg(_Tp __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.
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const 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.
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.
linear_congruential_engine(result_type __s)
Constructs a linear_congruential_engine random number generator engine with seed __s....
linear_congruential_engine(_Sseq &__q)
Constructs a linear_congruential_engine random number generator engine seeded from the seed sequence ...
static constexpr result_type min()
Gets the smallest possible value in the output range.
static constexpr result_type multiplier
void discard(unsigned long long __z)
Discard a sequence of random numbers.
linear_congruential_engine()
Constructs a linear_congruential_engine random number generator engine with seed 1.
void seed(result_type __s=default_seed)
Reseeds the linear_congruential_engine random number generator engine sequence to the seed __s.
static constexpr result_type increment
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the linear_congruential_engine random number generator engine sequence using values from the ...
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.
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.
result_type operator()()
Gets the next random number in the sequence.
static constexpr result_type max()
Gets the largest possible value in the output range.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
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::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 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 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 ...
static constexpr result_type min()
Gets the smallest possible value in the output range.
The Marsaglia-Zaman generator.
void seed(result_type __sd=0u)
Seeds the initial state of the random number generator.
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...
subtract_with_carry_engine(result_type __sd)
Constructs an explicitly seeded subtract_with_carry_engine random number generator.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
result_type operator()()
Gets the next random number in the sequence.
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Seeds the initial state of the % subtract_with_carry_engine random number generator.
static constexpr result_type min()
Gets the inclusive minimum value of the range of random integers returned by this generator.
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...
subtract_with_carry_engine(_Sseq &__q)
Constructs a subtract_with_carry_engine random number engine seeded from the seed sequence __q.
static constexpr result_type max()
Gets the inclusive maximum value of the range of random integers returned by this generator.
void seed(result_type __s)
Reseeds the discard_block_engine object with the default seed for the underlying base class generator...
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...
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...
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the discard_block_engine object with the given seed sequence.
discard_block_engine(const _RandomNumberEngine &__rng)
Copy constructs a discard_block_engine engine.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
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 ...
static constexpr result_type max()
Gets the maximum value in the generated random number range.
discard_block_engine()
Constructs a default discard_block_engine engine.
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.
discard_block_engine(_Sseq &__q)
Generator construct a discard_block_engine engine.
result_type operator()()
Gets the next value in the generated random number sequence.
discard_block_engine(result_type __s)
Seed constructs a discard_block_engine engine.
_RandomNumberEngine::result_type result_type
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the independent_bits_engine object with the given seed sequence.
independent_bits_engine(_Sseq &__q)
Generator construct a independent_bits_engine engine.
independent_bits_engine(const _RandomNumberEngine &__rng)
Copy constructs a independent_bits_engine engine.
static constexpr result_type min()
Gets the minimum value in the generated random number range.
result_type operator()()
Gets the next value in the generated random number sequence.
void seed()
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
void discard(unsigned long long __z)
Discard a sequence of random numbers.
void seed(result_type __s)
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
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 ...
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.
static constexpr result_type max()
Gets the maximum value in the generated random number range.
independent_bits_engine()
Constructs a default independent_bits_engine engine.
const _RandomNumberEngine & base() const noexcept
Gets a const reference to the underlying generator engine object.
independent_bits_engine(result_type __s)
Seed constructs a independent_bits_engine engine.
independent_bits_engine(_RandomNumberEngine &&__rng)
Move constructs a independent_bits_engine engine.
Produces random numbers by reordering random numbers from some base engine.
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the shuffle_order_engine object with the given seed sequence.
static constexpr result_type min()
shuffle_order_engine()
Constructs a default shuffle_order_engine engine.
static constexpr result_type max()
shuffle_order_engine(const _RandomNumberEngine &__rng)
Copy constructs a shuffle_order_engine engine.
shuffle_order_engine(_Sseq &__q)
Generator construct a shuffle_order_engine engine.
const _RandomNumberEngine & base() const noexcept
shuffle_order_engine(_RandomNumberEngine &&__rng)
Move constructs a shuffle_order_engine engine.
void seed()
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
shuffle_order_engine(result_type __s)
Seed constructs a shuffle_order_engine engine.
_RandomNumberEngine::result_type result_type
friend bool operator==(const shuffle_order_engine &__lhs, const shuffle_order_engine &__rhs)
void discard(unsigned long long __z)
void seed(result_type __s)
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
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...
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 ...
Uniform continuous distribution for random numbers.
param_type param() const
Returns the parameter set of the distribution.
void reset()
Resets the distribution state.
uniform_real_distribution(_RealType __a, _RealType __b=_RealType(1))
Constructs a uniform_real_distribution object.
result_type min() const
Returns the inclusive lower bound of the distribution range.
friend bool operator==(const uniform_real_distribution &__d1, const uniform_real_distribution &__d2)
Return true if two uniform real distributions have the same parameters.
result_type max() const
Returns the inclusive upper bound of the distribution range.
uniform_real_distribution()
Constructs a uniform_real_distribution object.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void param(const param_type &__param)
Sets the parameter set of the distribution.
A normal continuous distribution for random numbers.
_RealType stddev() const
Returns the standard deviation of the distribution.
param_type param() const
Returns the parameter set of the distribution.
void reset()
Resets the distribution state.
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.
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.
_RealType mean() const
Returns the mean 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.
normal_distribution(result_type __mean, result_type __stddev=result_type(1))
result_type max() const
Returns the least upper bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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...
A lognormal_distribution random number distribution.
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...
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::lognormal_distribution< _RealType1 > &__x)
Extracts a lognormal_distribution random number distribution __x from the input stream __is.
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::lognormal_distribution< _RealType1 > &__x)
Inserts a lognormal_distribution random number distribution __x into the output stream __os.
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.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
A gamma continuous distribution for random numbers.
gamma_distribution(_RealType __alpha_val, _RealType __beta_val=_RealType(1))
Constructs a gamma distribution with parameters and .
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.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type min() const
Returns the greatest lower bound value of the distribution.
_RealType alpha() const
Returns the of the distribution.
gamma_distribution()
Constructs a gamma distribution with parameters 1 and 1.
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...
void param(const param_type &__param)
Sets the parameter set of the distribution.
_RealType beta() const
Returns the of the distribution.
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.
param_type param() const
Returns the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
A chi_squared_distribution random number distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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...
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::chi_squared_distribution< _RealType1 > &__x)
Inserts a chi_squared_distribution random number distribution __x into the output stream __os.
void reset()
Resets the distribution state.
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::chi_squared_distribution< _RealType1 > &__x)
Extracts a chi_squared_distribution random number distribution __x from the input stream __is.
A cauchy_distribution random number distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
friend bool operator==(const cauchy_distribution &__d1, const cauchy_distribution &__d2)
Return true if two Cauchy distributions have the same parameters.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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.
A fisher_f_distribution random number 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.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
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...
result_type min() const
Returns the greatest lower bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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 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.
A student_t_distribution random number 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.
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
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 operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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 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.
param_type param() const
Returns the parameter set of the distribution.
A Bernoulli random number distribution.
void reset()
Resets the distribution state.
result_type max() const
Returns the least upper bound value of the distribution.
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.
bernoulli_distribution()
Constructs a Bernoulli distribution with likelihood 0.5.
bernoulli_distribution(double __p)
Constructs a Bernoulli distribution with likelihood p.
result_type min() const
Returns the greatest lower bound value of the distribution.
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 operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
A discrete binomial random number distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
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.
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...
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::binomial_distribution< _IntType1 > &__x)
Extracts a binomial_distribution random number distribution __x from the input stream __is.
_IntType t() const
Returns the distribution t parameter.
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.
void reset()
Resets the distribution state.
double p() const
Returns the distribution p parameter.
A discrete geometric random number distribution.
double p() const
Returns the distribution parameter p.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type max() const
Returns the least upper bound value 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.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void reset()
Resets the distribution state.
result_type min() const
Returns the greatest lower bound value of the distribution.
A negative_binomial_distribution random number 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.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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 min() const
Returns the greatest lower bound value of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
double p() const
Return the parameter of the distribution.
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...
param_type param() const
Returns the parameter set of the distribution.
_IntType k() const
Return the parameter of the distribution.
void reset()
Resets the distribution state.
A discrete Poisson random number distribution.
void reset()
Resets the distribution state.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
double mean() const
Returns the distribution parameter mean.
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...
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 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.
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::poisson_distribution< _IntType1 > &__x)
Extracts a poisson_distribution random number distribution __x from the input stream __is.
result_type min() const
Returns the greatest lower bound value of the distribution.
An exponential continuous distribution for random numbers.
_RealType lambda() const
Returns the inverse scale parameter of the distribution.
exponential_distribution()
Constructs an exponential distribution with inverse scale parameter 1.0.
exponential_distribution(_RealType __lambda)
Constructs an exponential distribution with inverse scale parameter .
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void reset()
Resets the distribution state.
result_type min() const
Returns the greatest lower bound value 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.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend bool operator==(const exponential_distribution &__d1, const exponential_distribution &__d2)
Return true if two exponential distributions have the same parameters.
A weibull_distribution random number distribution.
param_type param() const
Returns 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.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend bool operator==(const weibull_distribution &__d1, const weibull_distribution &__d2)
Return true if two Weibull distributions have the same parameters.
void param(const param_type &__param)
Sets the parameter set of the distribution.
_RealType b() const
Return the parameter of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
_RealType a() const
Return the parameter of the distribution.
A extreme_value_distribution random number distribution.
void reset()
Resets the distribution state.
_RealType b() const
Return the parameter of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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.
result_type max() const
Returns the least upper bound value of the distribution.
_RealType a() const
Return the parameter of the distribution.
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.
A discrete_distribution random number distribution.
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 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::discrete_distribution< _IntType1 > &__x)
Extracts a discrete_distribution random number distribution __x from the input stream __is.
result_type max() const
Returns the least upper bound value of the distribution.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const discrete_distribution &__d1, const discrete_distribution &__d2)
Return true if two discrete distributions have the same parameters.
std::vector< double > probabilities() const
Returns the probabilities of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void param(const param_type &__param)
Sets the parameter set of the distribution.
A piecewise_constant_distribution random number distribution.
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.
result_type min() const
Returns the greatest lower bound value of the distribution.
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::piecewise_constant_distribution< _RealType1 > &__x)
Inserts a piecewise_constant_distribution random number distribution __x into the output stream __os.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const piecewise_constant_distribution &__d1, const piecewise_constant_distribution &__d2)
Return true if two piecewise constant distributions have the same parameters.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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.
std::vector< _RealType > intervals() const
Returns a vector of the intervals.
A piecewise_linear_distribution random number distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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_linear_distribution< _RealType1 > &__x)
Extracts a piecewise_linear_distribution random number distribution __x from the input stream __is.
std::vector< _RealType > intervals() const
Return the intervals of the distribution.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const piecewise_linear_distribution &__d1, const piecewise_linear_distribution &__d2)
Return true if two piecewise linear distributions have the same parameters.
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.
std::vector< double > densities() const
Return a vector of the probability densities 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.
The seed_seq class generates sequences of seeds for random number generators.
uint_least32_t result_type
One of the math functors.
constexpr iterator end() noexcept
constexpr iterator begin() noexcept
constexpr reference front() noexcept
constexpr bool empty() const noexcept
constexpr size_type size() const noexcept
constexpr reference back() noexcept