37 namespace std _GLIBCXX_VISIBILITY(default)
39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
58 template<
typename _RealType,
size_t __bits,
59 typename _UniformRandomNumberGenerator>
67 template<
typename _UIntType,
size_t __w,
68 bool = __w < static_cast<size_t>
71 {
static constexpr _UIntType __value = 0; };
73 template<
typename _UIntType,
size_t __w>
74 struct _Shift<_UIntType, __w, true>
75 {
static constexpr _UIntType __value = _UIntType(1) << __w; };
78 int __which = ((__s <= __CHAR_BIT__ *
sizeof (int))
79 + (__s <= __CHAR_BIT__ *
sizeof (long))
80 + (__s <= __CHAR_BIT__ *
sizeof (
long long))
83 struct _Select_uint_least_t
85 static_assert(__which < 0,
86 "sorry, would be too much trouble for a slow result");
90 struct _Select_uint_least_t<__s, 4>
91 {
using type =
unsigned int; };
94 struct _Select_uint_least_t<__s, 3>
95 {
using type =
unsigned long; };
98 struct _Select_uint_least_t<__s, 2>
99 {
using type =
unsigned long long; };
101 #if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
103 struct _Select_uint_least_t<__s, 1>
104 { __extension__
using type =
unsigned __int128; };
108 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
109 bool __big_enough = (!(__m & (__m - 1))
110 || (_Tp(-1) - __c) / __a >= __m - 1),
111 bool __schrage_ok = __m % __a < __m / __a>
118 =
typename _Select_uint_least_t<
std::__lg(__a)
120 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>
152 if _GLIBCXX17_CONSTEXPR (__a == 0)
157 constexpr _Tp __a1 = __a ? __a : 1;
158 return _Mod<_Tp, __m, __a1, __c>::__calc(__x);
166 template<
typename _Engine,
typename _DInputType>
170 "template argument must be a floating point type");
173 _Adaptor(_Engine& __g)
178 {
return _DInputType(0); }
182 {
return _DInputType(1); }
206 template<
typename _Sseq>
207 using __seed_seq_generate_t = decltype(
208 std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
209 std::declval<uint_least32_t*>()));
211 template<
typename _Sseq,
typename _Engine,
typename _Res,
212 typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
213 using _If_seed_seq_for = _Require<
214 __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
215 is_unsigned<typename _Sseq::result_type>,
216 __not_<is_convertible<_Sseq, _Res>>
263 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
267 "result_type must be an unsigned integral type");
268 static_assert(__m == 0u || (__a < __m && __c < __m),
269 "template argument substituting __m out of bounds");
271 template<
typename _Sseq>
312 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
333 template<
typename _Sseq>
345 {
return __c == 0u ? 1u : 0u; }
360 for (; __z != 0ULL; --__z)
370 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
388 {
return __lhs._M_x == __rhs._M_x; }
398 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
399 _UIntType1 __m1,
typename _CharT,
typename _Traits>
403 __a1, __c1, __m1>& __lcr);
418 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
419 _UIntType1 __m1,
typename _CharT,
typename _Traits>
429 #if __cpp_impl_three_way_comparison < 201907L
441 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
447 {
return !(__lhs == __rhs); }
481 template<
typename _UIntType,
size_t __w,
482 size_t __n,
size_t __m,
size_t __r,
483 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
484 _UIntType __b,
size_t __t,
485 _UIntType __c,
size_t __l, _UIntType __f>
489 "result_type must be an unsigned integral type");
490 static_assert(1u <= __m && __m <= __n,
491 "template argument substituting __m out of bounds");
492 static_assert(__r <= __w,
"template argument substituting "
494 static_assert(__u <= __w,
"template argument substituting "
496 static_assert(__s <= __w,
"template argument substituting "
498 static_assert(__t <= __w,
"template argument substituting "
500 static_assert(__l <= __w,
"template argument substituting "
503 "template argument substituting __w out of bound");
504 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
505 "template argument substituting __a out of bound");
506 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
507 "template argument substituting __b out of bound");
508 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
509 "template argument substituting __c out of bound");
510 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
511 "template argument substituting __d out of bound");
512 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
513 "template argument substituting __f out of bound");
515 template<
typename _Sseq>
525 static constexpr
size_t word_size = __w;
526 static constexpr
size_t state_size = __n;
527 static constexpr
size_t shift_size = __m;
528 static constexpr
size_t mask_bits = __r;
530 static constexpr
size_t tempering_u = __u;
532 static constexpr
size_t tempering_s = __s;
534 static constexpr
size_t tempering_t = __t;
536 static constexpr
size_t tempering_l = __l;
537 static constexpr
result_type initialization_multiplier = __f;
554 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
562 template<
typename _Sseq>
578 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
584 discard(
unsigned long long __z);
604 {
return (
std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
605 && __lhs._M_p == __rhs._M_p); }
619 template<
typename _UIntType1,
620 size_t __w1,
size_t __n1,
621 size_t __m1,
size_t __r1,
622 _UIntType1 __a1,
size_t __u1,
623 _UIntType1 __d1,
size_t __s1,
624 _UIntType1 __b1,
size_t __t1,
625 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
626 typename _CharT,
typename _Traits>
630 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
645 template<
typename _UIntType1,
646 size_t __w1,
size_t __n1,
647 size_t __m1,
size_t __r1,
648 _UIntType1 __a1,
size_t __u1,
649 _UIntType1 __d1,
size_t __s1,
650 _UIntType1 __b1,
size_t __t1,
651 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
652 typename _CharT,
typename _Traits>
656 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
662 _UIntType _M_x[state_size];
666 #if __cpp_impl_three_way_comparison < 201907L
679 template<
typename _UIntType,
size_t __w,
680 size_t __n,
size_t __m,
size_t __r,
681 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
682 _UIntType __b,
size_t __t,
683 _UIntType __c,
size_t __l, _UIntType __f>
686 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
688 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
689 {
return !(__lhs == __rhs); }
710 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
714 "result_type must be an unsigned integral type");
715 static_assert(0u < __s && __s < __r,
718 "template argument substituting __w out of bounds");
720 template<
typename _Sseq>
730 static constexpr
size_t word_size = __w;
731 static constexpr
size_t short_lag = __s;
732 static constexpr
size_t long_lag = __r;
733 static constexpr uint_least32_t default_seed = 19780503u;
752 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
776 template<
typename _Sseq>
794 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
802 for (; __z != 0ULL; --__z)
827 {
return (
std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
828 && __lhs._M_carry == __rhs._M_carry
829 && __lhs._M_p == __rhs._M_p); }
843 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
844 typename _CharT,
typename _Traits>
862 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
863 typename _CharT,
typename _Traits>
871 _UIntType _M_x[long_lag];
876 #if __cpp_impl_three_way_comparison < 201907L
889 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
895 {
return !(__lhs == __rhs); }
907 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
910 static_assert(1 <= __r && __r <= __p,
911 "template argument substituting __r out of bounds");
915 typedef typename _RandomNumberEngine::result_type
result_type;
917 template<
typename _Sseq>
923 static constexpr
size_t block_size = __p;
924 static constexpr
size_t used_block = __r;
932 : _M_b(), _M_n(0) { }
942 : _M_b(__rng), _M_n(0) { }
952 : _M_b(
std::
move(__rng)), _M_n(0) { }
962 : _M_b(__s), _M_n(0) { }
969 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1002 template<
typename _Sseq>
1014 const _RandomNumberEngine&
1023 {
return _RandomNumberEngine::min(); }
1030 {
return _RandomNumberEngine::max(); }
1038 for (; __z != 0ULL; --__z)
1062 {
return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1075 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1076 typename _CharT,
typename _Traits>
1093 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1094 typename _CharT,
typename _Traits>
1101 _RandomNumberEngine _M_b;
1105 #if __cpp_impl_three_way_comparison < 201907L
1117 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1123 {
return !(__lhs == __rhs); }
1133 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1137 "result_type must be an unsigned integral type");
1139 "template argument substituting __w out of bounds");
1141 template<
typename _Sseq>
1193 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1220 template<
typename _Sseq>
1229 const _RandomNumberEngine&
1245 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1253 for (; __z != 0ULL; --__z)
1278 {
return __lhs._M_b == __rhs._M_b; }
1292 template<
typename _CharT,
typename _Traits>
1296 __w, _UIntType>& __x)
1303 _RandomNumberEngine _M_b;
1306 #if __cpp_impl_three_way_comparison < 201907L
1319 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1325 {
return !(__lhs == __rhs); }
1338 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1339 typename _CharT,
typename _Traits>
1343 __w, _UIntType>& __x)
1360 template<
typename _RandomNumberEngine,
size_t __k>
1363 static_assert(1u <= __k,
"template argument substituting "
1364 "__k out of bound");
1368 typedef typename _RandomNumberEngine::result_type
result_type;
1370 template<
typename _Sseq>
1375 static constexpr
size_t table_size = __k;
1384 { _M_initialize(); }
1395 { _M_initialize(); }
1406 { _M_initialize(); }
1417 { _M_initialize(); }
1424 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1428 { _M_initialize(); }
1457 template<
typename _Sseq>
1468 const _RandomNumberEngine&
1477 {
return _RandomNumberEngine::min(); }
1484 {
return _RandomNumberEngine::max(); }
1492 for (; __z != 0ULL; --__z)
1516 {
return (__lhs._M_b == __rhs._M_b
1517 &&
std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1518 && __lhs._M_y == __rhs._M_y); }
1531 template<
typename _RandomNumberEngine1,
size_t __k1,
1532 typename _CharT,
typename _Traits>
1549 template<
typename _RandomNumberEngine1,
size_t __k1,
1550 typename _CharT,
typename _Traits>
1556 void _M_initialize()
1558 for (
size_t __i = 0; __i < __k; ++__i)
1563 _RandomNumberEngine _M_b;
1568 #if __cpp_impl_three_way_comparison < 201907L
1580 template<
typename _RandomNumberEngine,
size_t __k>
1586 {
return !(__lhs == __rhs); }
1592 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1623 0xb5026f5aa96619e9ULL, 29,
1624 0x5555555555555555ULL, 17,
1625 0x71d67fffeda60000ULL, 37,
1626 0xfff7eee000000000ULL, 43,
1675 entropy() const noexcept
1676 {
return this->_M_getentropy(); }
1680 {
return this->_M_getval(); }
1683 random_device(
const random_device&) =
delete;
1684 void operator=(
const random_device&) =
delete;
1694 double _M_getentropy() const noexcept;
1696 void _M_init(const
char*,
size_t);
1726 #if __cpp_impl_three_way_comparison < 201907L
1731 template<
typename _IntType>
1735 {
return !(__d1 == __d2); }
1748 template<
typename _IntType,
typename _CharT,
typename _Traits>
1762 template<
typename _IntType,
typename _CharT,
typename _Traits>
1778 template<
typename _RealType =
double>
1782 "result_type must be a floating point type");
1796 param_type(_RealType __a, _RealType __b = _RealType(1))
1797 : _M_a(__a), _M_b(__b)
1799 __glibcxx_assert(_M_a <= _M_b);
1812 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1814 #if __cpp_impl_three_way_comparison < 201907L
1817 {
return !(__p1 == __p2); }
1841 : _M_param(__a, __b)
1859 {
return _M_param.a(); }
1863 {
return _M_param.b(); }
1870 {
return _M_param; }
1878 { _M_param = __param; }
1885 {
return this->a(); }
1892 {
return this->b(); }
1897 template<
typename _UniformRandomNumberGenerator>
1900 {
return this->
operator()(__urng, _M_param); }
1902 template<
typename _UniformRandomNumberGenerator>
1904 operator()(_UniformRandomNumberGenerator& __urng,
1905 const param_type& __p)
1907 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1909 return (__aurng() * (__p.b() - __p.a())) + __p.a();
1912 template<
typename _ForwardIterator,
1913 typename _UniformRandomNumberGenerator>
1915 __generate(_ForwardIterator __f, _ForwardIterator __t,
1916 _UniformRandomNumberGenerator& __urng)
1917 { this->__generate(__f, __t, __urng, _M_param); }
1919 template<
typename _ForwardIterator,
1920 typename _UniformRandomNumberGenerator>
1922 __generate(_ForwardIterator __f, _ForwardIterator __t,
1923 _UniformRandomNumberGenerator& __urng,
1924 const param_type& __p)
1925 { this->__generate_impl(__f, __t, __urng, __p); }
1927 template<
typename _UniformRandomNumberGenerator>
1930 _UniformRandomNumberGenerator& __urng,
1931 const param_type& __p)
1932 { this->__generate_impl(__f, __t, __urng, __p); }
1941 {
return __d1._M_param == __d2._M_param; }
1944 template<
typename _ForwardIterator,
1945 typename _UniformRandomNumberGenerator>
1947 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1948 _UniformRandomNumberGenerator& __urng,
1949 const param_type& __p);
1951 param_type _M_param;
1954 #if __cpp_impl_three_way_comparison < 201907L
1959 template<
typename _IntType>
1963 {
return !(__d1 == __d2); }
1976 template<
typename _RealType,
typename _CharT,
typename _Traits>
1990 template<
typename _RealType,
typename _CharT,
typename _Traits>
2015 template<
typename _RealType =
double>
2019 "result_type must be a floating point type");
2033 param_type(_RealType __mean, _RealType __stddev = _RealType(1))
2034 : _M_mean(__mean), _M_stddev(__stddev)
2036 __glibcxx_assert(_M_stddev > _RealType(0));
2045 {
return _M_stddev; }
2049 {
return (__p1._M_mean == __p2._M_mean
2050 && __p1._M_stddev == __p2._M_stddev); }
2052 #if __cpp_impl_three_way_comparison < 201907L
2055 {
return !(__p1 == __p2); }
2060 _RealType _M_stddev;
2073 : _M_param(__mean, __stddev)
2086 { _M_saved_available =
false; }
2093 {
return _M_param.mean(); }
2100 {
return _M_param.stddev(); }
2107 {
return _M_param; }
2115 { _M_param = __param; }
2134 template<
typename _UniformRandomNumberGenerator>
2137 {
return this->
operator()(__urng, _M_param); }
2139 template<
typename _UniformRandomNumberGenerator>
2141 operator()(_UniformRandomNumberGenerator& __urng,
2142 const param_type& __p);
2144 template<
typename _ForwardIterator,
2145 typename _UniformRandomNumberGenerator>
2147 __generate(_ForwardIterator __f, _ForwardIterator __t,
2148 _UniformRandomNumberGenerator& __urng)
2149 { this->__generate(__f, __t, __urng, _M_param); }
2151 template<
typename _ForwardIterator,
2152 typename _UniformRandomNumberGenerator>
2154 __generate(_ForwardIterator __f, _ForwardIterator __t,
2155 _UniformRandomNumberGenerator& __urng,
2156 const param_type& __p)
2157 { this->__generate_impl(__f, __t, __urng, __p); }
2159 template<
typename _UniformRandomNumberGenerator>
2162 _UniformRandomNumberGenerator& __urng,
2163 const param_type& __p)
2164 { this->__generate_impl(__f, __t, __urng, __p); }
2171 template<
typename _RealType1>
2186 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2201 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2207 template<
typename _ForwardIterator,
2208 typename _UniformRandomNumberGenerator>
2210 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2211 _UniformRandomNumberGenerator& __urng,
2212 const param_type& __p);
2214 param_type _M_param;
2216 bool _M_saved_available =
false;
2219 #if __cpp_impl_three_way_comparison < 201907L
2223 template<
typename _RealType>
2227 {
return !(__d1 == __d2); }
2242 template<
typename _RealType =
double>
2246 "result_type must be a floating point type");
2260 param_type(_RealType __m, _RealType __s = _RealType(1))
2261 : _M_m(__m), _M_s(__s)
2274 {
return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2276 #if __cpp_impl_three_way_comparison < 201907L
2279 {
return !(__p1 == __p2); }
2291 : _M_param(__m, __s), _M_nd()
2295 lognormal_distribution(
const param_type& __p)
2296 : _M_param(__p), _M_nd()
2311 {
return _M_param.m(); }
2315 {
return _M_param.s(); }
2322 {
return _M_param; }
2330 { _M_param = __param; }
2349 template<
typename _UniformRandomNumberGenerator>
2352 {
return this->
operator()(__urng, _M_param); }
2354 template<
typename _UniformRandomNumberGenerator>
2356 operator()(_UniformRandomNumberGenerator& __urng,
2357 const param_type& __p)
2358 {
return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2360 template<
typename _ForwardIterator,
2361 typename _UniformRandomNumberGenerator>
2363 __generate(_ForwardIterator __f, _ForwardIterator __t,
2364 _UniformRandomNumberGenerator& __urng)
2365 { this->__generate(__f, __t, __urng, _M_param); }
2367 template<
typename _ForwardIterator,
2368 typename _UniformRandomNumberGenerator>
2370 __generate(_ForwardIterator __f, _ForwardIterator __t,
2371 _UniformRandomNumberGenerator& __urng,
2372 const param_type& __p)
2373 { this->__generate_impl(__f, __t, __urng, __p); }
2375 template<
typename _UniformRandomNumberGenerator>
2378 _UniformRandomNumberGenerator& __urng,
2379 const param_type& __p)
2380 { this->__generate_impl(__f, __t, __urng, __p); }
2390 {
return (__d1._M_param == __d2._M_param
2391 && __d1._M_nd == __d2._M_nd); }
2403 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2418 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2424 template<
typename _ForwardIterator,
2425 typename _UniformRandomNumberGenerator>
2427 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2428 _UniformRandomNumberGenerator& __urng,
2429 const param_type& __p);
2431 param_type _M_param;
2436 #if __cpp_impl_three_way_comparison < 201907L
2440 template<
typename _RealType>
2444 {
return !(__d1 == __d2); }
2467 template<
typename _RealType =
double>
2471 "result_type must be a floating point type");
2486 param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1))
2487 : _M_alpha(__alpha_val), _M_beta(__beta_val)
2489 __glibcxx_assert(_M_alpha > _RealType(0));
2495 {
return _M_alpha; }
2503 {
return (__p1._M_alpha == __p2._M_alpha
2504 && __p1._M_beta == __p2._M_beta); }
2506 #if __cpp_impl_three_way_comparison < 201907L
2509 {
return !(__p1 == __p2); }
2519 _RealType _M_malpha, _M_a2;
2534 _RealType __beta_val = _RealType(1))
2535 : _M_param(__alpha_val, __beta_val), _M_nd()
2540 : _M_param(__p), _M_nd()
2555 {
return _M_param.alpha(); }
2562 {
return _M_param.beta(); }
2569 {
return _M_param; }
2577 { _M_param = __param; }
2596 template<
typename _UniformRandomNumberGenerator>
2599 {
return this->
operator()(__urng, _M_param); }
2601 template<
typename _UniformRandomNumberGenerator>
2603 operator()(_UniformRandomNumberGenerator& __urng,
2604 const param_type& __p);
2606 template<
typename _ForwardIterator,
2607 typename _UniformRandomNumberGenerator>
2609 __generate(_ForwardIterator __f, _ForwardIterator __t,
2610 _UniformRandomNumberGenerator& __urng)
2611 { this->__generate(__f, __t, __urng, _M_param); }
2613 template<
typename _ForwardIterator,
2614 typename _UniformRandomNumberGenerator>
2616 __generate(_ForwardIterator __f, _ForwardIterator __t,
2617 _UniformRandomNumberGenerator& __urng,
2618 const param_type& __p)
2619 { this->__generate_impl(__f, __t, __urng, __p); }
2621 template<
typename _UniformRandomNumberGenerator>
2624 _UniformRandomNumberGenerator& __urng,
2625 const param_type& __p)
2626 { this->__generate_impl(__f, __t, __urng, __p); }
2636 {
return (__d1._M_param == __d2._M_param
2637 && __d1._M_nd == __d2._M_nd); }
2649 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2663 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2669 template<
typename _ForwardIterator,
2670 typename _UniformRandomNumberGenerator>
2672 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2673 _UniformRandomNumberGenerator& __urng,
2674 const param_type& __p);
2676 param_type _M_param;
2681 #if __cpp_impl_three_way_comparison < 201907L
2685 template<
typename _RealType>
2689 {
return !(__d1 == __d2); }
2709 template<
typename _RealType =
double>
2713 "result_type must be a floating point type");
2737 {
return __p1._M_n == __p2._M_n; }
2739 #if __cpp_impl_three_way_comparison < 201907L
2742 {
return !(__p1 == __p2); }
2753 : _M_param(__n), _M_gd(__n / 2)
2757 chi_squared_distribution(
const param_type& __p)
2758 : _M_param(__p), _M_gd(__p.n() / 2)
2773 {
return _M_param.n(); }
2780 {
return _M_param; }
2812 template<
typename _UniformRandomNumberGenerator>
2815 {
return 2 * _M_gd(__urng); }
2817 template<
typename _UniformRandomNumberGenerator>
2819 operator()(_UniformRandomNumberGenerator& __urng,
2820 const param_type& __p)
2824 return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2827 template<
typename _ForwardIterator,
2828 typename _UniformRandomNumberGenerator>
2830 __generate(_ForwardIterator __f, _ForwardIterator __t,
2831 _UniformRandomNumberGenerator& __urng)
2832 { this->__generate_impl(__f, __t, __urng); }
2834 template<
typename _ForwardIterator,
2835 typename _UniformRandomNumberGenerator>
2837 __generate(_ForwardIterator __f, _ForwardIterator __t,
2838 _UniformRandomNumberGenerator& __urng,
2839 const param_type& __p)
2842 this->__generate_impl(__f, __t, __urng, __p2); }
2844 template<
typename _UniformRandomNumberGenerator>
2847 _UniformRandomNumberGenerator& __urng)
2848 { this->__generate_impl(__f, __t, __urng); }
2850 template<
typename _UniformRandomNumberGenerator>
2853 _UniformRandomNumberGenerator& __urng,
2854 const param_type& __p)
2857 this->__generate_impl(__f, __t, __urng, __p2); }
2867 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2879 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2894 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2900 template<
typename _ForwardIterator,
2901 typename _UniformRandomNumberGenerator>
2903 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2904 _UniformRandomNumberGenerator& __urng);
2906 template<
typename _ForwardIterator,
2907 typename _UniformRandomNumberGenerator>
2909 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2910 _UniformRandomNumberGenerator& __urng,
2914 param_type _M_param;
2919 #if __cpp_impl_three_way_comparison < 201907L
2923 template<
typename _RealType>
2927 {
return !(__d1 == __d2); }
2939 template<
typename _RealType =
double>
2943 "result_type must be a floating point type");
2957 param_type(_RealType __a, _RealType __b = _RealType(1))
2958 : _M_a(__a), _M_b(__b)
2971 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
2973 #if __cpp_impl_three_way_comparison < 201907L
2976 {
return !(__p1 == __p2); }
2988 : _M_param(__a, __b)
2992 cauchy_distribution(
const param_type& __p)
3008 {
return _M_param.a(); }
3012 {
return _M_param.b(); }
3019 {
return _M_param; }
3027 { _M_param = __param; }
3046 template<
typename _UniformRandomNumberGenerator>
3049 {
return this->
operator()(__urng, _M_param); }
3051 template<
typename _UniformRandomNumberGenerator>
3053 operator()(_UniformRandomNumberGenerator& __urng,
3054 const param_type& __p);
3056 template<
typename _ForwardIterator,
3057 typename _UniformRandomNumberGenerator>
3059 __generate(_ForwardIterator __f, _ForwardIterator __t,
3060 _UniformRandomNumberGenerator& __urng)
3061 { this->__generate(__f, __t, __urng, _M_param); }
3063 template<
typename _ForwardIterator,
3064 typename _UniformRandomNumberGenerator>
3066 __generate(_ForwardIterator __f, _ForwardIterator __t,
3067 _UniformRandomNumberGenerator& __urng,
3068 const param_type& __p)
3069 { this->__generate_impl(__f, __t, __urng, __p); }
3071 template<
typename _UniformRandomNumberGenerator>
3074 _UniformRandomNumberGenerator& __urng,
3075 const param_type& __p)
3076 { this->__generate_impl(__f, __t, __urng, __p); }
3085 {
return __d1._M_param == __d2._M_param; }
3088 template<
typename _ForwardIterator,
3089 typename _UniformRandomNumberGenerator>
3091 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3092 _UniformRandomNumberGenerator& __urng,
3093 const param_type& __p);
3095 param_type _M_param;
3098 #if __cpp_impl_three_way_comparison < 201907L
3103 template<
typename _RealType>
3107 {
return !(__d1 == __d2); }
3120 template<
typename _RealType,
typename _CharT,
typename _Traits>
3135 template<
typename _RealType,
typename _CharT,
typename _Traits>
3154 template<
typename _RealType =
double>
3158 "result_type must be a floating point type");
3172 param_type(_RealType __m, _RealType __n = _RealType(1))
3173 : _M_m(__m), _M_n(__n)
3186 {
return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3188 #if __cpp_impl_three_way_comparison < 201907L
3191 {
return !(__p1 == __p2); }
3203 _RealType __n = _RealType(1))
3204 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3208 fisher_f_distribution(
const param_type& __p)
3209 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3227 {
return _M_param.m(); }
3231 {
return _M_param.n(); }
3238 {
return _M_param; }
3246 { _M_param = __param; }
3265 template<
typename _UniformRandomNumberGenerator>
3268 {
return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3270 template<
typename _UniformRandomNumberGenerator>
3272 operator()(_UniformRandomNumberGenerator& __urng,
3273 const param_type& __p)
3277 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3278 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3281 template<
typename _ForwardIterator,
3282 typename _UniformRandomNumberGenerator>
3284 __generate(_ForwardIterator __f, _ForwardIterator __t,
3285 _UniformRandomNumberGenerator& __urng)
3286 { this->__generate_impl(__f, __t, __urng); }
3288 template<
typename _ForwardIterator,
3289 typename _UniformRandomNumberGenerator>
3291 __generate(_ForwardIterator __f, _ForwardIterator __t,
3292 _UniformRandomNumberGenerator& __urng,
3293 const param_type& __p)
3294 { this->__generate_impl(__f, __t, __urng, __p); }
3296 template<
typename _UniformRandomNumberGenerator>
3299 _UniformRandomNumberGenerator& __urng)
3300 { this->__generate_impl(__f, __t, __urng); }
3302 template<
typename _UniformRandomNumberGenerator>
3305 _UniformRandomNumberGenerator& __urng,
3306 const param_type& __p)
3307 { this->__generate_impl(__f, __t, __urng, __p); }
3317 {
return (__d1._M_param == __d2._M_param
3318 && __d1._M_gd_x == __d2._M_gd_x
3319 && __d1._M_gd_y == __d2._M_gd_y); }
3331 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3346 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3352 template<
typename _ForwardIterator,
3353 typename _UniformRandomNumberGenerator>
3355 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3356 _UniformRandomNumberGenerator& __urng);
3358 template<
typename _ForwardIterator,
3359 typename _UniformRandomNumberGenerator>
3361 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3362 _UniformRandomNumberGenerator& __urng,
3363 const param_type& __p);
3365 param_type _M_param;
3370 #if __cpp_impl_three_way_comparison < 201907L
3374 template<
typename _RealType>
3378 {
return !(__d1 == __d2); }
3393 template<
typename _RealType =
double>
3397 "result_type must be a floating point type");
3421 {
return __p1._M_n == __p2._M_n; }
3423 #if __cpp_impl_three_way_comparison < 201907L
3426 {
return !(__p1 == __p2); }
3437 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3441 student_t_distribution(
const param_type& __p)
3442 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3460 {
return _M_param.n(); }
3467 {
return _M_param; }
3475 { _M_param = __param; }
3494 template<
typename _UniformRandomNumberGenerator>
3497 {
return _M_nd(__urng) *
std::sqrt(n() / _M_gd(__urng)); }
3499 template<
typename _UniformRandomNumberGenerator>
3501 operator()(_UniformRandomNumberGenerator& __urng,
3502 const param_type& __p)
3507 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3508 return _M_nd(__urng) *
std::sqrt(__p.n() / __g);
3511 template<
typename _ForwardIterator,
3512 typename _UniformRandomNumberGenerator>
3514 __generate(_ForwardIterator __f, _ForwardIterator __t,
3515 _UniformRandomNumberGenerator& __urng)
3516 { this->__generate_impl(__f, __t, __urng); }
3518 template<
typename _ForwardIterator,
3519 typename _UniformRandomNumberGenerator>
3521 __generate(_ForwardIterator __f, _ForwardIterator __t,
3522 _UniformRandomNumberGenerator& __urng,
3523 const param_type& __p)
3524 { this->__generate_impl(__f, __t, __urng, __p); }
3526 template<
typename _UniformRandomNumberGenerator>
3529 _UniformRandomNumberGenerator& __urng)
3530 { this->__generate_impl(__f, __t, __urng); }
3532 template<
typename _UniformRandomNumberGenerator>
3535 _UniformRandomNumberGenerator& __urng,
3536 const param_type& __p)
3537 { this->__generate_impl(__f, __t, __urng, __p); }
3547 {
return (__d1._M_param == __d2._M_param
3548 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3560 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3575 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3581 template<
typename _ForwardIterator,
3582 typename _UniformRandomNumberGenerator>
3584 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3585 _UniformRandomNumberGenerator& __urng);
3586 template<
typename _ForwardIterator,
3587 typename _UniformRandomNumberGenerator>
3589 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3590 _UniformRandomNumberGenerator& __urng,
3591 const param_type& __p);
3593 param_type _M_param;
3599 #if __cpp_impl_three_way_comparison < 201907L
3603 template<
typename _RealType>
3607 {
return !(__d1 == __d2); }
3644 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3653 {
return __p1._M_p == __p2._M_p; }
3655 #if __cpp_impl_three_way_comparison < 201907L
3658 {
return !(__p1 == __p2); }
3700 {
return _M_param.p(); }
3707 {
return _M_param; }
3715 { _M_param = __param; }
3734 template<
typename _UniformRandomNumberGenerator>
3737 {
return this->
operator()(__urng, _M_param); }
3739 template<
typename _UniformRandomNumberGenerator>
3741 operator()(_UniformRandomNumberGenerator& __urng,
3742 const param_type& __p)
3744 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3746 if ((__aurng() - __aurng.min())
3747 < __p.p() * (__aurng.max() - __aurng.min()))
3752 template<
typename _ForwardIterator,
3753 typename _UniformRandomNumberGenerator>
3755 __generate(_ForwardIterator __f, _ForwardIterator __t,
3756 _UniformRandomNumberGenerator& __urng)
3757 { this->__generate(__f, __t, __urng, _M_param); }
3759 template<
typename _ForwardIterator,
3760 typename _UniformRandomNumberGenerator>
3762 __generate(_ForwardIterator __f, _ForwardIterator __t,
3763 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3764 { this->__generate_impl(__f, __t, __urng, __p); }
3766 template<
typename _UniformRandomNumberGenerator>
3769 _UniformRandomNumberGenerator& __urng,
3770 const param_type& __p)
3771 { this->__generate_impl(__f, __t, __urng, __p); }
3780 {
return __d1._M_param == __d2._M_param; }
3783 template<
typename _ForwardIterator,
3784 typename _UniformRandomNumberGenerator>
3786 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3787 _UniformRandomNumberGenerator& __urng,
3788 const param_type& __p);
3790 param_type _M_param;
3793 #if __cpp_impl_three_way_comparison < 201907L
3801 {
return !(__d1 == __d2); }
3814 template<
typename _CharT,
typename _Traits>
3828 template<
typename _CharT,
typename _Traits>
3850 template<
typename _IntType =
int>
3854 "result_type must be an integral type");
3870 : _M_t(__t), _M_p(__p)
3872 __glibcxx_assert((_M_t >= _IntType(0))
3888 {
return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3890 #if __cpp_impl_three_way_comparison < 201907L
3893 {
return !(__p1 == __p2); }
3904 #if _GLIBCXX_USE_C99_MATH_TR1
3905 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
3906 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
3917 : _M_param(__t, __p), _M_nd()
3921 binomial_distribution(
const param_type& __p)
3922 : _M_param(__p), _M_nd()
3937 {
return _M_param.t(); }
3944 {
return _M_param.p(); }
3951 {
return _M_param; }
3959 { _M_param = __param; }
3973 {
return _M_param.t(); }
3978 template<
typename _UniformRandomNumberGenerator>
3981 {
return this->
operator()(__urng, _M_param); }
3983 template<
typename _UniformRandomNumberGenerator>
3985 operator()(_UniformRandomNumberGenerator& __urng,
3986 const param_type& __p);
3988 template<
typename _ForwardIterator,
3989 typename _UniformRandomNumberGenerator>
3991 __generate(_ForwardIterator __f, _ForwardIterator __t,
3992 _UniformRandomNumberGenerator& __urng)
3993 { this->__generate(__f, __t, __urng, _M_param); }
3995 template<
typename _ForwardIterator,
3996 typename _UniformRandomNumberGenerator>
3998 __generate(_ForwardIterator __f, _ForwardIterator __t,
3999 _UniformRandomNumberGenerator& __urng,
4000 const param_type& __p)
4001 { this->__generate_impl(__f, __t, __urng, __p); }
4003 template<
typename _UniformRandomNumberGenerator>
4006 _UniformRandomNumberGenerator& __urng,
4007 const param_type& __p)
4008 { this->__generate_impl(__f, __t, __urng, __p); }
4018 #ifdef _GLIBCXX_USE_C99_MATH_TR1
4019 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4021 {
return __d1._M_param == __d2._M_param; }
4034 template<
typename _IntType1,
4035 typename _CharT,
typename _Traits>
4050 template<
typename _IntType1,
4051 typename _CharT,
typename _Traits>
4057 template<
typename _ForwardIterator,
4058 typename _UniformRandomNumberGenerator>
4060 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4061 _UniformRandomNumberGenerator& __urng,
4062 const param_type& __p);
4064 template<
typename _UniformRandomNumberGenerator>
4066 _M_waiting(_UniformRandomNumberGenerator& __urng,
4067 _IntType __t,
double __q);
4069 param_type _M_param;
4075 #if __cpp_impl_three_way_comparison < 201907L
4079 template<
typename _IntType>
4083 {
return !(__d1 == __d2); }
4096 template<
typename _IntType =
int>
4100 "result_type must be an integral type");
4118 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4128 {
return __p1._M_p == __p2._M_p; }
4130 #if __cpp_impl_three_way_comparison < 201907L
4133 {
return !(__p1 == __p2); }
4139 { _M_log_1_p =
std::log(1.0 - _M_p); }
4156 geometric_distribution(
const param_type& __p)
4173 {
return _M_param.p(); }
4180 {
return _M_param; }
4188 { _M_param = __param; }
4207 template<
typename _UniformRandomNumberGenerator>
4210 {
return this->
operator()(__urng, _M_param); }
4212 template<
typename _UniformRandomNumberGenerator>
4214 operator()(_UniformRandomNumberGenerator& __urng,
4215 const param_type& __p);
4217 template<
typename _ForwardIterator,
4218 typename _UniformRandomNumberGenerator>
4220 __generate(_ForwardIterator __f, _ForwardIterator __t,
4221 _UniformRandomNumberGenerator& __urng)
4222 { this->__generate(__f, __t, __urng, _M_param); }
4224 template<
typename _ForwardIterator,
4225 typename _UniformRandomNumberGenerator>
4227 __generate(_ForwardIterator __f, _ForwardIterator __t,
4228 _UniformRandomNumberGenerator& __urng,
4229 const param_type& __p)
4230 { this->__generate_impl(__f, __t, __urng, __p); }
4232 template<
typename _UniformRandomNumberGenerator>
4235 _UniformRandomNumberGenerator& __urng,
4236 const param_type& __p)
4237 { this->__generate_impl(__f, __t, __urng, __p); }
4246 {
return __d1._M_param == __d2._M_param; }
4249 template<
typename _ForwardIterator,
4250 typename _UniformRandomNumberGenerator>
4252 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4253 _UniformRandomNumberGenerator& __urng,
4254 const param_type& __p);
4256 param_type _M_param;
4259 #if __cpp_impl_three_way_comparison < 201907L
4264 template<
typename _IntType>
4268 {
return !(__d1 == __d2); }
4281 template<
typename _IntType,
4282 typename _CharT,
typename _Traits>
4296 template<
typename _IntType,
4297 typename _CharT,
typename _Traits>
4313 template<
typename _IntType =
int>
4317 "result_type must be an integral type");
4332 : _M_k(__k), _M_p(__p)
4334 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4347 {
return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4349 #if __cpp_impl_three_way_comparison < 201907L
4352 {
return !(__p1 == __p2); }
4364 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4368 negative_binomial_distribution(
const param_type& __p)
4369 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4384 {
return _M_param.k(); }
4391 {
return _M_param.p(); }
4398 {
return _M_param; }
4406 { _M_param = __param; }
4425 template<
typename _UniformRandomNumberGenerator>
4427 operator()(_UniformRandomNumberGenerator& __urng);
4429 template<
typename _UniformRandomNumberGenerator>
4431 operator()(_UniformRandomNumberGenerator& __urng,
4432 const param_type& __p);
4434 template<
typename _ForwardIterator,
4435 typename _UniformRandomNumberGenerator>
4437 __generate(_ForwardIterator __f, _ForwardIterator __t,
4438 _UniformRandomNumberGenerator& __urng)
4439 { this->__generate_impl(__f, __t, __urng); }
4441 template<
typename _ForwardIterator,
4442 typename _UniformRandomNumberGenerator>
4444 __generate(_ForwardIterator __f, _ForwardIterator __t,
4445 _UniformRandomNumberGenerator& __urng,
4446 const param_type& __p)
4447 { this->__generate_impl(__f, __t, __urng, __p); }
4449 template<
typename _UniformRandomNumberGenerator>
4452 _UniformRandomNumberGenerator& __urng)
4453 { this->__generate_impl(__f, __t, __urng); }
4455 template<
typename _UniformRandomNumberGenerator>
4458 _UniformRandomNumberGenerator& __urng,
4459 const param_type& __p)
4460 { this->__generate_impl(__f, __t, __urng, __p); }
4470 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4483 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4498 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4504 template<
typename _ForwardIterator,
4505 typename _UniformRandomNumberGenerator>
4507 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4508 _UniformRandomNumberGenerator& __urng);
4509 template<
typename _ForwardIterator,
4510 typename _UniformRandomNumberGenerator>
4512 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4513 _UniformRandomNumberGenerator& __urng,
4514 const param_type& __p);
4516 param_type _M_param;
4521 #if __cpp_impl_three_way_comparison < 201907L
4525 template<
typename _IntType>
4529 {
return !(__d1 == __d2); }
4550 template<
typename _IntType =
int>
4554 "result_type must be an integral type");
4572 __glibcxx_assert(_M_mean > 0.0);
4582 {
return __p1._M_mean == __p2._M_mean; }
4584 #if __cpp_impl_three_way_comparison < 201907L
4587 {
return !(__p1 == __p2); }
4598 #if _GLIBCXX_USE_C99_MATH_TR1
4599 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4609 : _M_param(__mean), _M_nd()
4613 poisson_distribution(
const param_type& __p)
4614 : _M_param(__p), _M_nd()
4629 {
return _M_param.mean(); }
4636 {
return _M_param; }
4644 { _M_param = __param; }
4663 template<
typename _UniformRandomNumberGenerator>
4666 {
return this->
operator()(__urng, _M_param); }
4668 template<
typename _UniformRandomNumberGenerator>
4670 operator()(_UniformRandomNumberGenerator& __urng,
4671 const param_type& __p);
4673 template<
typename _ForwardIterator,
4674 typename _UniformRandomNumberGenerator>
4676 __generate(_ForwardIterator __f, _ForwardIterator __t,
4677 _UniformRandomNumberGenerator& __urng)
4678 { this->__generate(__f, __t, __urng, _M_param); }
4680 template<
typename _ForwardIterator,
4681 typename _UniformRandomNumberGenerator>
4683 __generate(_ForwardIterator __f, _ForwardIterator __t,
4684 _UniformRandomNumberGenerator& __urng,
4685 const param_type& __p)
4686 { this->__generate_impl(__f, __t, __urng, __p); }
4688 template<
typename _UniformRandomNumberGenerator>
4691 _UniformRandomNumberGenerator& __urng,
4692 const param_type& __p)
4693 { this->__generate_impl(__f, __t, __urng, __p); }
4703 #ifdef _GLIBCXX_USE_C99_MATH_TR1
4704 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4706 {
return __d1._M_param == __d2._M_param; }
4719 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4734 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4740 template<
typename _ForwardIterator,
4741 typename _UniformRandomNumberGenerator>
4743 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4744 _UniformRandomNumberGenerator& __urng,
4745 const param_type& __p);
4747 param_type _M_param;
4753 #if __cpp_impl_three_way_comparison < 201907L
4757 template<
typename _IntType>
4761 {
return !(__d1 == __d2); }
4782 template<
typename _RealType =
double>
4786 "result_type must be a floating point type");
4801 : _M_lambda(__lambda)
4803 __glibcxx_assert(_M_lambda > _RealType(0));
4808 {
return _M_lambda; }
4812 {
return __p1._M_lambda == __p2._M_lambda; }
4814 #if __cpp_impl_three_way_comparison < 201907L
4817 {
return !(__p1 == __p2); }
4821 _RealType _M_lambda;
4837 : _M_param(__lambda)
4858 {
return _M_param.lambda(); }
4865 {
return _M_param; }
4873 { _M_param = __param; }
4892 template<
typename _UniformRandomNumberGenerator>
4895 {
return this->
operator()(__urng, _M_param); }
4897 template<
typename _UniformRandomNumberGenerator>
4899 operator()(_UniformRandomNumberGenerator& __urng,
4900 const param_type& __p)
4902 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4907 template<
typename _ForwardIterator,
4908 typename _UniformRandomNumberGenerator>
4910 __generate(_ForwardIterator __f, _ForwardIterator __t,
4911 _UniformRandomNumberGenerator& __urng)
4912 { this->__generate(__f, __t, __urng, _M_param); }
4914 template<
typename _ForwardIterator,
4915 typename _UniformRandomNumberGenerator>
4917 __generate(_ForwardIterator __f, _ForwardIterator __t,
4918 _UniformRandomNumberGenerator& __urng,
4919 const param_type& __p)
4920 { this->__generate_impl(__f, __t, __urng, __p); }
4922 template<
typename _UniformRandomNumberGenerator>
4925 _UniformRandomNumberGenerator& __urng,
4926 const param_type& __p)
4927 { this->__generate_impl(__f, __t, __urng, __p); }
4936 {
return __d1._M_param == __d2._M_param; }
4939 template<
typename _ForwardIterator,
4940 typename _UniformRandomNumberGenerator>
4942 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4943 _UniformRandomNumberGenerator& __urng,
4944 const param_type& __p);
4946 param_type _M_param;
4949 #if __cpp_impl_three_way_comparison < 201907L
4954 template<
typename _RealType>
4958 {
return !(__d1 == __d2); }
4971 template<
typename _RealType,
typename _CharT,
typename _Traits>
4986 template<
typename _RealType,
typename _CharT,
typename _Traits>
5004 template<
typename _RealType =
double>
5008 "result_type must be a floating point type");
5022 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5023 : _M_a(__a), _M_b(__b)
5036 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5038 #if __cpp_impl_three_way_comparison < 201907L
5041 {
return !(__p1 == __p2); }
5053 : _M_param(__a, __b)
5057 weibull_distribution(
const param_type& __p)
5073 {
return _M_param.a(); }
5080 {
return _M_param.b(); }
5087 {
return _M_param; }
5095 { _M_param = __param; }
5114 template<
typename _UniformRandomNumberGenerator>
5117 {
return this->
operator()(__urng, _M_param); }
5119 template<
typename _UniformRandomNumberGenerator>
5121 operator()(_UniformRandomNumberGenerator& __urng,
5122 const param_type& __p);
5124 template<
typename _ForwardIterator,
5125 typename _UniformRandomNumberGenerator>
5127 __generate(_ForwardIterator __f, _ForwardIterator __t,
5128 _UniformRandomNumberGenerator& __urng)
5129 { this->__generate(__f, __t, __urng, _M_param); }
5131 template<
typename _ForwardIterator,
5132 typename _UniformRandomNumberGenerator>
5134 __generate(_ForwardIterator __f, _ForwardIterator __t,
5135 _UniformRandomNumberGenerator& __urng,
5136 const param_type& __p)
5137 { this->__generate_impl(__f, __t, __urng, __p); }
5139 template<
typename _UniformRandomNumberGenerator>
5142 _UniformRandomNumberGenerator& __urng,
5143 const param_type& __p)
5144 { this->__generate_impl(__f, __t, __urng, __p); }
5153 {
return __d1._M_param == __d2._M_param; }
5156 template<
typename _ForwardIterator,
5157 typename _UniformRandomNumberGenerator>
5159 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5160 _UniformRandomNumberGenerator& __urng,
5161 const param_type& __p);
5163 param_type _M_param;
5166 #if __cpp_impl_three_way_comparison < 201907L
5171 template<
typename _RealType>
5175 {
return !(__d1 == __d2); }
5188 template<
typename _RealType,
typename _CharT,
typename _Traits>
5203 template<
typename _RealType,
typename _CharT,
typename _Traits>
5221 template<
typename _RealType =
double>
5225 "result_type must be a floating point type");
5239 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5240 : _M_a(__a), _M_b(__b)
5253 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5255 #if __cpp_impl_three_way_comparison < 201907L
5258 {
return !(__p1 == __p2); }
5270 : _M_param(__a, __b)
5274 extreme_value_distribution(
const param_type& __p)
5290 {
return _M_param.a(); }
5297 {
return _M_param.b(); }
5304 {
return _M_param; }
5312 { _M_param = __param; }
5331 template<
typename _UniformRandomNumberGenerator>
5334 {
return this->
operator()(__urng, _M_param); }
5336 template<
typename _UniformRandomNumberGenerator>
5338 operator()(_UniformRandomNumberGenerator& __urng,
5339 const param_type& __p);
5341 template<
typename _ForwardIterator,
5342 typename _UniformRandomNumberGenerator>
5344 __generate(_ForwardIterator __f, _ForwardIterator __t,
5345 _UniformRandomNumberGenerator& __urng)
5346 { this->__generate(__f, __t, __urng, _M_param); }
5348 template<
typename _ForwardIterator,
5349 typename _UniformRandomNumberGenerator>
5351 __generate(_ForwardIterator __f, _ForwardIterator __t,
5352 _UniformRandomNumberGenerator& __urng,
5353 const param_type& __p)
5354 { this->__generate_impl(__f, __t, __urng, __p); }
5356 template<
typename _UniformRandomNumberGenerator>
5359 _UniformRandomNumberGenerator& __urng,
5360 const param_type& __p)
5361 { this->__generate_impl(__f, __t, __urng, __p); }
5370 {
return __d1._M_param == __d2._M_param; }
5373 template<
typename _ForwardIterator,
5374 typename _UniformRandomNumberGenerator>
5376 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5377 _UniformRandomNumberGenerator& __urng,
5378 const param_type& __p);
5380 param_type _M_param;
5383 #if __cpp_impl_three_way_comparison < 201907L
5388 template<
typename _RealType>
5392 {
return !(__d1 == __d2); }
5405 template<
typename _RealType,
typename _CharT,
typename _Traits>
5420 template<
typename _RealType,
typename _CharT,
typename _Traits>
5443 template<
typename _IntType =
int>
5447 "result_type must be an integral type");
5460 : _M_prob(), _M_cp()
5463 template<
typename _InputIterator>
5465 _InputIterator __wend)
5466 : _M_prob(__wbegin, __wend), _M_cp()
5467 { _M_initialize(); }
5470 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5471 { _M_initialize(); }
5473 template<
typename _Func>
5474 param_type(
size_t __nw,
double __xmin,
double __xmax,
5482 probabilities()
const
5487 {
return __p1._M_prob == __p2._M_prob; }
5489 #if __cpp_impl_three_way_comparison < 201907L
5492 {
return !(__p1 == __p2); }
5507 template<
typename _InputIterator>
5509 _InputIterator __wend)
5510 : _M_param(__wbegin, __wend)
5513 discrete_distribution(initializer_list<double> __wl)
5517 template<
typename _Func>
5518 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5520 : _M_param(__nw, __xmin, __xmax, __fw)
5524 discrete_distribution(
const param_type& __p)
5541 return _M_param._M_prob.
empty()
5550 {
return _M_param; }
5558 { _M_param = __param; }
5573 return _M_param._M_prob.
empty()
5580 template<
typename _UniformRandomNumberGenerator>
5583 {
return this->
operator()(__urng, _M_param); }
5585 template<
typename _UniformRandomNumberGenerator>
5587 operator()(_UniformRandomNumberGenerator& __urng,
5588 const param_type& __p);
5590 template<
typename _ForwardIterator,
5591 typename _UniformRandomNumberGenerator>
5593 __generate(_ForwardIterator __f, _ForwardIterator __t,
5594 _UniformRandomNumberGenerator& __urng)
5595 { this->__generate(__f, __t, __urng, _M_param); }
5597 template<
typename _ForwardIterator,
5598 typename _UniformRandomNumberGenerator>
5600 __generate(_ForwardIterator __f, _ForwardIterator __t,
5601 _UniformRandomNumberGenerator& __urng,
5602 const param_type& __p)
5603 { this->__generate_impl(__f, __t, __urng, __p); }
5605 template<
typename _UniformRandomNumberGenerator>
5608 _UniformRandomNumberGenerator& __urng,
5609 const param_type& __p)
5610 { this->__generate_impl(__f, __t, __urng, __p); }
5619 {
return __d1._M_param == __d2._M_param; }
5631 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5647 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5653 template<
typename _ForwardIterator,
5654 typename _UniformRandomNumberGenerator>
5656 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5657 _UniformRandomNumberGenerator& __urng,
5658 const param_type& __p);
5660 param_type _M_param;
5663 #if __cpp_impl_three_way_comparison < 201907L
5668 template<
typename _IntType>
5672 {
return !(__d1 == __d2); }
5691 template<
typename _RealType =
double>
5695 "result_type must be a floating point type");
5708 : _M_int(), _M_den(), _M_cp()
5711 template<
typename _InputIteratorB,
typename _InputIteratorW>
5713 _InputIteratorB __bend,
5714 _InputIteratorW __wbegin);
5716 template<
typename _Func>
5719 template<
typename _Func>
5720 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5733 __tmp[1] = _RealType(1);
5746 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5748 #if __cpp_impl_three_way_comparison < 201907L
5751 {
return !(__p1 == __p2); }
5767 template<
typename _InputIteratorB,
typename _InputIteratorW>
5769 _InputIteratorB __bend,
5770 _InputIteratorW __wbegin)
5771 : _M_param(__bfirst, __bend, __wbegin)
5774 template<
typename _Func>
5775 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5777 : _M_param(__bl, __fw)
5780 template<
typename _Func>
5781 piecewise_constant_distribution(
size_t __nw,
5782 _RealType __xmin, _RealType __xmax,
5784 : _M_param(__nw, __xmin, __xmax, __fw)
5788 piecewise_constant_distribution(
const param_type& __p)
5805 if (_M_param._M_int.
empty())
5808 __tmp[1] = _RealType(1);
5812 return _M_param._M_int;
5821 return _M_param._M_den.
empty()
5830 {
return _M_param; }
5838 { _M_param = __param; }
5846 return _M_param._M_int.
empty()
5856 return _M_param._M_int.
empty()
5863 template<
typename _UniformRandomNumberGenerator>
5866 {
return this->
operator()(__urng, _M_param); }
5868 template<
typename _UniformRandomNumberGenerator>
5870 operator()(_UniformRandomNumberGenerator& __urng,
5871 const param_type& __p);
5873 template<
typename _ForwardIterator,
5874 typename _UniformRandomNumberGenerator>
5876 __generate(_ForwardIterator __f, _ForwardIterator __t,
5877 _UniformRandomNumberGenerator& __urng)
5878 { this->__generate(__f, __t, __urng, _M_param); }
5880 template<
typename _ForwardIterator,
5881 typename _UniformRandomNumberGenerator>
5883 __generate(_ForwardIterator __f, _ForwardIterator __t,
5884 _UniformRandomNumberGenerator& __urng,
5885 const param_type& __p)
5886 { this->__generate_impl(__f, __t, __urng, __p); }
5888 template<
typename _UniformRandomNumberGenerator>
5891 _UniformRandomNumberGenerator& __urng,
5892 const param_type& __p)
5893 { this->__generate_impl(__f, __t, __urng, __p); }
5902 {
return __d1._M_param == __d2._M_param; }
5915 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5931 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5937 template<
typename _ForwardIterator,
5938 typename _UniformRandomNumberGenerator>
5940 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5941 _UniformRandomNumberGenerator& __urng,
5942 const param_type& __p);
5944 param_type _M_param;
5947 #if __cpp_impl_three_way_comparison < 201907L
5952 template<
typename _RealType>
5956 {
return !(__d1 == __d2); }
5971 template<
typename _RealType =
double>
5975 "result_type must be a floating point type");
5988 : _M_int(), _M_den(), _M_cp(), _M_m()
5991 template<
typename _InputIteratorB,
typename _InputIteratorW>
5993 _InputIteratorB __bend,
5994 _InputIteratorW __wbegin);
5996 template<
typename _Func>
5999 template<
typename _Func>
6000 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
6013 __tmp[1] = _RealType(1);
6026 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
6028 #if __cpp_impl_three_way_comparison < 201907L
6031 {
return !(__p1 == __p2); }
6048 template<
typename _InputIteratorB,
typename _InputIteratorW>
6050 _InputIteratorB __bend,
6051 _InputIteratorW __wbegin)
6052 : _M_param(__bfirst, __bend, __wbegin)
6055 template<
typename _Func>
6056 piecewise_linear_distribution(initializer_list<_RealType> __bl,
6058 : _M_param(__bl, __fw)
6061 template<
typename _Func>
6062 piecewise_linear_distribution(
size_t __nw,
6063 _RealType __xmin, _RealType __xmax,
6065 : _M_param(__nw, __xmin, __xmax, __fw)
6069 piecewise_linear_distribution(
const param_type& __p)
6086 if (_M_param._M_int.
empty())
6089 __tmp[1] = _RealType(1);
6093 return _M_param._M_int;
6103 return _M_param._M_den.
empty()
6112 {
return _M_param; }
6120 { _M_param = __param; }
6128 return _M_param._M_int.
empty()
6138 return _M_param._M_int.
empty()
6145 template<
typename _UniformRandomNumberGenerator>
6148 {
return this->
operator()(__urng, _M_param); }
6150 template<
typename _UniformRandomNumberGenerator>
6152 operator()(_UniformRandomNumberGenerator& __urng,
6153 const param_type& __p);
6155 template<
typename _ForwardIterator,
6156 typename _UniformRandomNumberGenerator>
6158 __generate(_ForwardIterator __f, _ForwardIterator __t,
6159 _UniformRandomNumberGenerator& __urng)
6160 { this->__generate(__f, __t, __urng, _M_param); }
6162 template<
typename _ForwardIterator,
6163 typename _UniformRandomNumberGenerator>
6165 __generate(_ForwardIterator __f, _ForwardIterator __t,
6166 _UniformRandomNumberGenerator& __urng,
6167 const param_type& __p)
6168 { this->__generate_impl(__f, __t, __urng, __p); }
6170 template<
typename _UniformRandomNumberGenerator>
6173 _UniformRandomNumberGenerator& __urng,
6174 const param_type& __p)
6175 { this->__generate_impl(__f, __t, __urng, __p); }
6184 {
return __d1._M_param == __d2._M_param; }
6197 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6213 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6219 template<
typename _ForwardIterator,
6220 typename _UniformRandomNumberGenerator>
6222 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6223 _UniformRandomNumberGenerator& __urng,
6224 const param_type& __p);
6226 param_type _M_param;
6229 #if __cpp_impl_three_way_comparison < 201907L
6234 template<
typename _RealType>
6238 {
return !(__d1 == __d2); }
6269 template<
typename _IntType,
typename = _Require<is_
integral<_IntType>>>
6272 template<
typename _InputIterator>
6273 seed_seq(_InputIterator __begin, _InputIterator __end);
6276 template<
typename _RandomAccessIterator>
6278 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6281 size_t size() const noexcept
6282 {
return _M_v.
size(); }
6284 template<
typename _OutputIterator>
6286 param(_OutputIterator __dest)
const
6287 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
6301 _GLIBCXX_END_NAMESPACE_VERSION