36 namespace std _GLIBCXX_VISIBILITY(default)
38 _GLIBCXX_BEGIN_NAMESPACE_VERSION
55 template<
typename _RealType,
size_t __bits,
56 typename _UniformRandomNumberGenerator>
60 _GLIBCXX_END_NAMESPACE_VERSION
67 _GLIBCXX_BEGIN_NAMESPACE_VERSION
69 template<
typename _UIntType,
size_t __w,
70 bool = __w < static_cast<size_t>
73 {
static const _UIntType __value = 0; };
75 template<
typename _UIntType,
size_t __w>
76 struct _Shift<_UIntType, __w, true>
77 {
static const _UIntType __value = _UIntType(1) << __w; };
80 int __which = ((__s <= __CHAR_BIT__ *
sizeof (int))
81 + (__s <= __CHAR_BIT__ *
sizeof (long))
82 + (__s <= __CHAR_BIT__ *
sizeof (
long long))
85 struct _Select_uint_least_t
87 static_assert(__which < 0,
88 "sorry, would be too much trouble for a slow result");
92 struct _Select_uint_least_t<__s, 4>
93 {
typedef unsigned int type; };
96 struct _Select_uint_least_t<__s, 3>
97 {
typedef unsigned long type; };
100 struct _Select_uint_least_t<__s, 2>
101 {
typedef unsigned long long type; };
103 #ifdef _GLIBCXX_USE_INT128
105 struct _Select_uint_least_t<__s, 1>
106 {
typedef unsigned __int128 type; };
110 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
111 bool __big_enough = (!(__m & (__m - 1))
112 || (_Tp(-1) - __c) / __a >= __m - 1),
113 bool __schrage_ok = __m % __a < __m / __a>
116 typedef typename _Select_uint_least_t<
std::__lg(__a)
120 {
return static_cast<_Tp
>((_Tp2(__a) * __x + __c) % __m); }
124 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
125 struct _Mod<_Tp, __m, __a, __c, false, true>
134 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
135 struct _Mod<_Tp, __m, __a, __c, true, __s>
140 _Tp __res = __a * __x + __c;
147 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
150 {
return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
153 template<
typename _Tp>
157 return ((__x - 1) & __x) == 0;
164 template<
typename _Engine,
typename _DInputType>
169 _Adaptor(_Engine& __g)
174 {
return _DInputType(0); }
178 {
return _DInputType(1); }
197 _GLIBCXX_END_NAMESPACE_VERSION
200 _GLIBCXX_BEGIN_NAMESPACE_VERSION
240 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
244 "substituting _UIntType not an unsigned integral type");
245 static_assert(__m == 0u || (__a < __m && __c < __m),
246 "template argument substituting __m out of bounds");
277 template<
typename _Sseq,
typename =
typename
300 template<
typename _Sseq>
312 {
return __c == 0u ? 1u : 0u; }
327 for (; __z != 0ULL; --__z)
337 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
355 {
return __lhs._M_x == __rhs._M_x; }
365 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
366 _UIntType1 __m1,
typename _CharT,
typename _Traits>
368 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
370 __a1, __c1, __m1>& __lcr);
385 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
386 _UIntType1 __m1,
typename _CharT,
typename _Traits>
407 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
413 {
return !(__lhs == __rhs); }
444 template<
typename _UIntType,
size_t __w,
445 size_t __n,
size_t __m,
size_t __r,
446 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
447 _UIntType __b,
size_t __t,
448 _UIntType __c,
size_t __l, _UIntType __f>
452 "substituting _UIntType not an unsigned integral type");
453 static_assert(1u <= __m && __m <= __n,
454 "template argument substituting __m out of bounds");
455 static_assert(__r <= __w,
"template argument substituting "
457 static_assert(__u <= __w,
"template argument substituting "
459 static_assert(__s <= __w,
"template argument substituting "
461 static_assert(__t <= __w,
"template argument substituting "
463 static_assert(__l <= __w,
"template argument substituting "
466 "template argument substituting __w out of bound");
467 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
468 "template argument substituting __a out of bound");
469 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
470 "template argument substituting __b out of bound");
471 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
472 "template argument substituting __c out of bound");
473 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
474 "template argument substituting __d out of bound");
475 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
476 "template argument substituting __f out of bound");
483 static constexpr
size_t word_size = __w;
484 static constexpr
size_t state_size = __n;
485 static constexpr
size_t shift_size = __m;
486 static constexpr
size_t mask_bits = __r;
488 static constexpr
size_t tempering_u = __u;
490 static constexpr
size_t tempering_s = __s;
492 static constexpr
size_t tempering_t = __t;
494 static constexpr
size_t tempering_l = __l;
495 static constexpr
result_type initialization_multiplier = __f;
509 template<
typename _Sseq,
typename =
typename
519 template<
typename _Sseq>
535 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
541 discard(
unsigned long long __z);
561 {
return (
std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
562 && __lhs._M_p == __rhs._M_p); }
576 template<
typename _UIntType1,
577 size_t __w1,
size_t __n1,
578 size_t __m1,
size_t __r1,
579 _UIntType1 __a1,
size_t __u1,
580 _UIntType1 __d1,
size_t __s1,
581 _UIntType1 __b1,
size_t __t1,
582 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
583 typename _CharT,
typename _Traits>
585 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
587 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
602 template<
typename _UIntType1,
603 size_t __w1,
size_t __n1,
604 size_t __m1,
size_t __r1,
605 _UIntType1 __a1,
size_t __u1,
606 _UIntType1 __d1,
size_t __s1,
607 _UIntType1 __b1,
size_t __t1,
608 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
609 typename _CharT,
typename _Traits>
613 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
619 _UIntType _M_x[state_size];
635 template<
typename _UIntType,
size_t __w,
636 size_t __n,
size_t __m,
size_t __r,
637 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
638 _UIntType __b,
size_t __t,
639 _UIntType __c,
size_t __l, _UIntType __f>
642 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
644 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
645 {
return !(__lhs == __rhs); }
667 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
668 class subtract_with_carry_engine
671 "substituting _UIntType not an unsigned integral type");
672 static_assert(0u < __s && __s < __r,
673 "template argument substituting __s out of bounds");
675 "template argument substituting __w out of bounds");
679 typedef _UIntType result_type;
682 static constexpr
size_t word_size = __w;
683 static constexpr
size_t short_lag = __s;
684 static constexpr
size_t long_lag = __r;
685 static constexpr result_type default_seed = 19780503u;
692 subtract_with_carry_engine(result_type __sd = default_seed)
701 template<
typename _Sseq,
typename =
typename
705 subtract_with_carry_engine(_Sseq& __q)
721 seed(result_type __sd = default_seed);
727 template<
typename _Sseq>
735 static constexpr result_type
743 static constexpr result_type
745 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
751 discard(
unsigned long long __z)
753 for (; __z != 0ULL; --__z)
776 operator==(
const subtract_with_carry_engine& __lhs,
777 const subtract_with_carry_engine& __rhs)
778 {
return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
779 && __lhs._M_carry == __rhs._M_carry
780 && __lhs._M_p == __rhs._M_p); }
794 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
795 typename _CharT,
typename _Traits>
797 operator<<(std::basic_ostream<_CharT, _Traits>&,
798 const std::subtract_with_carry_engine<_UIntType1, __w1,
813 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
814 typename _CharT,
typename _Traits>
817 std::subtract_with_carry_engine<_UIntType1, __w1,
821 _UIntType _M_x[long_lag];
838 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
840 operator!=(
const std::subtract_with_carry_engine<_UIntType, __w,
842 const std::subtract_with_carry_engine<_UIntType, __w,
844 {
return !(__lhs == __rhs); }
853 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
856 static_assert(1 <= __r && __r <= __p,
857 "template argument substituting __r out of bounds");
861 typedef typename _RandomNumberEngine::result_type
result_type;
864 static constexpr
size_t block_size = __p;
865 static constexpr
size_t used_block = __r;
873 : _M_b(), _M_n(0) { }
883 : _M_b(__rng), _M_n(0) { }
893 : _M_b(std::move(__rng)), _M_n(0) { }
903 : _M_b(__s), _M_n(0) { }
910 template<
typename _Sseq,
typename =
typename
946 template<
typename _Sseq>
958 const _RandomNumberEngine&
982 for (; __z != 0ULL; --__z)
1006 {
return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1019 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1020 typename _CharT,
typename _Traits>
1022 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1037 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1038 typename _CharT,
typename _Traits>
1045 _RandomNumberEngine _M_b;
1060 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1066 {
return !(__lhs == __rhs); }
1073 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1077 "substituting _UIntType not an unsigned integral type");
1079 "template argument substituting __w out of bounds");
1111 : _M_b(std::move(__rng)) { }
1128 template<
typename _Sseq,
typename =
typename
1158 template<
typename _Sseq>
1167 const _RandomNumberEngine&
1183 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1191 for (; __z != 0ULL; --__z)
1216 {
return __lhs._M_b == __rhs._M_b; }
1230 template<
typename _CharT,
typename _Traits>
1234 __w, _UIntType>& __x)
1241 _RandomNumberEngine _M_b;
1256 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1262 {
return !(__lhs == __rhs); }
1274 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1275 typename _CharT,
typename _Traits>
1277 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1279 __w, _UIntType>& __x)
1291 template<
typename _RandomNumberEngine,
size_t __k>
1294 static_assert(1u <= __k,
"template argument substituting "
1295 "__k out of bound");
1299 typedef typename _RandomNumberEngine::result_type
result_type;
1301 static constexpr
size_t table_size = __k;
1310 { _M_initialize(); }
1321 { _M_initialize(); }
1331 : _M_b(std::move(__rng))
1332 { _M_initialize(); }
1343 { _M_initialize(); }
1350 template<
typename _Sseq,
typename =
typename
1357 { _M_initialize(); }
1386 template<
typename _Sseq>
1397 const _RandomNumberEngine&
1421 for (; __z != 0ULL; --__z)
1445 {
return (__lhs._M_b == __rhs._M_b
1446 &&
std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1447 && __lhs._M_y == __rhs._M_y); }
1460 template<
typename _RandomNumberEngine1,
size_t __k1,
1461 typename _CharT,
typename _Traits>
1463 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1478 template<
typename _RandomNumberEngine1,
size_t __k1,
1479 typename _CharT,
typename _Traits>
1485 void _M_initialize()
1487 for (
size_t __i = 0; __i < __k; ++__i)
1492 _RandomNumberEngine _M_b;
1508 template<
typename _RandomNumberEngine,
size_t __k>
1514 {
return !(__lhs == __rhs); }
1520 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1551 0xb5026f5aa96619e9ULL, 29,
1552 0x5555555555555555ULL, 17,
1553 0x71d67fffeda60000ULL, 37,
1554 0xfff7eee000000000ULL, 43,
1557 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
1560 typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
1583 #ifdef _GLIBCXX_USE_RANDOM_TR1
1597 random_device(
const std::string& __token =
"mt19937")
1598 { _M_init_pretr1(__token); }
1613 entropy() const noexcept
1619 #ifdef _GLIBCXX_USE_RANDOM_TR1
1620 return this->_M_getval();
1622 return this->_M_getval_pretr1();
1627 random_device(
const random_device&) =
delete;
1628 void operator=(
const random_device&) =
delete;
1665 template<
typename _IntType =
int>
1669 "template argument not an integral type");
1682 : _M_a(__a), _M_b(__b)
1684 _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
1697 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1711 : _M_param(__a, __b)
1729 {
return _M_param.a(); }
1733 {
return _M_param.b(); }
1740 {
return _M_param; }
1748 { _M_param = __param; }
1755 {
return this->a(); }
1762 {
return this->b(); }
1767 template<
typename _UniformRandomNumberGenerator>
1770 {
return this->
operator()(__urng, _M_param); }
1772 template<
typename _UniformRandomNumberGenerator>
1774 operator()(_UniformRandomNumberGenerator& __urng,
1775 const param_type& __p);
1777 template<
typename _ForwardIterator,
1778 typename _UniformRandomNumberGenerator>
1780 __generate(_ForwardIterator __f, _ForwardIterator __t,
1781 _UniformRandomNumberGenerator& __urng)
1782 { this->__generate(__f, __t, __urng, _M_param); }
1784 template<
typename _ForwardIterator,
1785 typename _UniformRandomNumberGenerator>
1787 __generate(_ForwardIterator __f, _ForwardIterator __t,
1788 _UniformRandomNumberGenerator& __urng,
1789 const param_type& __p)
1790 { this->__generate_impl(__f, __t, __urng, __p); }
1792 template<
typename _UniformRandomNumberGenerator>
1795 _UniformRandomNumberGenerator& __urng,
1796 const param_type& __p)
1797 { this->__generate_impl(__f, __t, __urng, __p); }
1806 {
return __d1._M_param == __d2._M_param; }
1809 template<
typename _ForwardIterator,
1810 typename _UniformRandomNumberGenerator>
1812 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1813 _UniformRandomNumberGenerator& __urng,
1814 const param_type& __p);
1816 param_type _M_param;
1823 template<
typename _IntType>
1827 {
return !(__d1 == __d2); }
1839 template<
typename _IntType,
typename _CharT,
typename _Traits>
1841 operator<<(std::basic_ostream<_CharT, _Traits>&,
1853 template<
typename _IntType,
typename _CharT,
typename _Traits>
1866 template<
typename _RealType =
double>
1870 "template argument not a floating point type");
1882 _RealType __b = _RealType(1))
1883 : _M_a(__a), _M_b(__b)
1885 _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
1898 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1914 _RealType __b = _RealType(1))
1915 : _M_param(__a, __b)
1933 {
return _M_param.a(); }
1937 {
return _M_param.b(); }
1944 {
return _M_param; }
1952 { _M_param = __param; }
1959 {
return this->a(); }
1966 {
return this->b(); }
1971 template<
typename _UniformRandomNumberGenerator>
1974 {
return this->
operator()(__urng, _M_param); }
1976 template<
typename _UniformRandomNumberGenerator>
1978 operator()(_UniformRandomNumberGenerator& __urng,
1979 const param_type& __p)
1981 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1983 return (__aurng() * (__p.b() - __p.a())) + __p.a();
1986 template<
typename _ForwardIterator,
1987 typename _UniformRandomNumberGenerator>
1989 __generate(_ForwardIterator __f, _ForwardIterator __t,
1990 _UniformRandomNumberGenerator& __urng)
1991 { this->__generate(__f, __t, __urng, _M_param); }
1993 template<
typename _ForwardIterator,
1994 typename _UniformRandomNumberGenerator>
1996 __generate(_ForwardIterator __f, _ForwardIterator __t,
1997 _UniformRandomNumberGenerator& __urng,
1998 const param_type& __p)
1999 { this->__generate_impl(__f, __t, __urng, __p); }
2001 template<
typename _UniformRandomNumberGenerator>
2004 _UniformRandomNumberGenerator& __urng,
2005 const param_type& __p)
2006 { this->__generate_impl(__f, __t, __urng, __p); }
2015 {
return __d1._M_param == __d2._M_param; }
2018 template<
typename _ForwardIterator,
2019 typename _UniformRandomNumberGenerator>
2021 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2022 _UniformRandomNumberGenerator& __urng,
2023 const param_type& __p);
2025 param_type _M_param;
2032 template<
typename _IntType>
2036 {
return !(__d1 == __d2); }
2048 template<
typename _RealType,
typename _CharT,
typename _Traits>
2050 operator<<(std::basic_ostream<_CharT, _Traits>&,
2062 template<
typename _RealType,
typename _CharT,
typename _Traits>
2084 template<
typename _RealType =
double>
2088 "template argument not a floating point type");
2100 _RealType __stddev = _RealType(1))
2101 : _M_mean(__mean), _M_stddev(__stddev)
2103 _GLIBCXX_DEBUG_ASSERT(_M_stddev > _RealType(0));
2112 {
return _M_stddev; }
2116 {
return (__p1._M_mean == __p2._M_mean
2117 && __p1._M_stddev == __p2._M_stddev); }
2121 _RealType _M_stddev;
2132 : _M_param(__mean, __stddev), _M_saved_available(false)
2137 : _M_param(__p), _M_saved_available(false)
2145 { _M_saved_available =
false; }
2152 {
return _M_param.mean(); }
2159 {
return _M_param.stddev(); }
2166 {
return _M_param; }
2174 { _M_param = __param; }
2193 template<
typename _UniformRandomNumberGenerator>
2196 {
return this->
operator()(__urng, _M_param); }
2198 template<
typename _UniformRandomNumberGenerator>
2200 operator()(_UniformRandomNumberGenerator& __urng,
2201 const param_type& __p);
2203 template<
typename _ForwardIterator,
2204 typename _UniformRandomNumberGenerator>
2206 __generate(_ForwardIterator __f, _ForwardIterator __t,
2207 _UniformRandomNumberGenerator& __urng)
2208 { this->__generate(__f, __t, __urng, _M_param); }
2210 template<
typename _ForwardIterator,
2211 typename _UniformRandomNumberGenerator>
2213 __generate(_ForwardIterator __f, _ForwardIterator __t,
2214 _UniformRandomNumberGenerator& __urng,
2215 const param_type& __p)
2216 { this->__generate_impl(__f, __t, __urng, __p); }
2218 template<
typename _UniformRandomNumberGenerator>
2221 _UniformRandomNumberGenerator& __urng,
2222 const param_type& __p)
2223 { this->__generate_impl(__f, __t, __urng, __p); }
2230 template<
typename _RealType1>
2245 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2247 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2260 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2266 template<
typename _ForwardIterator,
2267 typename _UniformRandomNumberGenerator>
2269 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2270 _UniformRandomNumberGenerator& __urng,
2271 const param_type& __p);
2273 param_type _M_param;
2275 bool _M_saved_available;
2281 template<
typename _RealType>
2285 {
return !(__d1 == __d2); }
2297 template<
typename _RealType =
double>
2301 "template argument not a floating point type");
2313 _RealType __s = _RealType(1))
2314 : _M_m(__m), _M_s(__s)
2327 {
return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2336 _RealType __s = _RealType(1))
2337 : _M_param(__m, __s), _M_nd()
2342 : _M_param(__p), _M_nd()
2357 {
return _M_param.m(); }
2361 {
return _M_param.s(); }
2368 {
return _M_param; }
2376 { _M_param = __param; }
2395 template<
typename _UniformRandomNumberGenerator>
2398 {
return this->
operator()(__urng, _M_param); }
2400 template<
typename _UniformRandomNumberGenerator>
2402 operator()(_UniformRandomNumberGenerator& __urng,
2403 const param_type& __p)
2404 {
return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2406 template<
typename _ForwardIterator,
2407 typename _UniformRandomNumberGenerator>
2409 __generate(_ForwardIterator __f, _ForwardIterator __t,
2410 _UniformRandomNumberGenerator& __urng)
2411 { this->__generate(__f, __t, __urng, _M_param); }
2413 template<
typename _ForwardIterator,
2414 typename _UniformRandomNumberGenerator>
2416 __generate(_ForwardIterator __f, _ForwardIterator __t,
2417 _UniformRandomNumberGenerator& __urng,
2418 const param_type& __p)
2419 { this->__generate_impl(__f, __t, __urng, __p); }
2421 template<
typename _UniformRandomNumberGenerator>
2424 _UniformRandomNumberGenerator& __urng,
2425 const param_type& __p)
2426 { this->__generate_impl(__f, __t, __urng, __p); }
2436 {
return (__d1._M_param == __d2._M_param
2437 && __d1._M_nd == __d2._M_nd); }
2449 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2451 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2464 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2470 template<
typename _ForwardIterator,
2471 typename _UniformRandomNumberGenerator>
2473 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2474 _UniformRandomNumberGenerator& __urng,
2475 const param_type& __p);
2477 param_type _M_param;
2485 template<
typename _RealType>
2489 {
return !(__d1 == __d2); }
2501 template<
typename _RealType =
double>
2505 "template argument not a floating point type");
2517 param_type(_RealType __alpha_val = _RealType(1),
2518 _RealType __beta_val = _RealType(1))
2519 : _M_alpha(__alpha_val), _M_beta(__beta_val)
2521 _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
2527 {
return _M_alpha; }
2534 operator==(
const param_type& __p1,
const param_type& __p2)
2535 {
return (__p1._M_alpha == __p2._M_alpha
2536 && __p1._M_beta == __p2._M_beta); }
2545 _RealType _M_malpha, _M_a2;
2555 _RealType __beta_val = _RealType(1))
2556 : _M_param(__alpha_val, __beta_val), _M_nd()
2561 : _M_param(__p), _M_nd()
2576 {
return _M_param.alpha(); }
2583 {
return _M_param.beta(); }
2590 {
return _M_param; }
2598 { _M_param = __param; }
2617 template<
typename _UniformRandomNumberGenerator>
2620 {
return this->
operator()(__urng, _M_param); }
2622 template<
typename _UniformRandomNumberGenerator>
2624 operator()(_UniformRandomNumberGenerator& __urng,
2625 const param_type& __p);
2627 template<
typename _ForwardIterator,
2628 typename _UniformRandomNumberGenerator>
2630 __generate(_ForwardIterator __f, _ForwardIterator __t,
2631 _UniformRandomNumberGenerator& __urng)
2632 { this->__generate(__f, __t, __urng, _M_param); }
2634 template<
typename _ForwardIterator,
2635 typename _UniformRandomNumberGenerator>
2637 __generate(_ForwardIterator __f, _ForwardIterator __t,
2638 _UniformRandomNumberGenerator& __urng,
2639 const param_type& __p)
2640 { this->__generate_impl(__f, __t, __urng, __p); }
2642 template<
typename _UniformRandomNumberGenerator>
2645 _UniformRandomNumberGenerator& __urng,
2646 const param_type& __p)
2647 { this->__generate_impl(__f, __t, __urng, __p); }
2657 {
return (__d1._M_param == __d2._M_param
2658 && __d1._M_nd == __d2._M_nd); }
2670 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2672 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2684 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2690 template<
typename _ForwardIterator,
2691 typename _UniformRandomNumberGenerator>
2693 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2694 _UniformRandomNumberGenerator& __urng,
2695 const param_type& __p);
2697 param_type _M_param;
2705 template<
typename _RealType>
2709 {
return !(__d1 == __d2); }
2718 template<
typename _RealType =
double>
2722 "template argument not a floating point type");
2743 {
return __p1._M_n == __p2._M_n; }
2751 : _M_param(__n), _M_gd(__n / 2)
2756 : _M_param(__p), _M_gd(__p.n() / 2)
2771 {
return _M_param.n(); }
2778 {
return _M_param; }
2786 { _M_param = __param; }
2805 template<
typename _UniformRandomNumberGenerator>
2808 {
return 2 * _M_gd(__urng); }
2810 template<
typename _UniformRandomNumberGenerator>
2812 operator()(_UniformRandomNumberGenerator& __urng,
2813 const param_type& __p)
2817 return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2820 template<
typename _ForwardIterator,
2821 typename _UniformRandomNumberGenerator>
2823 __generate(_ForwardIterator __f, _ForwardIterator __t,
2824 _UniformRandomNumberGenerator& __urng)
2825 { this->__generate_impl(__f, __t, __urng); }
2827 template<
typename _ForwardIterator,
2828 typename _UniformRandomNumberGenerator>
2830 __generate(_ForwardIterator __f, _ForwardIterator __t,
2831 _UniformRandomNumberGenerator& __urng,
2832 const param_type& __p)
2835 this->__generate_impl(__f, __t, __urng, __p2); }
2837 template<
typename _UniformRandomNumberGenerator>
2840 _UniformRandomNumberGenerator& __urng)
2841 { this->__generate_impl(__f, __t, __urng); }
2843 template<
typename _UniformRandomNumberGenerator>
2846 _UniformRandomNumberGenerator& __urng,
2847 const param_type& __p)
2850 this->__generate_impl(__f, __t, __urng, __p2); }
2860 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2872 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2874 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2887 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2893 template<
typename _ForwardIterator,
2894 typename _UniformRandomNumberGenerator>
2896 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2897 _UniformRandomNumberGenerator& __urng);
2899 template<
typename _ForwardIterator,
2900 typename _UniformRandomNumberGenerator>
2902 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2903 _UniformRandomNumberGenerator& __urng,
2907 param_type _M_param;
2915 template<
typename _RealType>
2919 {
return !(__d1 == __d2); }
2928 template<
typename _RealType =
double>
2932 "template argument not a floating point type");
2943 param_type(_RealType __a = _RealType(0),
2944 _RealType __b = _RealType(1))
2945 : _M_a(__a), _M_b(__b)
2957 operator==(
const param_type& __p1,
const param_type& __p2)
2958 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
2967 _RealType __b = _RealType(1))
2968 : _M_param(__a, __b)
2988 {
return _M_param.a(); }
2992 {
return _M_param.b(); }
2999 {
return _M_param; }
3007 { _M_param = __param; }
3026 template<
typename _UniformRandomNumberGenerator>
3029 {
return this->
operator()(__urng, _M_param); }
3031 template<
typename _UniformRandomNumberGenerator>
3033 operator()(_UniformRandomNumberGenerator& __urng,
3034 const param_type& __p);
3036 template<
typename _ForwardIterator,
3037 typename _UniformRandomNumberGenerator>
3039 __generate(_ForwardIterator __f, _ForwardIterator __t,
3040 _UniformRandomNumberGenerator& __urng)
3041 { this->__generate(__f, __t, __urng, _M_param); }
3043 template<
typename _ForwardIterator,
3044 typename _UniformRandomNumberGenerator>
3046 __generate(_ForwardIterator __f, _ForwardIterator __t,
3047 _UniformRandomNumberGenerator& __urng,
3048 const param_type& __p)
3049 { this->__generate_impl(__f, __t, __urng, __p); }
3051 template<
typename _UniformRandomNumberGenerator>
3054 _UniformRandomNumberGenerator& __urng,
3055 const param_type& __p)
3056 { this->__generate_impl(__f, __t, __urng, __p); }
3065 {
return __d1._M_param == __d2._M_param; }
3068 template<
typename _ForwardIterator,
3069 typename _UniformRandomNumberGenerator>
3071 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3072 _UniformRandomNumberGenerator& __urng,
3073 const param_type& __p);
3075 param_type _M_param;
3082 template<
typename _RealType>
3086 {
return !(__d1 == __d2); }
3098 template<
typename _RealType,
typename _CharT,
typename _Traits>
3100 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3113 template<
typename _RealType,
typename _CharT,
typename _Traits>
3129 template<
typename _RealType =
double>
3133 "template argument not a floating point type");
3144 param_type(_RealType __m = _RealType(1),
3145 _RealType __n = _RealType(1))
3146 : _M_m(__m), _M_n(__n)
3158 operator==(
const param_type& __p1,
const param_type& __p2)
3159 {
return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3168 _RealType __n = _RealType(1))
3169 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3174 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3192 {
return _M_param.m(); }
3196 {
return _M_param.n(); }
3203 {
return _M_param; }
3211 { _M_param = __param; }
3230 template<
typename _UniformRandomNumberGenerator>
3233 {
return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3235 template<
typename _UniformRandomNumberGenerator>
3237 operator()(_UniformRandomNumberGenerator& __urng,
3238 const param_type& __p)
3242 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3243 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3246 template<
typename _ForwardIterator,
3247 typename _UniformRandomNumberGenerator>
3249 __generate(_ForwardIterator __f, _ForwardIterator __t,
3250 _UniformRandomNumberGenerator& __urng)
3251 { this->__generate_impl(__f, __t, __urng); }
3253 template<
typename _ForwardIterator,
3254 typename _UniformRandomNumberGenerator>
3256 __generate(_ForwardIterator __f, _ForwardIterator __t,
3257 _UniformRandomNumberGenerator& __urng,
3258 const param_type& __p)
3259 { this->__generate_impl(__f, __t, __urng, __p); }
3261 template<
typename _UniformRandomNumberGenerator>
3264 _UniformRandomNumberGenerator& __urng)
3265 { this->__generate_impl(__f, __t, __urng); }
3267 template<
typename _UniformRandomNumberGenerator>
3270 _UniformRandomNumberGenerator& __urng,
3271 const param_type& __p)
3272 { this->__generate_impl(__f, __t, __urng, __p); }
3282 {
return (__d1._M_param == __d2._M_param
3283 && __d1._M_gd_x == __d2._M_gd_x
3284 && __d1._M_gd_y == __d2._M_gd_y); }
3296 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3298 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3311 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3317 template<
typename _ForwardIterator,
3318 typename _UniformRandomNumberGenerator>
3320 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3321 _UniformRandomNumberGenerator& __urng);
3323 template<
typename _ForwardIterator,
3324 typename _UniformRandomNumberGenerator>
3326 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3327 _UniformRandomNumberGenerator& __urng,
3328 const param_type& __p);
3330 param_type _M_param;
3338 template<
typename _RealType>
3342 {
return !(__d1 == __d2); }
3353 template<
typename _RealType =
double>
3357 "template argument not a floating point type");
3368 param_type(_RealType __n = _RealType(1))
3377 operator==(
const param_type& __p1,
const param_type& __p2)
3378 {
return __p1._M_n == __p2._M_n; }
3386 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3391 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3409 {
return _M_param.n(); }
3416 {
return _M_param; }
3424 { _M_param = __param; }
3443 template<
typename _UniformRandomNumberGenerator>
3446 {
return _M_nd(__urng) *
std::sqrt(n() / _M_gd(__urng)); }
3448 template<
typename _UniformRandomNumberGenerator>
3450 operator()(_UniformRandomNumberGenerator& __urng,
3451 const param_type& __p)
3456 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3457 return _M_nd(__urng) *
std::sqrt(__p.n() / __g);
3460 template<
typename _ForwardIterator,
3461 typename _UniformRandomNumberGenerator>
3463 __generate(_ForwardIterator __f, _ForwardIterator __t,
3464 _UniformRandomNumberGenerator& __urng)
3465 { this->__generate_impl(__f, __t, __urng); }
3467 template<
typename _ForwardIterator,
3468 typename _UniformRandomNumberGenerator>
3470 __generate(_ForwardIterator __f, _ForwardIterator __t,
3471 _UniformRandomNumberGenerator& __urng,
3472 const param_type& __p)
3473 { this->__generate_impl(__f, __t, __urng, __p); }
3475 template<
typename _UniformRandomNumberGenerator>
3478 _UniformRandomNumberGenerator& __urng)
3479 { this->__generate_impl(__f, __t, __urng); }
3481 template<
typename _UniformRandomNumberGenerator>
3484 _UniformRandomNumberGenerator& __urng,
3485 const param_type& __p)
3486 { this->__generate_impl(__f, __t, __urng, __p); }
3496 {
return (__d1._M_param == __d2._M_param
3497 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3509 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3511 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3524 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3530 template<
typename _ForwardIterator,
3531 typename _UniformRandomNumberGenerator>
3533 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3534 _UniformRandomNumberGenerator& __urng);
3535 template<
typename _ForwardIterator,
3536 typename _UniformRandomNumberGenerator>
3538 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3539 _UniformRandomNumberGenerator& __urng,
3540 const param_type& __p);
3542 param_type _M_param;
3551 template<
typename _RealType>
3555 {
return !(__d1 == __d2); }
3583 param_type(
double __p = 0.5)
3586 _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
3594 operator==(
const param_type& __p1,
const param_type& __p2)
3595 {
return __p1._M_p == __p2._M_p; }
3631 {
return _M_param.p(); }
3638 {
return _M_param; }
3646 { _M_param = __param; }
3665 template<
typename _UniformRandomNumberGenerator>
3668 {
return this->
operator()(__urng, _M_param); }
3670 template<
typename _UniformRandomNumberGenerator>
3672 operator()(_UniformRandomNumberGenerator& __urng,
3673 const param_type& __p)
3675 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3677 if ((__aurng() - __aurng.min())
3678 < __p.p() * (__aurng.max() - __aurng.min()))
3683 template<
typename _ForwardIterator,
3684 typename _UniformRandomNumberGenerator>
3686 __generate(_ForwardIterator __f, _ForwardIterator __t,
3687 _UniformRandomNumberGenerator& __urng)
3688 { this->__generate(__f, __t, __urng, _M_param); }
3690 template<
typename _ForwardIterator,
3691 typename _UniformRandomNumberGenerator>
3693 __generate(_ForwardIterator __f, _ForwardIterator __t,
3694 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3695 { this->__generate_impl(__f, __t, __urng, __p); }
3697 template<
typename _UniformRandomNumberGenerator>
3700 _UniformRandomNumberGenerator& __urng,
3701 const param_type& __p)
3702 { this->__generate_impl(__f, __t, __urng, __p); }
3711 {
return __d1._M_param == __d2._M_param; }
3714 template<
typename _ForwardIterator,
3715 typename _UniformRandomNumberGenerator>
3717 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3718 _UniformRandomNumberGenerator& __urng,
3719 const param_type& __p);
3721 param_type _M_param;
3731 {
return !(__d1 == __d2); }
3743 template<
typename _CharT,
typename _Traits>
3745 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3757 template<
typename _CharT,
typename _Traits>
3776 template<
typename _IntType =
int>
3780 "template argument not an integral type");
3792 param_type(_IntType __t = _IntType(1),
double __p = 0.5)
3793 : _M_t(__t), _M_p(__p)
3795 _GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0))
3810 operator==(
const param_type& __p1,
const param_type& __p2)
3811 {
return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3821 #if _GLIBCXX_USE_C99_MATH_TR1
3822 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
3823 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
3832 : _M_param(__t, __p), _M_nd()
3837 : _M_param(__p), _M_nd()
3852 {
return _M_param.t(); }
3859 {
return _M_param.p(); }
3866 {
return _M_param; }
3874 { _M_param = __param; }
3888 {
return _M_param.t(); }
3893 template<
typename _UniformRandomNumberGenerator>
3896 {
return this->
operator()(__urng, _M_param); }
3898 template<
typename _UniformRandomNumberGenerator>
3900 operator()(_UniformRandomNumberGenerator& __urng,
3901 const param_type& __p);
3903 template<
typename _ForwardIterator,
3904 typename _UniformRandomNumberGenerator>
3906 __generate(_ForwardIterator __f, _ForwardIterator __t,
3907 _UniformRandomNumberGenerator& __urng)
3908 { this->__generate(__f, __t, __urng, _M_param); }
3910 template<
typename _ForwardIterator,
3911 typename _UniformRandomNumberGenerator>
3913 __generate(_ForwardIterator __f, _ForwardIterator __t,
3914 _UniformRandomNumberGenerator& __urng,
3915 const param_type& __p)
3916 { this->__generate_impl(__f, __t, __urng, __p); }
3918 template<
typename _UniformRandomNumberGenerator>
3921 _UniformRandomNumberGenerator& __urng,
3922 const param_type& __p)
3923 { this->__generate_impl(__f, __t, __urng, __p); }
3933 #ifdef _GLIBCXX_USE_C99_MATH_TR1
3934 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
3936 {
return __d1._M_param == __d2._M_param; }
3949 template<
typename _IntType1,
3950 typename _CharT,
typename _Traits>
3952 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3965 template<
typename _IntType1,
3966 typename _CharT,
typename _Traits>
3972 template<
typename _ForwardIterator,
3973 typename _UniformRandomNumberGenerator>
3975 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3976 _UniformRandomNumberGenerator& __urng,
3977 const param_type& __p);
3979 template<
typename _UniformRandomNumberGenerator>
3981 _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
3983 param_type _M_param;
3992 template<
typename _IntType>
3996 {
return !(__d1 == __d2); }
4006 template<
typename _IntType =
int>
4010 "template argument not an integral type");
4022 param_type(
double __p = 0.5)
4025 _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
4034 operator==(
const param_type& __p1,
const param_type& __p2)
4035 {
return __p1._M_p == __p2._M_p; }
4040 { _M_log_1_p =
std::log(1.0 - _M_p); }
4071 {
return _M_param.p(); }
4078 {
return _M_param; }
4086 { _M_param = __param; }
4105 template<
typename _UniformRandomNumberGenerator>
4108 {
return this->
operator()(__urng, _M_param); }
4110 template<
typename _UniformRandomNumberGenerator>
4112 operator()(_UniformRandomNumberGenerator& __urng,
4113 const param_type& __p);
4115 template<
typename _ForwardIterator,
4116 typename _UniformRandomNumberGenerator>
4118 __generate(_ForwardIterator __f, _ForwardIterator __t,
4119 _UniformRandomNumberGenerator& __urng)
4120 { this->__generate(__f, __t, __urng, _M_param); }
4122 template<
typename _ForwardIterator,
4123 typename _UniformRandomNumberGenerator>
4125 __generate(_ForwardIterator __f, _ForwardIterator __t,
4126 _UniformRandomNumberGenerator& __urng,
4127 const param_type& __p)
4128 { this->__generate_impl(__f, __t, __urng, __p); }
4130 template<
typename _UniformRandomNumberGenerator>
4133 _UniformRandomNumberGenerator& __urng,
4134 const param_type& __p)
4135 { this->__generate_impl(__f, __t, __urng, __p); }
4144 {
return __d1._M_param == __d2._M_param; }
4147 template<
typename _ForwardIterator,
4148 typename _UniformRandomNumberGenerator>
4150 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4151 _UniformRandomNumberGenerator& __urng,
4152 const param_type& __p);
4154 param_type _M_param;
4161 template<
typename _IntType>
4165 {
return !(__d1 == __d2); }
4177 template<
typename _IntType,
4178 typename _CharT,
typename _Traits>
4180 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4192 template<
typename _IntType,
4193 typename _CharT,
typename _Traits>
4206 template<
typename _IntType =
int>
4210 "template argument not an integral type");
4221 param_type(_IntType __k = 1,
double __p = 0.5)
4222 : _M_k(__k), _M_p(__p)
4224 _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4236 operator==(
const param_type& __p1,
const param_type& __p2)
4237 {
return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4246 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4251 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4266 {
return _M_param.k(); }
4273 {
return _M_param.p(); }
4280 {
return _M_param; }
4288 { _M_param = __param; }
4307 template<
typename _UniformRandomNumberGenerator>
4309 operator()(_UniformRandomNumberGenerator& __urng);
4311 template<
typename _UniformRandomNumberGenerator>
4313 operator()(_UniformRandomNumberGenerator& __urng,
4314 const param_type& __p);
4316 template<
typename _ForwardIterator,
4317 typename _UniformRandomNumberGenerator>
4319 __generate(_ForwardIterator __f, _ForwardIterator __t,
4320 _UniformRandomNumberGenerator& __urng)
4321 { this->__generate_impl(__f, __t, __urng); }
4323 template<
typename _ForwardIterator,
4324 typename _UniformRandomNumberGenerator>
4326 __generate(_ForwardIterator __f, _ForwardIterator __t,
4327 _UniformRandomNumberGenerator& __urng,
4328 const param_type& __p)
4329 { this->__generate_impl(__f, __t, __urng, __p); }
4331 template<
typename _UniformRandomNumberGenerator>
4334 _UniformRandomNumberGenerator& __urng)
4335 { this->__generate_impl(__f, __t, __urng); }
4337 template<
typename _UniformRandomNumberGenerator>
4340 _UniformRandomNumberGenerator& __urng,
4341 const param_type& __p)
4342 { this->__generate_impl(__f, __t, __urng, __p); }
4352 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4365 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4367 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4380 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4386 template<
typename _ForwardIterator,
4387 typename _UniformRandomNumberGenerator>
4389 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4390 _UniformRandomNumberGenerator& __urng);
4391 template<
typename _ForwardIterator,
4392 typename _UniformRandomNumberGenerator>
4394 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4395 _UniformRandomNumberGenerator& __urng,
4396 const param_type& __p);
4398 param_type _M_param;
4406 template<
typename _IntType>
4410 {
return !(__d1 == __d2); }
4428 template<
typename _IntType =
int>
4432 "template argument not an integral type");
4444 param_type(
double __mean = 1.0)
4447 _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
4456 operator==(
const param_type& __p1,
const param_type& __p2)
4457 {
return __p1._M_mean == __p2._M_mean; }
4467 #if _GLIBCXX_USE_C99_MATH_TR1
4468 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4475 : _M_param(__mean), _M_nd()
4480 : _M_param(__p), _M_nd()
4495 {
return _M_param.mean(); }
4502 {
return _M_param; }
4510 { _M_param = __param; }
4529 template<
typename _UniformRandomNumberGenerator>
4532 {
return this->
operator()(__urng, _M_param); }
4534 template<
typename _UniformRandomNumberGenerator>
4536 operator()(_UniformRandomNumberGenerator& __urng,
4537 const param_type& __p);
4539 template<
typename _ForwardIterator,
4540 typename _UniformRandomNumberGenerator>
4542 __generate(_ForwardIterator __f, _ForwardIterator __t,
4543 _UniformRandomNumberGenerator& __urng)
4544 { this->__generate(__f, __t, __urng, _M_param); }
4546 template<
typename _ForwardIterator,
4547 typename _UniformRandomNumberGenerator>
4549 __generate(_ForwardIterator __f, _ForwardIterator __t,
4550 _UniformRandomNumberGenerator& __urng,
4551 const param_type& __p)
4552 { this->__generate_impl(__f, __t, __urng, __p); }
4554 template<
typename _UniformRandomNumberGenerator>
4557 _UniformRandomNumberGenerator& __urng,
4558 const param_type& __p)
4559 { this->__generate_impl(__f, __t, __urng, __p); }
4569 #ifdef _GLIBCXX_USE_C99_MATH_TR1
4570 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4572 {
return __d1._M_param == __d2._M_param; }
4585 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4587 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4600 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4606 template<
typename _ForwardIterator,
4607 typename _UniformRandomNumberGenerator>
4609 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4610 _UniformRandomNumberGenerator& __urng,
4611 const param_type& __p);
4613 param_type _M_param;
4622 template<
typename _IntType>
4626 {
return !(__d1 == __d2); }
4644 template<
typename _RealType =
double>
4648 "template argument not a floating point type");
4659 param_type(_RealType __lambda = _RealType(1))
4660 : _M_lambda(__lambda)
4662 _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0));
4667 {
return _M_lambda; }
4670 operator==(
const param_type& __p1,
const param_type& __p2)
4671 {
return __p1._M_lambda == __p2._M_lambda; }
4674 _RealType _M_lambda;
4684 : _M_param(__lambda)
4705 {
return _M_param.lambda(); }
4712 {
return _M_param; }
4720 { _M_param = __param; }
4739 template<
typename _UniformRandomNumberGenerator>
4742 {
return this->
operator()(__urng, _M_param); }
4744 template<
typename _UniformRandomNumberGenerator>
4746 operator()(_UniformRandomNumberGenerator& __urng,
4747 const param_type& __p)
4749 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4754 template<
typename _ForwardIterator,
4755 typename _UniformRandomNumberGenerator>
4757 __generate(_ForwardIterator __f, _ForwardIterator __t,
4758 _UniformRandomNumberGenerator& __urng)
4759 { this->__generate(__f, __t, __urng, _M_param); }
4761 template<
typename _ForwardIterator,
4762 typename _UniformRandomNumberGenerator>
4764 __generate(_ForwardIterator __f, _ForwardIterator __t,
4765 _UniformRandomNumberGenerator& __urng,
4766 const param_type& __p)
4767 { this->__generate_impl(__f, __t, __urng, __p); }
4769 template<
typename _UniformRandomNumberGenerator>
4772 _UniformRandomNumberGenerator& __urng,
4773 const param_type& __p)
4774 { this->__generate_impl(__f, __t, __urng, __p); }
4783 {
return __d1._M_param == __d2._M_param; }
4786 template<
typename _ForwardIterator,
4787 typename _UniformRandomNumberGenerator>
4789 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4790 _UniformRandomNumberGenerator& __urng,
4791 const param_type& __p);
4793 param_type _M_param;
4800 template<
typename _RealType>
4804 {
return !(__d1 == __d2); }
4816 template<
typename _RealType,
typename _CharT,
typename _Traits>
4818 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4831 template<
typename _RealType,
typename _CharT,
typename _Traits>
4846 template<
typename _RealType =
double>
4850 "template argument not a floating point type");
4861 param_type(_RealType __a = _RealType(1),
4862 _RealType __b = _RealType(1))
4863 : _M_a(__a), _M_b(__b)
4875 operator==(
const param_type& __p1,
const param_type& __p2)
4876 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
4885 _RealType __b = _RealType(1))
4886 : _M_param(__a, __b)
4906 {
return _M_param.a(); }
4913 {
return _M_param.b(); }
4920 {
return _M_param; }
4928 { _M_param = __param; }
4947 template<
typename _UniformRandomNumberGenerator>
4950 {
return this->
operator()(__urng, _M_param); }
4952 template<
typename _UniformRandomNumberGenerator>
4954 operator()(_UniformRandomNumberGenerator& __urng,
4955 const param_type& __p);
4957 template<
typename _ForwardIterator,
4958 typename _UniformRandomNumberGenerator>
4960 __generate(_ForwardIterator __f, _ForwardIterator __t,
4961 _UniformRandomNumberGenerator& __urng)
4962 { this->__generate(__f, __t, __urng, _M_param); }
4964 template<
typename _ForwardIterator,
4965 typename _UniformRandomNumberGenerator>
4967 __generate(_ForwardIterator __f, _ForwardIterator __t,
4968 _UniformRandomNumberGenerator& __urng,
4969 const param_type& __p)
4970 { this->__generate_impl(__f, __t, __urng, __p); }
4972 template<
typename _UniformRandomNumberGenerator>
4975 _UniformRandomNumberGenerator& __urng,
4976 const param_type& __p)
4977 { this->__generate_impl(__f, __t, __urng, __p); }
4986 {
return __d1._M_param == __d2._M_param; }
4989 template<
typename _ForwardIterator,
4990 typename _UniformRandomNumberGenerator>
4992 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4993 _UniformRandomNumberGenerator& __urng,
4994 const param_type& __p);
4996 param_type _M_param;
5003 template<
typename _RealType>
5007 {
return !(__d1 == __d2); }
5019 template<
typename _RealType,
typename _CharT,
typename _Traits>
5021 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5034 template<
typename _RealType,
typename _CharT,
typename _Traits>
5049 template<
typename _RealType =
double>
5053 "template argument not a floating point type");
5064 param_type(_RealType __a = _RealType(0),
5065 _RealType __b = _RealType(1))
5066 : _M_a(__a), _M_b(__b)
5078 operator==(
const param_type& __p1,
const param_type& __p2)
5079 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5088 _RealType __b = _RealType(1))
5089 : _M_param(__a, __b)
5109 {
return _M_param.a(); }
5116 {
return _M_param.b(); }
5123 {
return _M_param; }
5131 { _M_param = __param; }
5150 template<
typename _UniformRandomNumberGenerator>
5153 {
return this->
operator()(__urng, _M_param); }
5155 template<
typename _UniformRandomNumberGenerator>
5157 operator()(_UniformRandomNumberGenerator& __urng,
5158 const param_type& __p);
5160 template<
typename _ForwardIterator,
5161 typename _UniformRandomNumberGenerator>
5163 __generate(_ForwardIterator __f, _ForwardIterator __t,
5164 _UniformRandomNumberGenerator& __urng)
5165 { this->__generate(__f, __t, __urng, _M_param); }
5167 template<
typename _ForwardIterator,
5168 typename _UniformRandomNumberGenerator>
5170 __generate(_ForwardIterator __f, _ForwardIterator __t,
5171 _UniformRandomNumberGenerator& __urng,
5172 const param_type& __p)
5173 { this->__generate_impl(__f, __t, __urng, __p); }
5175 template<
typename _UniformRandomNumberGenerator>
5178 _UniformRandomNumberGenerator& __urng,
5179 const param_type& __p)
5180 { this->__generate_impl(__f, __t, __urng, __p); }
5189 {
return __d1._M_param == __d2._M_param; }
5192 template<
typename _ForwardIterator,
5193 typename _UniformRandomNumberGenerator>
5195 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5196 _UniformRandomNumberGenerator& __urng,
5197 const param_type& __p);
5199 param_type _M_param;
5206 template<
typename _RealType>
5210 {
return !(__d1 == __d2); }
5222 template<
typename _RealType,
typename _CharT,
typename _Traits>
5224 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5237 template<
typename _RealType,
typename _CharT,
typename _Traits>
5249 template<
typename _IntType =
int>
5253 "template argument not an integral type");
5265 : _M_prob(), _M_cp()
5268 template<
typename _InputIterator>
5269 param_type(_InputIterator __wbegin,
5270 _InputIterator __wend)
5271 : _M_prob(__wbegin, __wend), _M_cp()
5272 { _M_initialize(); }
5275 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5276 { _M_initialize(); }
5278 template<
typename _Func>
5279 param_type(
size_t __nw,
double __xmin,
double __xmax,
5283 param_type(
const param_type&) =
default;
5284 param_type& operator=(
const param_type&) =
default;
5287 probabilities()
const
5291 operator==(
const param_type& __p1,
const param_type& __p2)
5292 {
return __p1._M_prob == __p2._M_prob; }
5306 template<
typename _InputIterator>
5308 _InputIterator __wend)
5309 : _M_param(__wbegin, __wend)
5312 discrete_distribution(initializer_list<double> __wl)
5316 template<
typename _Func>
5317 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5319 : _M_param(__nw, __xmin, __xmax, __fw)
5323 discrete_distribution(
const param_type& __p)
5340 return _M_param._M_prob.
empty()
5349 {
return _M_param; }
5357 { _M_param = __param; }
5372 return _M_param._M_prob.
empty()
5379 template<
typename _UniformRandomNumberGenerator>
5382 {
return this->
operator()(__urng, _M_param); }
5384 template<
typename _UniformRandomNumberGenerator>
5386 operator()(_UniformRandomNumberGenerator& __urng,
5387 const param_type& __p);
5389 template<
typename _ForwardIterator,
5390 typename _UniformRandomNumberGenerator>
5392 __generate(_ForwardIterator __f, _ForwardIterator __t,
5393 _UniformRandomNumberGenerator& __urng)
5394 { this->__generate(__f, __t, __urng, _M_param); }
5396 template<
typename _ForwardIterator,
5397 typename _UniformRandomNumberGenerator>
5399 __generate(_ForwardIterator __f, _ForwardIterator __t,
5400 _UniformRandomNumberGenerator& __urng,
5401 const param_type& __p)
5402 { this->__generate_impl(__f, __t, __urng, __p); }
5404 template<
typename _UniformRandomNumberGenerator>
5407 _UniformRandomNumberGenerator& __urng,
5408 const param_type& __p)
5409 { this->__generate_impl(__f, __t, __urng, __p); }
5418 {
return __d1._M_param == __d2._M_param; }
5430 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5432 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5446 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5452 template<
typename _ForwardIterator,
5453 typename _UniformRandomNumberGenerator>
5455 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5456 _UniformRandomNumberGenerator& __urng,
5457 const param_type& __p);
5459 param_type _M_param;
5466 template<
typename _IntType>
5470 {
return !(__d1 == __d2); }
5479 template<
typename _RealType =
double>
5483 "template argument not a floating point type");
5495 : _M_int(), _M_den(), _M_cp()
5498 template<
typename _InputIteratorB,
typename _InputIteratorW>
5499 param_type(_InputIteratorB __bfirst,
5500 _InputIteratorB __bend,
5501 _InputIteratorW __wbegin);
5503 template<
typename _Func>
5506 template<
typename _Func>
5507 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5511 param_type(
const param_type&) =
default;
5512 param_type& operator=(
const param_type&) =
default;
5520 __tmp[1] = _RealType(1);
5532 operator==(
const param_type& __p1,
const param_type& __p2)
5533 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5549 template<
typename _InputIteratorB,
typename _InputIteratorW>
5551 _InputIteratorB __bend,
5552 _InputIteratorW __wbegin)
5553 : _M_param(__bfirst, __bend, __wbegin)
5556 template<
typename _Func>
5557 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5559 : _M_param(__bl, __fw)
5562 template<
typename _Func>
5563 piecewise_constant_distribution(
size_t __nw,
5564 _RealType __xmin, _RealType __xmax,
5566 : _M_param(__nw, __xmin, __xmax, __fw)
5570 piecewise_constant_distribution(
const param_type& __p)
5587 if (_M_param._M_int.
empty())
5590 __tmp[1] = _RealType(1);
5594 return _M_param._M_int;
5603 return _M_param._M_den.
empty()
5612 {
return _M_param; }
5620 { _M_param = __param; }
5628 return _M_param._M_int.
empty()
5638 return _M_param._M_int.
empty()
5645 template<
typename _UniformRandomNumberGenerator>
5648 {
return this->
operator()(__urng, _M_param); }
5650 template<
typename _UniformRandomNumberGenerator>
5652 operator()(_UniformRandomNumberGenerator& __urng,
5653 const param_type& __p);
5655 template<
typename _ForwardIterator,
5656 typename _UniformRandomNumberGenerator>
5658 __generate(_ForwardIterator __f, _ForwardIterator __t,
5659 _UniformRandomNumberGenerator& __urng)
5660 { this->__generate(__f, __t, __urng, _M_param); }
5662 template<
typename _ForwardIterator,
5663 typename _UniformRandomNumberGenerator>
5665 __generate(_ForwardIterator __f, _ForwardIterator __t,
5666 _UniformRandomNumberGenerator& __urng,
5667 const param_type& __p)
5668 { this->__generate_impl(__f, __t, __urng, __p); }
5670 template<
typename _UniformRandomNumberGenerator>
5673 _UniformRandomNumberGenerator& __urng,
5674 const param_type& __p)
5675 { this->__generate_impl(__f, __t, __urng, __p); }
5684 {
return __d1._M_param == __d2._M_param; }
5697 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5699 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5713 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5719 template<
typename _ForwardIterator,
5720 typename _UniformRandomNumberGenerator>
5722 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5723 _UniformRandomNumberGenerator& __urng,
5724 const param_type& __p);
5726 param_type _M_param;
5733 template<
typename _RealType>
5737 {
return !(__d1 == __d2); }
5746 template<
typename _RealType =
double>
5750 "template argument not a floating point type");
5762 : _M_int(), _M_den(), _M_cp(), _M_m()
5765 template<
typename _InputIteratorB,
typename _InputIteratorW>
5766 param_type(_InputIteratorB __bfirst,
5767 _InputIteratorB __bend,
5768 _InputIteratorW __wbegin);
5770 template<
typename _Func>
5773 template<
typename _Func>
5774 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5778 param_type(
const param_type&) =
default;
5779 param_type& operator=(
const param_type&) =
default;
5787 __tmp[1] = _RealType(1);
5799 operator==(
const param_type& __p1,
const param_type& __p2)
5800 {
return (__p1._M_int == __p2._M_int
5801 && __p1._M_den == __p2._M_den); }
5818 template<
typename _InputIteratorB,
typename _InputIteratorW>
5820 _InputIteratorB __bend,
5821 _InputIteratorW __wbegin)
5822 : _M_param(__bfirst, __bend, __wbegin)
5825 template<
typename _Func>
5826 piecewise_linear_distribution(initializer_list<_RealType> __bl,
5828 : _M_param(__bl, __fw)
5831 template<
typename _Func>
5832 piecewise_linear_distribution(
size_t __nw,
5833 _RealType __xmin, _RealType __xmax,
5835 : _M_param(__nw, __xmin, __xmax, __fw)
5839 piecewise_linear_distribution(
const param_type& __p)
5856 if (_M_param._M_int.
empty())
5859 __tmp[1] = _RealType(1);
5863 return _M_param._M_int;
5873 return _M_param._M_den.
empty()
5882 {
return _M_param; }
5890 { _M_param = __param; }
5898 return _M_param._M_int.
empty()
5908 return _M_param._M_int.
empty()
5915 template<
typename _UniformRandomNumberGenerator>
5918 {
return this->
operator()(__urng, _M_param); }
5920 template<
typename _UniformRandomNumberGenerator>
5922 operator()(_UniformRandomNumberGenerator& __urng,
5923 const param_type& __p);
5925 template<
typename _ForwardIterator,
5926 typename _UniformRandomNumberGenerator>
5928 __generate(_ForwardIterator __f, _ForwardIterator __t,
5929 _UniformRandomNumberGenerator& __urng)
5930 { this->__generate(__f, __t, __urng, _M_param); }
5932 template<
typename _ForwardIterator,
5933 typename _UniformRandomNumberGenerator>
5935 __generate(_ForwardIterator __f, _ForwardIterator __t,
5936 _UniformRandomNumberGenerator& __urng,
5937 const param_type& __p)
5938 { this->__generate_impl(__f, __t, __urng, __p); }
5940 template<
typename _UniformRandomNumberGenerator>
5943 _UniformRandomNumberGenerator& __urng,
5944 const param_type& __p)
5945 { this->__generate_impl(__f, __t, __urng, __p); }
5954 {
return __d1._M_param == __d2._M_param; }
5967 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5969 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5983 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5989 template<
typename _ForwardIterator,
5990 typename _UniformRandomNumberGenerator>
5992 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5993 _UniformRandomNumberGenerator& __urng,
5994 const param_type& __p);
5996 param_type _M_param;
6003 template<
typename _RealType>
6007 {
return !(__d1 == __d2); }
6036 template<
typename _IntType>
6039 template<
typename _InputIterator>
6040 seed_seq(_InputIterator __begin, _InputIterator __end);
6043 template<
typename _RandomAccessIterator>
6045 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6049 {
return _M_v.
size(); }
6051 template<
typename OutputIterator>
6053 param(OutputIterator __dest)
const
6054 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
6065 _GLIBCXX_END_NAMESPACE_VERSION