36 #if __cplusplus > 201703L
40 namespace std _GLIBCXX_VISIBILITY(default)
42 _GLIBCXX_BEGIN_NAMESPACE_VERSION
54 #ifdef __cpp_lib_concepts
56 template<
typename _Gen>
57 concept uniform_random_bit_generator
58 = invocable<_Gen&> && unsigned_integral<invoke_result_t<_Gen&>>
61 {
_Gen::min() } -> same_as<invoke_result_t<_Gen&>>;
62 {
_Gen::max() } -> same_as<invoke_result_t<_Gen&>>;
71 template<
typename _RealType,
size_t __bits,
72 typename _UniformRandomNumberGenerator>
81 template<
typename _UIntType,
size_t __w,
82 bool = __w < static_cast<size_t>
85 {
static const _UIntType __value = 0; };
87 template<
typename _UIntType,
size_t __w>
88 struct _Shift<_UIntType, __w, true>
89 {
static const _UIntType __value = _UIntType(1) << __w; };
92 int __which = ((__s <= __CHAR_BIT__ *
sizeof (int))
93 + (__s <= __CHAR_BIT__ *
sizeof (long))
94 + (__s <= __CHAR_BIT__ *
sizeof (
long long))
97 struct _Select_uint_least_t
99 static_assert(__which < 0,
100 "sorry, would be too much trouble for a slow result");
104 struct _Select_uint_least_t<__s, 4>
105 {
typedef unsigned int type; };
108 struct _Select_uint_least_t<__s, 3>
109 {
typedef unsigned long type; };
112 struct _Select_uint_least_t<__s, 2>
113 {
typedef unsigned long long type; };
115 #ifdef _GLIBCXX_USE_INT128
117 struct _Select_uint_least_t<__s, 1>
118 {
typedef unsigned __int128 type; };
122 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
123 bool __big_enough = (!(__m & (__m - 1))
124 || (_Tp(-1) - __c) / __a >= __m - 1),
125 bool __schrage_ok = __m % __a < __m / __a>
128 typedef typename _Select_uint_least_t<
std::__lg(__a)
132 {
return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); }
136 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
137 struct _Mod<_Tp, __m, __a, __c, false, true>
146 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
147 struct _Mod<_Tp, __m, __a, __c, true, __s>
152 _Tp __res = __a * __x + __c;
159 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
162 {
return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
168 template<
typename _Engine,
typename _DInputType>
172 "template argument must be a floating point type");
175 _Adaptor(_Engine& __g)
180 {
return _DInputType(0); }
184 {
return _DInputType(1); }
203 template<
typename _Sseq>
204 using __seed_seq_generate_t = decltype(
205 std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
206 std::declval<uint_least32_t*>()));
210 template<
typename _Sseq,
typename _Engine,
typename _Res,
211 typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
212 using __is_seed_seq = __and_<
213 __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
214 is_unsigned<typename _Sseq::result_type>,
215 __not_<is_convertible<_Sseq, _Res>>
258 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
261 static_assert(std::is_unsigned<_UIntType>::value,
262 "result_type must be an unsigned integral type");
263 static_assert(__m == 0u || (__a < __m && __c < __m),
264 "template argument substituting __m out of bounds");
266 template<
typename _Sseq>
267 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
306 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
327 template<
typename _Sseq>
339 {
return __c == 0u ? 1u : 0u; }
354 for (; __z != 0ULL; --__z)
364 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
382 {
return __lhs._M_x == __rhs._M_x; }
392 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
393 _UIntType1 __m1,
typename _CharT,
typename _Traits>
397 __a1, __c1, __m1>& __lcr);
412 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
413 _UIntType1 __m1,
typename _CharT,
typename _Traits>
434 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
440 {
return !(__lhs == __rhs); }
471 template<
typename _UIntType,
size_t __w,
472 size_t __n,
size_t __m,
size_t __r,
473 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
474 _UIntType __b,
size_t __t,
475 _UIntType __c,
size_t __l, _UIntType __f>
478 static_assert(std::is_unsigned<_UIntType>::value,
479 "result_type must be an unsigned integral type");
480 static_assert(1u <= __m && __m <= __n,
481 "template argument substituting __m out of bounds");
482 static_assert(__r <= __w,
"template argument substituting "
484 static_assert(__u <= __w,
"template argument substituting "
486 static_assert(__s <= __w,
"template argument substituting "
488 static_assert(__t <= __w,
"template argument substituting "
490 static_assert(__l <= __w,
"template argument substituting "
493 "template argument substituting __w out of bound");
494 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
495 "template argument substituting __a out of bound");
496 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
497 "template argument substituting __b out of bound");
498 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
499 "template argument substituting __c out of bound");
500 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
501 "template argument substituting __d out of bound");
502 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
503 "template argument substituting __f out of bound");
505 template<
typename _Sseq>
506 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
514 static constexpr
size_t word_size = __w;
515 static constexpr
size_t state_size = __n;
516 static constexpr
size_t shift_size = __m;
517 static constexpr
size_t mask_bits = __r;
519 static constexpr
size_t tempering_u = __u;
521 static constexpr
size_t tempering_s = __s;
523 static constexpr
size_t tempering_t = __t;
525 static constexpr
size_t tempering_l = __l;
526 static constexpr
result_type initialization_multiplier = __f;
543 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
551 template<
typename _Sseq>
567 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
573 discard(
unsigned long long __z);
593 {
return (
std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
594 && __lhs._M_p == __rhs._M_p); }
608 template<
typename _UIntType1,
609 size_t __w1,
size_t __n1,
610 size_t __m1,
size_t __r1,
611 _UIntType1 __a1,
size_t __u1,
612 _UIntType1 __d1,
size_t __s1,
613 _UIntType1 __b1,
size_t __t1,
614 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
615 typename _CharT,
typename _Traits>
619 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
634 template<
typename _UIntType1,
635 size_t __w1,
size_t __n1,
636 size_t __m1,
size_t __r1,
637 _UIntType1 __a1,
size_t __u1,
638 _UIntType1 __d1,
size_t __s1,
639 _UIntType1 __b1,
size_t __t1,
640 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
641 typename _CharT,
typename _Traits>
645 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
651 _UIntType _M_x[state_size];
667 template<
typename _UIntType,
size_t __w,
668 size_t __n,
size_t __m,
size_t __r,
669 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
670 _UIntType __b,
size_t __t,
671 _UIntType __c,
size_t __l, _UIntType __f>
674 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
676 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
677 {
return !(__lhs == __rhs); }
695 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
698 static_assert(std::is_unsigned<_UIntType>::value,
699 "result_type must be an unsigned integral type");
700 static_assert(0u < __s && __s < __r,
703 "template argument substituting __w out of bounds");
705 template<
typename _Sseq>
706 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
714 static constexpr
size_t word_size = __w;
715 static constexpr
size_t short_lag = __s;
716 static constexpr
size_t long_lag = __r;
717 static constexpr
result_type default_seed = 19780503u;
736 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
760 template<
typename _Sseq>
778 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
786 for (; __z != 0ULL; --__z)
811 {
return (
std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
812 && __lhs._M_carry == __rhs._M_carry
813 && __lhs._M_p == __rhs._M_p); }
827 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
828 typename _CharT,
typename _Traits>
846 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
847 typename _CharT,
typename _Traits>
855 _UIntType _M_x[long_lag];
872 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
878 {
return !(__lhs == __rhs); }
887 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
890 static_assert(1 <= __r && __r <= __p,
891 "template argument substituting __r out of bounds");
895 typedef typename _RandomNumberEngine::result_type
result_type;
897 template<
typename _Sseq>
898 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
902 static constexpr
size_t block_size = __p;
903 static constexpr
size_t used_block = __r;
911 : _M_b(), _M_n(0) { }
921 : _M_b(__rng), _M_n(0) { }
931 : _M_b(
std::
move(__rng)), _M_n(0) { }
941 : _M_b(__s), _M_n(0) { }
948 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
981 template<
typename _Sseq>
993 const _RandomNumberEngine&
1017 for (; __z != 0ULL; --__z)
1041 {
return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1054 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1055 typename _CharT,
typename _Traits>
1072 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1073 typename _CharT,
typename _Traits>
1080 _RandomNumberEngine _M_b;
1095 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1101 {
return !(__lhs == __rhs); }
1108 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1111 static_assert(std::is_unsigned<_UIntType>::value,
1112 "result_type must be an unsigned integral type");
1114 "template argument substituting __w out of bounds");
1116 template<
typename _Sseq>
1117 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
1167 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1194 template<
typename _Sseq>
1203 const _RandomNumberEngine&
1219 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1227 for (; __z != 0ULL; --__z)
1252 {
return __lhs._M_b == __rhs._M_b; }
1266 template<
typename _CharT,
typename _Traits>
1270 __w, _UIntType>& __x)
1277 _RandomNumberEngine _M_b;
1292 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1298 {
return !(__lhs == __rhs); }
1310 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1311 typename _CharT,
typename _Traits>
1315 __w, _UIntType>& __x)
1327 template<
typename _RandomNumberEngine,
size_t __k>
1330 static_assert(1u <= __k,
"template argument substituting "
1331 "__k out of bound");
1335 typedef typename _RandomNumberEngine::result_type
result_type;
1337 template<
typename _Sseq>
1338 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
1341 static constexpr
size_t table_size = __k;
1350 { _M_initialize(); }
1361 { _M_initialize(); }
1372 { _M_initialize(); }
1383 { _M_initialize(); }
1390 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1394 { _M_initialize(); }
1423 template<
typename _Sseq>
1434 const _RandomNumberEngine&
1458 for (; __z != 0ULL; --__z)
1482 {
return (__lhs._M_b == __rhs._M_b
1483 &&
std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1484 && __lhs._M_y == __rhs._M_y); }
1497 template<
typename _RandomNumberEngine1,
size_t __k1,
1498 typename _CharT,
typename _Traits>
1515 template<
typename _RandomNumberEngine1,
size_t __k1,
1516 typename _CharT,
typename _Traits>
1522 void _M_initialize()
1524 for (
size_t __i = 0; __i < __k; ++__i)
1529 _RandomNumberEngine _M_b;
1545 template<
typename _RandomNumberEngine,
size_t __k>
1551 {
return !(__lhs == __rhs); }
1557 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1588 0xb5026f5aa96619e9ULL, 29,
1589 0x5555555555555555ULL, 17,
1590 0x71d67fffeda60000ULL, 37,
1591 0xfff7eee000000000ULL, 43,
1625 #if defined _GLIBCXX_USE_DEV_RANDOM
1639 entropy() const noexcept
1641 #ifdef _GLIBCXX_USE_DEV_RANDOM
1642 return this->_M_getentropy();
1650 {
return this->_M_getval(); }
1653 random_device(
const random_device&) =
delete;
1654 void operator=(
const random_device&) =
delete;
1664 double _M_getentropy() const noexcept;
1666 void _M_init(const
char*,
size_t);
1700 template<
typename _IntType>
1704 {
return !(__d1 == __d2); }
1716 template<
typename _IntType,
typename _CharT,
typename _Traits>
1730 template<
typename _IntType,
typename _CharT,
typename _Traits>
1743 template<
typename _RealType =
double>
1747 "result_type must be a floating point type");
1761 param_type(_RealType __a, _RealType __b = _RealType(1))
1762 : _M_a(__a), _M_b(__b)
1764 __glibcxx_assert(_M_a <= _M_b);
1777 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1781 {
return !(__p1 == __p2); }
1804 : _M_param(__a, __b)
1822 {
return _M_param.a(); }
1826 {
return _M_param.b(); }
1833 {
return _M_param; }
1841 { _M_param = __param; }
1848 {
return this->a(); }
1855 {
return this->b(); }
1860 template<
typename _UniformRandomNumberGenerator>
1863 {
return this->
operator()(__urng, _M_param); }
1865 template<
typename _UniformRandomNumberGenerator>
1867 operator()(_UniformRandomNumberGenerator& __urng,
1868 const param_type& __p)
1870 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1872 return (__aurng() * (__p.b() - __p.a())) + __p.a();
1875 template<
typename _ForwardIterator,
1876 typename _UniformRandomNumberGenerator>
1878 __generate(_ForwardIterator __f, _ForwardIterator __t,
1879 _UniformRandomNumberGenerator& __urng)
1880 { this->__generate(__f, __t, __urng, _M_param); }
1882 template<
typename _ForwardIterator,
1883 typename _UniformRandomNumberGenerator>
1885 __generate(_ForwardIterator __f, _ForwardIterator __t,
1886 _UniformRandomNumberGenerator& __urng,
1887 const param_type& __p)
1888 { this->__generate_impl(__f, __t, __urng, __p); }
1890 template<
typename _UniformRandomNumberGenerator>
1893 _UniformRandomNumberGenerator& __urng,
1894 const param_type& __p)
1895 { this->__generate_impl(__f, __t, __urng, __p); }
1904 {
return __d1._M_param == __d2._M_param; }
1907 template<
typename _ForwardIterator,
1908 typename _UniformRandomNumberGenerator>
1910 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1911 _UniformRandomNumberGenerator& __urng,
1912 const param_type& __p);
1914 param_type _M_param;
1921 template<
typename _IntType>
1925 {
return !(__d1 == __d2); }
1937 template<
typename _RealType,
typename _CharT,
typename _Traits>
1951 template<
typename _RealType,
typename _CharT,
typename _Traits>
1973 template<
typename _RealType =
double>
1977 "result_type must be a floating point type");
1991 param_type(_RealType __mean, _RealType __stddev = _RealType(1))
1992 : _M_mean(__mean), _M_stddev(__stddev)
1994 __glibcxx_assert(_M_stddev > _RealType(0));
2003 {
return _M_stddev; }
2007 {
return (__p1._M_mean == __p2._M_mean
2008 && __p1._M_stddev == __p2._M_stddev); }
2012 {
return !(__p1 == __p2); }
2016 _RealType _M_stddev;
2029 : _M_param(__mean, __stddev), _M_saved_available(false)
2034 : _M_param(__p), _M_saved_available(false)
2042 { _M_saved_available =
false; }
2049 {
return _M_param.mean(); }
2056 {
return _M_param.stddev(); }
2063 {
return _M_param; }
2071 { _M_param = __param; }
2090 template<
typename _UniformRandomNumberGenerator>
2093 {
return this->
operator()(__urng, _M_param); }
2095 template<
typename _UniformRandomNumberGenerator>
2097 operator()(_UniformRandomNumberGenerator& __urng,
2098 const param_type& __p);
2100 template<
typename _ForwardIterator,
2101 typename _UniformRandomNumberGenerator>
2103 __generate(_ForwardIterator __f, _ForwardIterator __t,
2104 _UniformRandomNumberGenerator& __urng)
2105 { this->__generate(__f, __t, __urng, _M_param); }
2107 template<
typename _ForwardIterator,
2108 typename _UniformRandomNumberGenerator>
2110 __generate(_ForwardIterator __f, _ForwardIterator __t,
2111 _UniformRandomNumberGenerator& __urng,
2112 const param_type& __p)
2113 { this->__generate_impl(__f, __t, __urng, __p); }
2115 template<
typename _UniformRandomNumberGenerator>
2118 _UniformRandomNumberGenerator& __urng,
2119 const param_type& __p)
2120 { this->__generate_impl(__f, __t, __urng, __p); }
2127 template<
typename _RealType1>
2142 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2157 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2163 template<
typename _ForwardIterator,
2164 typename _UniformRandomNumberGenerator>
2166 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2167 _UniformRandomNumberGenerator& __urng,
2168 const param_type& __p);
2170 param_type _M_param;
2172 bool _M_saved_available;
2178 template<
typename _RealType>
2182 {
return !(__d1 == __d2); }
2194 template<
typename _RealType =
double>
2198 "result_type must be a floating point type");
2212 param_type(_RealType __m, _RealType __s = _RealType(1))
2213 : _M_m(__m), _M_s(__s)
2226 {
return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2230 {
return !(__p1 == __p2); }
2241 : _M_param(__m, __s), _M_nd()
2245 lognormal_distribution(
const param_type& __p)
2246 : _M_param(__p), _M_nd()
2261 {
return _M_param.m(); }
2265 {
return _M_param.s(); }
2272 {
return _M_param; }
2280 { _M_param = __param; }
2299 template<
typename _UniformRandomNumberGenerator>
2302 {
return this->
operator()(__urng, _M_param); }
2304 template<
typename _UniformRandomNumberGenerator>
2306 operator()(_UniformRandomNumberGenerator& __urng,
2307 const param_type& __p)
2308 {
return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2310 template<
typename _ForwardIterator,
2311 typename _UniformRandomNumberGenerator>
2313 __generate(_ForwardIterator __f, _ForwardIterator __t,
2314 _UniformRandomNumberGenerator& __urng)
2315 { this->__generate(__f, __t, __urng, _M_param); }
2317 template<
typename _ForwardIterator,
2318 typename _UniformRandomNumberGenerator>
2320 __generate(_ForwardIterator __f, _ForwardIterator __t,
2321 _UniformRandomNumberGenerator& __urng,
2322 const param_type& __p)
2323 { this->__generate_impl(__f, __t, __urng, __p); }
2325 template<
typename _UniformRandomNumberGenerator>
2328 _UniformRandomNumberGenerator& __urng,
2329 const param_type& __p)
2330 { this->__generate_impl(__f, __t, __urng, __p); }
2340 {
return (__d1._M_param == __d2._M_param
2341 && __d1._M_nd == __d2._M_nd); }
2353 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2368 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2374 template<
typename _ForwardIterator,
2375 typename _UniformRandomNumberGenerator>
2377 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2378 _UniformRandomNumberGenerator& __urng,
2379 const param_type& __p);
2381 param_type _M_param;
2389 template<
typename _RealType>
2393 {
return !(__d1 == __d2); }
2405 template<
typename _RealType =
double>
2409 "result_type must be a floating point type");
2424 param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1))
2425 : _M_alpha(__alpha_val), _M_beta(__beta_val)
2427 __glibcxx_assert(_M_alpha > _RealType(0));
2433 {
return _M_alpha; }
2441 {
return (__p1._M_alpha == __p2._M_alpha
2442 && __p1._M_beta == __p2._M_beta); }
2446 {
return !(__p1 == __p2); }
2455 _RealType _M_malpha, _M_a2;
2470 _RealType __beta_val = _RealType(1))
2471 : _M_param(__alpha_val, __beta_val), _M_nd()
2476 : _M_param(__p), _M_nd()
2491 {
return _M_param.alpha(); }
2498 {
return _M_param.beta(); }
2505 {
return _M_param; }
2513 { _M_param = __param; }
2532 template<
typename _UniformRandomNumberGenerator>
2535 {
return this->
operator()(__urng, _M_param); }
2537 template<
typename _UniformRandomNumberGenerator>
2539 operator()(_UniformRandomNumberGenerator& __urng,
2540 const param_type& __p);
2542 template<
typename _ForwardIterator,
2543 typename _UniformRandomNumberGenerator>
2545 __generate(_ForwardIterator __f, _ForwardIterator __t,
2546 _UniformRandomNumberGenerator& __urng)
2547 { this->__generate(__f, __t, __urng, _M_param); }
2549 template<
typename _ForwardIterator,
2550 typename _UniformRandomNumberGenerator>
2552 __generate(_ForwardIterator __f, _ForwardIterator __t,
2553 _UniformRandomNumberGenerator& __urng,
2554 const param_type& __p)
2555 { this->__generate_impl(__f, __t, __urng, __p); }
2557 template<
typename _UniformRandomNumberGenerator>
2560 _UniformRandomNumberGenerator& __urng,
2561 const param_type& __p)
2562 { this->__generate_impl(__f, __t, __urng, __p); }
2572 {
return (__d1._M_param == __d2._M_param
2573 && __d1._M_nd == __d2._M_nd); }
2585 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2599 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2605 template<
typename _ForwardIterator,
2606 typename _UniformRandomNumberGenerator>
2608 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2609 _UniformRandomNumberGenerator& __urng,
2610 const param_type& __p);
2612 param_type _M_param;
2620 template<
typename _RealType>
2624 {
return !(__d1 == __d2); }
2633 template<
typename _RealType =
double>
2637 "result_type must be a floating point type");
2661 {
return __p1._M_n == __p2._M_n; }
2665 {
return !(__p1 == __p2); }
2675 : _M_param(__n), _M_gd(__n / 2)
2679 chi_squared_distribution(
const param_type& __p)
2680 : _M_param(__p), _M_gd(__p.n() / 2)
2695 {
return _M_param.n(); }
2702 {
return _M_param; }
2734 template<
typename _UniformRandomNumberGenerator>
2737 {
return 2 * _M_gd(__urng); }
2739 template<
typename _UniformRandomNumberGenerator>
2741 operator()(_UniformRandomNumberGenerator& __urng,
2742 const param_type& __p)
2746 return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2749 template<
typename _ForwardIterator,
2750 typename _UniformRandomNumberGenerator>
2752 __generate(_ForwardIterator __f, _ForwardIterator __t,
2753 _UniformRandomNumberGenerator& __urng)
2754 { this->__generate_impl(__f, __t, __urng); }
2756 template<
typename _ForwardIterator,
2757 typename _UniformRandomNumberGenerator>
2759 __generate(_ForwardIterator __f, _ForwardIterator __t,
2760 _UniformRandomNumberGenerator& __urng,
2761 const param_type& __p)
2764 this->__generate_impl(__f, __t, __urng, __p2); }
2766 template<
typename _UniformRandomNumberGenerator>
2769 _UniformRandomNumberGenerator& __urng)
2770 { this->__generate_impl(__f, __t, __urng); }
2772 template<
typename _UniformRandomNumberGenerator>
2775 _UniformRandomNumberGenerator& __urng,
2776 const param_type& __p)
2779 this->__generate_impl(__f, __t, __urng, __p2); }
2789 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2801 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2816 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2822 template<
typename _ForwardIterator,
2823 typename _UniformRandomNumberGenerator>
2825 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2826 _UniformRandomNumberGenerator& __urng);
2828 template<
typename _ForwardIterator,
2829 typename _UniformRandomNumberGenerator>
2831 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2832 _UniformRandomNumberGenerator& __urng,
2836 param_type _M_param;
2844 template<
typename _RealType>
2848 {
return !(__d1 == __d2); }
2857 template<
typename _RealType =
double>
2861 "result_type must be a floating point type");
2875 param_type(_RealType __a, _RealType __b = _RealType(1))
2876 : _M_a(__a), _M_b(__b)
2889 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
2893 {
return !(__p1 == __p2); }
2904 : _M_param(__a, __b)
2908 cauchy_distribution(
const param_type& __p)
2924 {
return _M_param.a(); }
2928 {
return _M_param.b(); }
2935 {
return _M_param; }
2943 { _M_param = __param; }
2962 template<
typename _UniformRandomNumberGenerator>
2965 {
return this->
operator()(__urng, _M_param); }
2967 template<
typename _UniformRandomNumberGenerator>
2969 operator()(_UniformRandomNumberGenerator& __urng,
2970 const param_type& __p);
2972 template<
typename _ForwardIterator,
2973 typename _UniformRandomNumberGenerator>
2975 __generate(_ForwardIterator __f, _ForwardIterator __t,
2976 _UniformRandomNumberGenerator& __urng)
2977 { this->__generate(__f, __t, __urng, _M_param); }
2979 template<
typename _ForwardIterator,
2980 typename _UniformRandomNumberGenerator>
2982 __generate(_ForwardIterator __f, _ForwardIterator __t,
2983 _UniformRandomNumberGenerator& __urng,
2984 const param_type& __p)
2985 { this->__generate_impl(__f, __t, __urng, __p); }
2987 template<
typename _UniformRandomNumberGenerator>
2990 _UniformRandomNumberGenerator& __urng,
2991 const param_type& __p)
2992 { this->__generate_impl(__f, __t, __urng, __p); }
3001 {
return __d1._M_param == __d2._M_param; }
3004 template<
typename _ForwardIterator,
3005 typename _UniformRandomNumberGenerator>
3007 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3008 _UniformRandomNumberGenerator& __urng,
3009 const param_type& __p);
3011 param_type _M_param;
3018 template<
typename _RealType>
3022 {
return !(__d1 == __d2); }
3034 template<
typename _RealType,
typename _CharT,
typename _Traits>
3049 template<
typename _RealType,
typename _CharT,
typename _Traits>
3065 template<
typename _RealType =
double>
3069 "result_type must be a floating point type");
3083 param_type(_RealType __m, _RealType __n = _RealType(1))
3084 : _M_m(__m), _M_n(__n)
3097 {
return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3101 {
return !(__p1 == __p2); }
3112 _RealType __n = _RealType(1))
3113 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3117 fisher_f_distribution(
const param_type& __p)
3118 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3136 {
return _M_param.m(); }
3140 {
return _M_param.n(); }
3147 {
return _M_param; }
3155 { _M_param = __param; }
3174 template<
typename _UniformRandomNumberGenerator>
3177 {
return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3179 template<
typename _UniformRandomNumberGenerator>
3181 operator()(_UniformRandomNumberGenerator& __urng,
3182 const param_type& __p)
3186 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3187 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3190 template<
typename _ForwardIterator,
3191 typename _UniformRandomNumberGenerator>
3193 __generate(_ForwardIterator __f, _ForwardIterator __t,
3194 _UniformRandomNumberGenerator& __urng)
3195 { this->__generate_impl(__f, __t, __urng); }
3197 template<
typename _ForwardIterator,
3198 typename _UniformRandomNumberGenerator>
3200 __generate(_ForwardIterator __f, _ForwardIterator __t,
3201 _UniformRandomNumberGenerator& __urng,
3202 const param_type& __p)
3203 { this->__generate_impl(__f, __t, __urng, __p); }
3205 template<
typename _UniformRandomNumberGenerator>
3208 _UniformRandomNumberGenerator& __urng)
3209 { this->__generate_impl(__f, __t, __urng); }
3211 template<
typename _UniformRandomNumberGenerator>
3214 _UniformRandomNumberGenerator& __urng,
3215 const param_type& __p)
3216 { this->__generate_impl(__f, __t, __urng, __p); }
3226 {
return (__d1._M_param == __d2._M_param
3227 && __d1._M_gd_x == __d2._M_gd_x
3228 && __d1._M_gd_y == __d2._M_gd_y); }
3240 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3255 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3261 template<
typename _ForwardIterator,
3262 typename _UniformRandomNumberGenerator>
3264 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3265 _UniformRandomNumberGenerator& __urng);
3267 template<
typename _ForwardIterator,
3268 typename _UniformRandomNumberGenerator>
3270 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3271 _UniformRandomNumberGenerator& __urng,
3272 const param_type& __p);
3274 param_type _M_param;
3282 template<
typename _RealType>
3286 {
return !(__d1 == __d2); }
3297 template<
typename _RealType =
double>
3301 "result_type must be a floating point type");
3325 {
return __p1._M_n == __p2._M_n; }
3329 {
return !(__p1 == __p2); }
3339 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3343 student_t_distribution(
const param_type& __p)
3344 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3362 {
return _M_param.n(); }
3369 {
return _M_param; }
3377 { _M_param = __param; }
3396 template<
typename _UniformRandomNumberGenerator>
3399 {
return _M_nd(__urng) *
std::sqrt(n() / _M_gd(__urng)); }
3401 template<
typename _UniformRandomNumberGenerator>
3403 operator()(_UniformRandomNumberGenerator& __urng,
3404 const param_type& __p)
3409 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3410 return _M_nd(__urng) *
std::sqrt(__p.n() / __g);
3413 template<
typename _ForwardIterator,
3414 typename _UniformRandomNumberGenerator>
3416 __generate(_ForwardIterator __f, _ForwardIterator __t,
3417 _UniformRandomNumberGenerator& __urng)
3418 { this->__generate_impl(__f, __t, __urng); }
3420 template<
typename _ForwardIterator,
3421 typename _UniformRandomNumberGenerator>
3423 __generate(_ForwardIterator __f, _ForwardIterator __t,
3424 _UniformRandomNumberGenerator& __urng,
3425 const param_type& __p)
3426 { this->__generate_impl(__f, __t, __urng, __p); }
3428 template<
typename _UniformRandomNumberGenerator>
3431 _UniformRandomNumberGenerator& __urng)
3432 { this->__generate_impl(__f, __t, __urng); }
3434 template<
typename _UniformRandomNumberGenerator>
3437 _UniformRandomNumberGenerator& __urng,
3438 const param_type& __p)
3439 { this->__generate_impl(__f, __t, __urng, __p); }
3449 {
return (__d1._M_param == __d2._M_param
3450 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3462 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3477 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3483 template<
typename _ForwardIterator,
3484 typename _UniformRandomNumberGenerator>
3486 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3487 _UniformRandomNumberGenerator& __urng);
3488 template<
typename _ForwardIterator,
3489 typename _UniformRandomNumberGenerator>
3491 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3492 _UniformRandomNumberGenerator& __urng,
3493 const param_type& __p);
3495 param_type _M_param;
3504 template<
typename _RealType>
3508 {
return !(__d1 == __d2); }
3542 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3551 {
return __p1._M_p == __p2._M_p; }
3555 {
return !(__p1 == __p2); }
3596 {
return _M_param.p(); }
3603 {
return _M_param; }
3611 { _M_param = __param; }
3630 template<
typename _UniformRandomNumberGenerator>
3633 {
return this->
operator()(__urng, _M_param); }
3635 template<
typename _UniformRandomNumberGenerator>
3637 operator()(_UniformRandomNumberGenerator& __urng,
3638 const param_type& __p)
3640 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3642 if ((__aurng() - __aurng.min())
3643 < __p.p() * (__aurng.max() - __aurng.min()))
3648 template<
typename _ForwardIterator,
3649 typename _UniformRandomNumberGenerator>
3651 __generate(_ForwardIterator __f, _ForwardIterator __t,
3652 _UniformRandomNumberGenerator& __urng)
3653 { this->__generate(__f, __t, __urng, _M_param); }
3655 template<
typename _ForwardIterator,
3656 typename _UniformRandomNumberGenerator>
3658 __generate(_ForwardIterator __f, _ForwardIterator __t,
3659 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3660 { this->__generate_impl(__f, __t, __urng, __p); }
3662 template<
typename _UniformRandomNumberGenerator>
3665 _UniformRandomNumberGenerator& __urng,
3666 const param_type& __p)
3667 { this->__generate_impl(__f, __t, __urng, __p); }
3676 {
return __d1._M_param == __d2._M_param; }
3679 template<
typename _ForwardIterator,
3680 typename _UniformRandomNumberGenerator>
3682 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3683 _UniformRandomNumberGenerator& __urng,
3684 const param_type& __p);
3686 param_type _M_param;
3696 {
return !(__d1 == __d2); }
3708 template<
typename _CharT,
typename _Traits>
3722 template<
typename _CharT,
typename _Traits>
3741 template<
typename _IntType =
int>
3745 "result_type must be an integral type");
3761 : _M_t(__t), _M_p(__p)
3763 __glibcxx_assert((_M_t >= _IntType(0))
3779 {
return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3783 {
return !(__p1 == __p2); }
3793 #if _GLIBCXX_USE_C99_MATH_TR1
3794 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
3795 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
3806 : _M_param(__t, __p), _M_nd()
3810 binomial_distribution(
const param_type& __p)
3811 : _M_param(__p), _M_nd()
3826 {
return _M_param.t(); }
3833 {
return _M_param.p(); }
3840 {
return _M_param; }
3848 { _M_param = __param; }
3862 {
return _M_param.t(); }
3867 template<
typename _UniformRandomNumberGenerator>
3870 {
return this->
operator()(__urng, _M_param); }
3872 template<
typename _UniformRandomNumberGenerator>
3874 operator()(_UniformRandomNumberGenerator& __urng,
3875 const param_type& __p);
3877 template<
typename _ForwardIterator,
3878 typename _UniformRandomNumberGenerator>
3880 __generate(_ForwardIterator __f, _ForwardIterator __t,
3881 _UniformRandomNumberGenerator& __urng)
3882 { this->__generate(__f, __t, __urng, _M_param); }
3884 template<
typename _ForwardIterator,
3885 typename _UniformRandomNumberGenerator>
3887 __generate(_ForwardIterator __f, _ForwardIterator __t,
3888 _UniformRandomNumberGenerator& __urng,
3889 const param_type& __p)
3890 { this->__generate_impl(__f, __t, __urng, __p); }
3892 template<
typename _UniformRandomNumberGenerator>
3895 _UniformRandomNumberGenerator& __urng,
3896 const param_type& __p)
3897 { this->__generate_impl(__f, __t, __urng, __p); }
3907 #ifdef _GLIBCXX_USE_C99_MATH_TR1
3908 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
3910 {
return __d1._M_param == __d2._M_param; }
3923 template<
typename _IntType1,
3924 typename _CharT,
typename _Traits>
3939 template<
typename _IntType1,
3940 typename _CharT,
typename _Traits>
3946 template<
typename _ForwardIterator,
3947 typename _UniformRandomNumberGenerator>
3949 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3950 _UniformRandomNumberGenerator& __urng,
3951 const param_type& __p);
3953 template<
typename _UniformRandomNumberGenerator>
3955 _M_waiting(_UniformRandomNumberGenerator& __urng,
3956 _IntType __t,
double __q);
3958 param_type _M_param;
3967 template<
typename _IntType>
3971 {
return !(__d1 == __d2); }
3981 template<
typename _IntType =
int>
3985 "result_type must be an integral type");
4003 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4013 {
return __p1._M_p == __p2._M_p; }
4017 {
return !(__p1 == __p2); }
4022 { _M_log_1_p =
std::log(1.0 - _M_p); }
4039 geometric_distribution(
const param_type& __p)
4056 {
return _M_param.p(); }
4063 {
return _M_param; }
4071 { _M_param = __param; }
4090 template<
typename _UniformRandomNumberGenerator>
4093 {
return this->
operator()(__urng, _M_param); }
4095 template<
typename _UniformRandomNumberGenerator>
4097 operator()(_UniformRandomNumberGenerator& __urng,
4098 const param_type& __p);
4100 template<
typename _ForwardIterator,
4101 typename _UniformRandomNumberGenerator>
4103 __generate(_ForwardIterator __f, _ForwardIterator __t,
4104 _UniformRandomNumberGenerator& __urng)
4105 { this->__generate(__f, __t, __urng, _M_param); }
4107 template<
typename _ForwardIterator,
4108 typename _UniformRandomNumberGenerator>
4110 __generate(_ForwardIterator __f, _ForwardIterator __t,
4111 _UniformRandomNumberGenerator& __urng,
4112 const param_type& __p)
4113 { this->__generate_impl(__f, __t, __urng, __p); }
4115 template<
typename _UniformRandomNumberGenerator>
4118 _UniformRandomNumberGenerator& __urng,
4119 const param_type& __p)
4120 { this->__generate_impl(__f, __t, __urng, __p); }
4129 {
return __d1._M_param == __d2._M_param; }
4132 template<
typename _ForwardIterator,
4133 typename _UniformRandomNumberGenerator>
4135 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4136 _UniformRandomNumberGenerator& __urng,
4137 const param_type& __p);
4139 param_type _M_param;
4146 template<
typename _IntType>
4150 {
return !(__d1 == __d2); }
4162 template<
typename _IntType,
4163 typename _CharT,
typename _Traits>
4177 template<
typename _IntType,
4178 typename _CharT,
typename _Traits>
4191 template<
typename _IntType =
int>
4195 "result_type must be an integral type");
4210 : _M_k(__k), _M_p(__p)
4212 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4225 {
return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4229 {
return !(__p1 == __p2); }
4240 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4244 negative_binomial_distribution(
const param_type& __p)
4245 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4260 {
return _M_param.k(); }
4267 {
return _M_param.p(); }
4274 {
return _M_param; }
4282 { _M_param = __param; }
4301 template<
typename _UniformRandomNumberGenerator>
4303 operator()(_UniformRandomNumberGenerator& __urng);
4305 template<
typename _UniformRandomNumberGenerator>
4307 operator()(_UniformRandomNumberGenerator& __urng,
4308 const param_type& __p);
4310 template<
typename _ForwardIterator,
4311 typename _UniformRandomNumberGenerator>
4313 __generate(_ForwardIterator __f, _ForwardIterator __t,
4314 _UniformRandomNumberGenerator& __urng)
4315 { this->__generate_impl(__f, __t, __urng); }
4317 template<
typename _ForwardIterator,
4318 typename _UniformRandomNumberGenerator>
4320 __generate(_ForwardIterator __f, _ForwardIterator __t,
4321 _UniformRandomNumberGenerator& __urng,
4322 const param_type& __p)
4323 { this->__generate_impl(__f, __t, __urng, __p); }
4325 template<
typename _UniformRandomNumberGenerator>
4328 _UniformRandomNumberGenerator& __urng)
4329 { this->__generate_impl(__f, __t, __urng); }
4331 template<
typename _UniformRandomNumberGenerator>
4334 _UniformRandomNumberGenerator& __urng,
4335 const param_type& __p)
4336 { this->__generate_impl(__f, __t, __urng, __p); }
4346 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4359 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4374 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4380 template<
typename _ForwardIterator,
4381 typename _UniformRandomNumberGenerator>
4383 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4384 _UniformRandomNumberGenerator& __urng);
4385 template<
typename _ForwardIterator,
4386 typename _UniformRandomNumberGenerator>
4388 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4389 _UniformRandomNumberGenerator& __urng,
4390 const param_type& __p);
4392 param_type _M_param;
4400 template<
typename _IntType>
4404 {
return !(__d1 == __d2); }
4422 template<
typename _IntType =
int>
4426 "result_type must be an integral type");
4444 __glibcxx_assert(_M_mean > 0.0);
4454 {
return __p1._M_mean == __p2._M_mean; }
4458 {
return !(__p1 == __p2); }
4468 #if _GLIBCXX_USE_C99_MATH_TR1
4469 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4479 : _M_param(__mean), _M_nd()
4483 poisson_distribution(
const param_type& __p)
4484 : _M_param(__p), _M_nd()
4499 {
return _M_param.mean(); }
4506 {
return _M_param; }
4514 { _M_param = __param; }
4533 template<
typename _UniformRandomNumberGenerator>
4536 {
return this->
operator()(__urng, _M_param); }
4538 template<
typename _UniformRandomNumberGenerator>
4540 operator()(_UniformRandomNumberGenerator& __urng,
4541 const param_type& __p);
4543 template<
typename _ForwardIterator,
4544 typename _UniformRandomNumberGenerator>
4546 __generate(_ForwardIterator __f, _ForwardIterator __t,
4547 _UniformRandomNumberGenerator& __urng)
4548 { this->__generate(__f, __t, __urng, _M_param); }
4550 template<
typename _ForwardIterator,
4551 typename _UniformRandomNumberGenerator>
4553 __generate(_ForwardIterator __f, _ForwardIterator __t,
4554 _UniformRandomNumberGenerator& __urng,
4555 const param_type& __p)
4556 { this->__generate_impl(__f, __t, __urng, __p); }
4558 template<
typename _UniformRandomNumberGenerator>
4561 _UniformRandomNumberGenerator& __urng,
4562 const param_type& __p)
4563 { this->__generate_impl(__f, __t, __urng, __p); }
4573 #ifdef _GLIBCXX_USE_C99_MATH_TR1
4574 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4576 {
return __d1._M_param == __d2._M_param; }
4589 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4604 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4610 template<
typename _ForwardIterator,
4611 typename _UniformRandomNumberGenerator>
4613 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4614 _UniformRandomNumberGenerator& __urng,
4615 const param_type& __p);
4617 param_type _M_param;
4626 template<
typename _IntType>
4630 {
return !(__d1 == __d2); }
4648 template<
typename _RealType =
double>
4652 "result_type must be a floating point type");
4667 : _M_lambda(__lambda)
4669 __glibcxx_assert(_M_lambda > _RealType(0));
4674 {
return _M_lambda; }
4678 {
return __p1._M_lambda == __p2._M_lambda; }
4682 {
return !(__p1 == __p2); }
4685 _RealType _M_lambda;
4701 : _M_param(__lambda)
4722 {
return _M_param.lambda(); }
4729 {
return _M_param; }
4737 { _M_param = __param; }
4756 template<
typename _UniformRandomNumberGenerator>
4759 {
return this->
operator()(__urng, _M_param); }
4761 template<
typename _UniformRandomNumberGenerator>
4763 operator()(_UniformRandomNumberGenerator& __urng,
4764 const param_type& __p)
4766 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4771 template<
typename _ForwardIterator,
4772 typename _UniformRandomNumberGenerator>
4774 __generate(_ForwardIterator __f, _ForwardIterator __t,
4775 _UniformRandomNumberGenerator& __urng)
4776 { this->__generate(__f, __t, __urng, _M_param); }
4778 template<
typename _ForwardIterator,
4779 typename _UniformRandomNumberGenerator>
4781 __generate(_ForwardIterator __f, _ForwardIterator __t,
4782 _UniformRandomNumberGenerator& __urng,
4783 const param_type& __p)
4784 { this->__generate_impl(__f, __t, __urng, __p); }
4786 template<
typename _UniformRandomNumberGenerator>
4789 _UniformRandomNumberGenerator& __urng,
4790 const param_type& __p)
4791 { this->__generate_impl(__f, __t, __urng, __p); }
4800 {
return __d1._M_param == __d2._M_param; }
4803 template<
typename _ForwardIterator,
4804 typename _UniformRandomNumberGenerator>
4806 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4807 _UniformRandomNumberGenerator& __urng,
4808 const param_type& __p);
4810 param_type _M_param;
4817 template<
typename _RealType>
4821 {
return !(__d1 == __d2); }
4833 template<
typename _RealType,
typename _CharT,
typename _Traits>
4848 template<
typename _RealType,
typename _CharT,
typename _Traits>
4863 template<
typename _RealType =
double>
4867 "result_type must be a floating point type");
4881 param_type(_RealType __a, _RealType __b = _RealType(1.0))
4882 : _M_a(__a), _M_b(__b)
4895 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
4899 {
return !(__p1 == __p2); }
4910 : _M_param(__a, __b)
4914 weibull_distribution(
const param_type& __p)
4930 {
return _M_param.a(); }
4937 {
return _M_param.b(); }
4944 {
return _M_param; }
4952 { _M_param = __param; }
4971 template<
typename _UniformRandomNumberGenerator>
4974 {
return this->
operator()(__urng, _M_param); }
4976 template<
typename _UniformRandomNumberGenerator>
4978 operator()(_UniformRandomNumberGenerator& __urng,
4979 const param_type& __p);
4981 template<
typename _ForwardIterator,
4982 typename _UniformRandomNumberGenerator>
4984 __generate(_ForwardIterator __f, _ForwardIterator __t,
4985 _UniformRandomNumberGenerator& __urng)
4986 { this->__generate(__f, __t, __urng, _M_param); }
4988 template<
typename _ForwardIterator,
4989 typename _UniformRandomNumberGenerator>
4991 __generate(_ForwardIterator __f, _ForwardIterator __t,
4992 _UniformRandomNumberGenerator& __urng,
4993 const param_type& __p)
4994 { this->__generate_impl(__f, __t, __urng, __p); }
4996 template<
typename _UniformRandomNumberGenerator>
4999 _UniformRandomNumberGenerator& __urng,
5000 const param_type& __p)
5001 { this->__generate_impl(__f, __t, __urng, __p); }
5010 {
return __d1._M_param == __d2._M_param; }
5013 template<
typename _ForwardIterator,
5014 typename _UniformRandomNumberGenerator>
5016 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5017 _UniformRandomNumberGenerator& __urng,
5018 const param_type& __p);
5020 param_type _M_param;
5027 template<
typename _RealType>
5031 {
return !(__d1 == __d2); }
5043 template<
typename _RealType,
typename _CharT,
typename _Traits>
5058 template<
typename _RealType,
typename _CharT,
typename _Traits>
5073 template<
typename _RealType =
double>
5077 "result_type must be a floating point type");
5091 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5092 : _M_a(__a), _M_b(__b)
5105 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5109 {
return !(__p1 == __p2); }
5120 : _M_param(__a, __b)
5124 extreme_value_distribution(
const param_type& __p)
5140 {
return _M_param.a(); }
5147 {
return _M_param.b(); }
5154 {
return _M_param; }
5162 { _M_param = __param; }
5181 template<
typename _UniformRandomNumberGenerator>
5184 {
return this->
operator()(__urng, _M_param); }
5186 template<
typename _UniformRandomNumberGenerator>
5188 operator()(_UniformRandomNumberGenerator& __urng,
5189 const param_type& __p);
5191 template<
typename _ForwardIterator,
5192 typename _UniformRandomNumberGenerator>
5194 __generate(_ForwardIterator __f, _ForwardIterator __t,
5195 _UniformRandomNumberGenerator& __urng)
5196 { this->__generate(__f, __t, __urng, _M_param); }
5198 template<
typename _ForwardIterator,
5199 typename _UniformRandomNumberGenerator>
5201 __generate(_ForwardIterator __f, _ForwardIterator __t,
5202 _UniformRandomNumberGenerator& __urng,
5203 const param_type& __p)
5204 { this->__generate_impl(__f, __t, __urng, __p); }
5206 template<
typename _UniformRandomNumberGenerator>
5209 _UniformRandomNumberGenerator& __urng,
5210 const param_type& __p)
5211 { this->__generate_impl(__f, __t, __urng, __p); }
5220 {
return __d1._M_param == __d2._M_param; }
5223 template<
typename _ForwardIterator,
5224 typename _UniformRandomNumberGenerator>
5226 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5227 _UniformRandomNumberGenerator& __urng,
5228 const param_type& __p);
5230 param_type _M_param;
5237 template<
typename _RealType>
5241 {
return !(__d1 == __d2); }
5253 template<
typename _RealType,
typename _CharT,
typename _Traits>
5268 template<
typename _RealType,
typename _CharT,
typename _Traits>
5280 template<
typename _IntType =
int>
5284 "result_type must be an integral type");
5297 : _M_prob(), _M_cp()
5300 template<
typename _InputIterator>
5302 _InputIterator __wend)
5303 : _M_prob(__wbegin, __wend), _M_cp()
5304 { _M_initialize(); }
5307 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5308 { _M_initialize(); }
5310 template<
typename _Func>
5311 param_type(
size_t __nw,
double __xmin,
double __xmax,
5319 probabilities()
const
5324 {
return __p1._M_prob == __p2._M_prob; }
5328 {
return !(__p1 == __p2); }
5342 template<
typename _InputIterator>
5344 _InputIterator __wend)
5345 : _M_param(__wbegin, __wend)
5348 discrete_distribution(initializer_list<double> __wl)
5352 template<
typename _Func>
5353 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5355 : _M_param(__nw, __xmin, __xmax, __fw)
5359 discrete_distribution(
const param_type& __p)
5376 return _M_param._M_prob.
empty()
5385 {
return _M_param; }
5393 { _M_param = __param; }
5408 return _M_param._M_prob.
empty()
5415 template<
typename _UniformRandomNumberGenerator>
5418 {
return this->
operator()(__urng, _M_param); }
5420 template<
typename _UniformRandomNumberGenerator>
5422 operator()(_UniformRandomNumberGenerator& __urng,
5423 const param_type& __p);
5425 template<
typename _ForwardIterator,
5426 typename _UniformRandomNumberGenerator>
5428 __generate(_ForwardIterator __f, _ForwardIterator __t,
5429 _UniformRandomNumberGenerator& __urng)
5430 { this->__generate(__f, __t, __urng, _M_param); }
5432 template<
typename _ForwardIterator,
5433 typename _UniformRandomNumberGenerator>
5435 __generate(_ForwardIterator __f, _ForwardIterator __t,
5436 _UniformRandomNumberGenerator& __urng,
5437 const param_type& __p)
5438 { this->__generate_impl(__f, __t, __urng, __p); }
5440 template<
typename _UniformRandomNumberGenerator>
5443 _UniformRandomNumberGenerator& __urng,
5444 const param_type& __p)
5445 { this->__generate_impl(__f, __t, __urng, __p); }
5454 {
return __d1._M_param == __d2._M_param; }
5466 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5482 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5488 template<
typename _ForwardIterator,
5489 typename _UniformRandomNumberGenerator>
5491 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5492 _UniformRandomNumberGenerator& __urng,
5493 const param_type& __p);
5495 param_type _M_param;
5502 template<
typename _IntType>
5506 {
return !(__d1 == __d2); }
5515 template<
typename _RealType =
double>
5519 "result_type must be a floating point type");
5532 : _M_int(), _M_den(), _M_cp()
5535 template<
typename _InputIteratorB,
typename _InputIteratorW>
5537 _InputIteratorB __bend,
5538 _InputIteratorW __wbegin);
5540 template<
typename _Func>
5543 template<
typename _Func>
5544 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5557 __tmp[1] = _RealType(1);
5570 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5574 {
return !(__p1 == __p2); }
5589 template<
typename _InputIteratorB,
typename _InputIteratorW>
5591 _InputIteratorB __bend,
5592 _InputIteratorW __wbegin)
5593 : _M_param(__bfirst, __bend, __wbegin)
5596 template<
typename _Func>
5597 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5599 : _M_param(__bl, __fw)
5602 template<
typename _Func>
5603 piecewise_constant_distribution(
size_t __nw,
5604 _RealType __xmin, _RealType __xmax,
5606 : _M_param(__nw, __xmin, __xmax, __fw)
5610 piecewise_constant_distribution(
const param_type& __p)
5627 if (_M_param._M_int.
empty())
5630 __tmp[1] = _RealType(1);
5634 return _M_param._M_int;
5643 return _M_param._M_den.
empty()
5652 {
return _M_param; }
5660 { _M_param = __param; }
5668 return _M_param._M_int.
empty()
5678 return _M_param._M_int.
empty()
5685 template<
typename _UniformRandomNumberGenerator>
5688 {
return this->
operator()(__urng, _M_param); }
5690 template<
typename _UniformRandomNumberGenerator>
5692 operator()(_UniformRandomNumberGenerator& __urng,
5693 const param_type& __p);
5695 template<
typename _ForwardIterator,
5696 typename _UniformRandomNumberGenerator>
5698 __generate(_ForwardIterator __f, _ForwardIterator __t,
5699 _UniformRandomNumberGenerator& __urng)
5700 { this->__generate(__f, __t, __urng, _M_param); }
5702 template<
typename _ForwardIterator,
5703 typename _UniformRandomNumberGenerator>
5705 __generate(_ForwardIterator __f, _ForwardIterator __t,
5706 _UniformRandomNumberGenerator& __urng,
5707 const param_type& __p)
5708 { this->__generate_impl(__f, __t, __urng, __p); }
5710 template<
typename _UniformRandomNumberGenerator>
5713 _UniformRandomNumberGenerator& __urng,
5714 const param_type& __p)
5715 { this->__generate_impl(__f, __t, __urng, __p); }
5724 {
return __d1._M_param == __d2._M_param; }
5737 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5753 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5759 template<
typename _ForwardIterator,
5760 typename _UniformRandomNumberGenerator>
5762 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5763 _UniformRandomNumberGenerator& __urng,
5764 const param_type& __p);
5766 param_type _M_param;
5773 template<
typename _RealType>
5777 {
return !(__d1 == __d2); }
5786 template<
typename _RealType =
double>
5790 "result_type must be a floating point type");
5803 : _M_int(), _M_den(), _M_cp(), _M_m()
5806 template<
typename _InputIteratorB,
typename _InputIteratorW>
5808 _InputIteratorB __bend,
5809 _InputIteratorW __wbegin);
5811 template<
typename _Func>
5814 template<
typename _Func>
5815 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5828 __tmp[1] = _RealType(1);
5841 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5845 {
return !(__p1 == __p2); }
5861 template<
typename _InputIteratorB,
typename _InputIteratorW>
5863 _InputIteratorB __bend,
5864 _InputIteratorW __wbegin)
5865 : _M_param(__bfirst, __bend, __wbegin)
5868 template<
typename _Func>
5869 piecewise_linear_distribution(initializer_list<_RealType> __bl,
5871 : _M_param(__bl, __fw)
5874 template<
typename _Func>
5875 piecewise_linear_distribution(
size_t __nw,
5876 _RealType __xmin, _RealType __xmax,
5878 : _M_param(__nw, __xmin, __xmax, __fw)
5882 piecewise_linear_distribution(
const param_type& __p)
5899 if (_M_param._M_int.
empty())
5902 __tmp[1] = _RealType(1);
5906 return _M_param._M_int;
5916 return _M_param._M_den.
empty()
5925 {
return _M_param; }
5933 { _M_param = __param; }
5941 return _M_param._M_int.
empty()
5951 return _M_param._M_int.
empty()
5958 template<
typename _UniformRandomNumberGenerator>
5961 {
return this->
operator()(__urng, _M_param); }
5963 template<
typename _UniformRandomNumberGenerator>
5965 operator()(_UniformRandomNumberGenerator& __urng,
5966 const param_type& __p);
5968 template<
typename _ForwardIterator,
5969 typename _UniformRandomNumberGenerator>
5971 __generate(_ForwardIterator __f, _ForwardIterator __t,
5972 _UniformRandomNumberGenerator& __urng)
5973 { this->__generate(__f, __t, __urng, _M_param); }
5975 template<
typename _ForwardIterator,
5976 typename _UniformRandomNumberGenerator>
5978 __generate(_ForwardIterator __f, _ForwardIterator __t,
5979 _UniformRandomNumberGenerator& __urng,
5980 const param_type& __p)
5981 { this->__generate_impl(__f, __t, __urng, __p); }
5983 template<
typename _UniformRandomNumberGenerator>
5986 _UniformRandomNumberGenerator& __urng,
5987 const param_type& __p)
5988 { this->__generate_impl(__f, __t, __urng, __p); }
5997 {
return __d1._M_param == __d2._M_param; }
6010 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6026 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6032 template<
typename _ForwardIterator,
6033 typename _UniformRandomNumberGenerator>
6035 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6036 _UniformRandomNumberGenerator& __urng,
6037 const param_type& __p);
6039 param_type _M_param;
6046 template<
typename _RealType>
6050 {
return !(__d1 == __d2); }
6078 template<
typename _IntType>
6081 template<
typename _InputIterator>
6082 seed_seq(_InputIterator __begin, _InputIterator __end);
6085 template<
typename _RandomAccessIterator>
6087 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6090 size_t size() const noexcept
6091 {
return _M_v.
size(); }
6093 template<
typename _OutputIterator>
6095 param(_OutputIterator __dest)
const
6096 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
6110 _GLIBCXX_END_NAMESPACE_VERSION