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; };
79 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool>
84 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
87 {
return _Mod<_Tp, __m, __a, __c, __m == 0>::__calc(__x); }
93 template<
typename _Engine,
typename _DInputType>
98 _Adaptor(_Engine& __g)
103 {
return _DInputType(0); }
107 {
return _DInputType(1); }
126 _GLIBCXX_END_NAMESPACE_VERSION
129 _GLIBCXX_BEGIN_NAMESPACE_VERSION
169 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
173 "substituting _UIntType not an unsigned integral type");
174 static_assert(__m == 0u || (__a < __m && __c < __m),
175 "template argument substituting __m out of bounds");
179 static_assert(__m % __a < __m / __a,
180 "sorry, not implemented yet: try a smaller 'a' constant");
211 template<
typename _Sseq,
typename =
typename
234 template<
typename _Sseq>
246 {
return __c == 0u ? 1u : 0u; }
261 for (; __z != 0ULL; --__z)
271 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
289 {
return __lhs._M_x == __rhs._M_x; }
299 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
300 _UIntType1 __m1,
typename _CharT,
typename _Traits>
302 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
304 __a1, __c1, __m1>& __lcr);
319 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
320 _UIntType1 __m1,
typename _CharT,
typename _Traits>
341 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
347 {
return !(__lhs == __rhs); }
378 template<
typename _UIntType,
size_t __w,
379 size_t __n,
size_t __m,
size_t __r,
380 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
381 _UIntType __b,
size_t __t,
382 _UIntType __c,
size_t __l, _UIntType __f>
386 "substituting _UIntType not an unsigned integral type");
387 static_assert(1u <= __m && __m <= __n,
388 "template argument substituting __m out of bounds");
389 static_assert(__r <= __w,
"template argument substituting "
391 static_assert(__u <= __w,
"template argument substituting "
393 static_assert(__s <= __w,
"template argument substituting "
395 static_assert(__t <= __w,
"template argument substituting "
397 static_assert(__l <= __w,
"template argument substituting "
400 "template argument substituting __w out of bound");
401 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
402 "template argument substituting __a out of bound");
403 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
404 "template argument substituting __b out of bound");
405 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
406 "template argument substituting __c out of bound");
407 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
408 "template argument substituting __d out of bound");
409 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
410 "template argument substituting __f out of bound");
417 static constexpr
size_t word_size = __w;
418 static constexpr
size_t state_size = __n;
419 static constexpr
size_t shift_size = __m;
420 static constexpr
size_t mask_bits = __r;
422 static constexpr
size_t tempering_u = __u;
424 static constexpr
size_t tempering_s = __s;
426 static constexpr
size_t tempering_t = __t;
428 static constexpr
size_t tempering_l = __l;
429 static constexpr
result_type initialization_multiplier = __f;
443 template<
typename _Sseq,
typename =
typename
453 template<
typename _Sseq>
469 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
477 for (; __z != 0ULL; --__z)
499 {
return (
std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
500 && __lhs._M_p == __rhs._M_p); }
514 template<
typename _UIntType1,
515 size_t __w1,
size_t __n1,
516 size_t __m1,
size_t __r1,
517 _UIntType1 __a1,
size_t __u1,
518 _UIntType1 __d1,
size_t __s1,
519 _UIntType1 __b1,
size_t __t1,
520 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
521 typename _CharT,
typename _Traits>
523 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
525 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
540 template<
typename _UIntType1,
541 size_t __w1,
size_t __n1,
542 size_t __m1,
size_t __r1,
543 _UIntType1 __a1,
size_t __u1,
544 _UIntType1 __d1,
size_t __s1,
545 _UIntType1 __b1,
size_t __t1,
546 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
547 typename _CharT,
typename _Traits>
551 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
555 _UIntType _M_x[state_size];
571 template<
typename _UIntType,
size_t __w,
572 size_t __n,
size_t __m,
size_t __r,
573 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
574 _UIntType __b,
size_t __t,
575 _UIntType __c,
size_t __l, _UIntType __f>
578 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
580 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
581 {
return !(__lhs == __rhs); }
603 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
604 class subtract_with_carry_engine
607 "substituting _UIntType not an unsigned integral type");
608 static_assert(0u < __s && __s < __r,
609 "template argument substituting __s out of bounds");
611 "template argument substituting __w out of bounds");
615 typedef _UIntType result_type;
618 static constexpr
size_t word_size = __w;
619 static constexpr
size_t short_lag = __s;
620 static constexpr
size_t long_lag = __r;
621 static constexpr result_type default_seed = 19780503u;
628 subtract_with_carry_engine(result_type __sd = default_seed)
637 template<
typename _Sseq,
typename =
typename
641 subtract_with_carry_engine(_Sseq& __q)
657 seed(result_type __sd = default_seed);
663 template<
typename _Sseq>
671 static constexpr result_type
679 static constexpr result_type
681 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
687 discard(
unsigned long long __z)
689 for (; __z != 0ULL; --__z)
712 operator==(
const subtract_with_carry_engine& __lhs,
713 const subtract_with_carry_engine& __rhs)
714 {
return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
715 && __lhs._M_carry == __rhs._M_carry
716 && __lhs._M_p == __rhs._M_p); }
730 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
731 typename _CharT,
typename _Traits>
733 operator<<(std::basic_ostream<_CharT, _Traits>&,
734 const std::subtract_with_carry_engine<_UIntType1, __w1,
749 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
750 typename _CharT,
typename _Traits>
753 std::subtract_with_carry_engine<_UIntType1, __w1,
757 _UIntType _M_x[long_lag];
774 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
776 operator!=(
const std::subtract_with_carry_engine<_UIntType, __w,
778 const std::subtract_with_carry_engine<_UIntType, __w,
780 {
return !(__lhs == __rhs); }
789 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
792 static_assert(1 <= __r && __r <= __p,
793 "template argument substituting __r out of bounds");
800 static constexpr
size_t block_size = __p;
801 static constexpr
size_t used_block = __r;
809 : _M_b(), _M_n(0) { }
819 : _M_b(__rng), _M_n(0) { }
829 : _M_b(std::move(__rng)), _M_n(0) { }
839 : _M_b(__s), _M_n(0) { }
846 template<
typename _Sseq,
typename =
typename
882 template<
typename _Sseq>
894 const _RandomNumberEngine&
918 for (; __z != 0ULL; --__z)
942 {
return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
955 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
956 typename _CharT,
typename _Traits>
958 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
973 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
974 typename _CharT,
typename _Traits>
981 _RandomNumberEngine _M_b;
996 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1002 {
return !(__lhs == __rhs); }
1009 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1013 "substituting _UIntType not an unsigned integral type");
1015 "template argument substituting __w out of bounds");
1047 : _M_b(std::move(__rng)) { }
1064 template<
typename _Sseq,
typename =
typename
1094 template<
typename _Sseq>
1103 const _RandomNumberEngine&
1119 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1127 for (; __z != 0ULL; --__z)
1152 {
return __lhs._M_b == __rhs._M_b; }
1166 template<
typename _CharT,
typename _Traits>
1170 __w, _UIntType>& __x)
1177 _RandomNumberEngine _M_b;
1192 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1198 {
return !(__lhs == __rhs); }
1210 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1211 typename _CharT,
typename _Traits>
1213 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1215 __w, _UIntType>& __x)
1227 template<
typename _RandomNumberEngine,
size_t __k>
1230 static_assert(1u <= __k,
"template argument substituting "
1231 "__k out of bound");
1237 static constexpr
size_t table_size = __k;
1246 { _M_initialize(); }
1257 { _M_initialize(); }
1267 : _M_b(std::move(__rng))
1268 { _M_initialize(); }
1279 { _M_initialize(); }
1286 template<
typename _Sseq,
typename =
typename
1293 { _M_initialize(); }
1322 template<
typename _Sseq>
1333 const _RandomNumberEngine&
1357 for (; __z != 0ULL; --__z)
1381 {
return (__lhs._M_b == __rhs._M_b
1382 &&
std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1383 && __lhs._M_y == __rhs._M_y); }
1396 template<
typename _RandomNumberEngine1,
size_t __k1,
1397 typename _CharT,
typename _Traits>
1399 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1414 template<
typename _RandomNumberEngine1,
size_t __k1,
1415 typename _CharT,
typename _Traits>
1421 void _M_initialize()
1423 for (
size_t __i = 0; __i < __k; ++__i)
1428 _RandomNumberEngine _M_b;
1444 template<
typename _RandomNumberEngine,
size_t __k>
1450 {
return !(__lhs == __rhs); }
1456 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1487 0xb5026f5aa96619e9ULL, 29,
1488 0x5555555555555555ULL, 17,
1489 0x71d67fffeda60000ULL, 37,
1490 0xfff7eee000000000ULL, 43,
1493 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
1496 typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
1519 #ifdef _GLIBCXX_USE_RANDOM_TR1
1524 if ((__token !=
"/dev/urandom" && __token !=
"/dev/random")
1525 || !(_M_file = std::fopen(__token.c_str(),
"rb")))
1526 std::__throw_runtime_error(__N(
"random_device::"
1527 "random_device(const std::string&)"));
1531 { std::fclose(_M_file); }
1536 random_device(
const std::string& __token =
"mt19937")
1537 : _M_mt(_M_strtoul(__token)) { }
1540 static unsigned long
1543 unsigned long __ret = 5489UL;
1544 if (__str !=
"mt19937")
1546 const char* __nptr = __str.
c_str();
1548 __ret = std::strtoul(__nptr, &__endptr, 0);
1549 if (*__nptr ==
'\0' || *__endptr !=
'\0')
1550 std::__throw_runtime_error(__N(
"random_device::_M_strtoul"
1551 "(const std::string&)"));
1569 entropy() const noexcept
1575 #ifdef _GLIBCXX_USE_RANDOM_TR1
1577 std::fread(reinterpret_cast<void*>(&__ret),
sizeof(
result_type),
1586 random_device(
const random_device&) =
delete;
1587 void operator=(
const random_device&) =
delete;
1591 #ifdef _GLIBCXX_USE_RANDOM_TR1
1617 template<
typename _IntType =
int>
1621 "template argument not an integral type");
1634 : _M_a(__a), _M_b(__b)
1636 _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
1649 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1663 : _M_param(__a, __b)
1681 {
return _M_param.a(); }
1685 {
return _M_param.b(); }
1692 {
return _M_param; }
1700 { _M_param = __param; }
1707 {
return this->a(); }
1714 {
return this->b(); }
1719 template<
typename _UniformRandomNumberGenerator>
1724 template<
typename _UniformRandomNumberGenerator>
1726 operator()(_UniformRandomNumberGenerator& __urng,
1727 const param_type& __p);
1729 param_type _M_param;
1736 template<
typename _IntType>
1746 template<
typename _IntType>
1750 {
return !(__d1 == __d2); }
1762 template<
typename _IntType,
typename _CharT,
typename _Traits>
1764 operator<<(std::basic_ostream<_CharT, _Traits>&,
1776 template<
typename _IntType,
typename _CharT,
typename _Traits>
1789 template<
typename _RealType =
double>
1793 "template argument not a floating point type");
1805 _RealType __b = _RealType(1))
1806 : _M_a(__a), _M_b(__b)
1808 _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
1821 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1837 _RealType __b = _RealType(1))
1838 : _M_param(__a, __b)
1856 {
return _M_param.a(); }
1860 {
return _M_param.b(); }
1867 {
return _M_param; }
1875 { _M_param = __param; }
1882 {
return this->a(); }
1889 {
return this->b(); }
1894 template<
typename _UniformRandomNumberGenerator>
1899 template<
typename _UniformRandomNumberGenerator>
1901 operator()(_UniformRandomNumberGenerator& __urng,
1902 const param_type& __p)
1904 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1906 return (__aurng() * (__p.b() - __p.a())) + __p.a();
1910 param_type _M_param;
1917 template<
typename _IntType>
1927 template<
typename _IntType>
1931 {
return !(__d1 == __d2); }
1943 template<
typename _RealType,
typename _CharT,
typename _Traits>
1945 operator<<(std::basic_ostream<_CharT, _Traits>&,
1957 template<
typename _RealType,
typename _CharT,
typename _Traits>
1979 template<
typename _RealType =
double>
1983 "template argument not a floating point type");
1995 _RealType __stddev = _RealType(1))
1996 : _M_mean(__mean), _M_stddev(__stddev)
1998 _GLIBCXX_DEBUG_ASSERT(_M_stddev > _RealType(0));
2007 {
return _M_stddev; }
2011 {
return (__p1._M_mean == __p2._M_mean
2012 && __p1._M_stddev == __p2._M_stddev); }
2016 _RealType _M_stddev;
2027 : _M_param(__mean, __stddev), _M_saved_available(false)
2032 : _M_param(__p), _M_saved_available(false)
2040 { _M_saved_available =
false; }
2047 {
return _M_param.mean(); }
2054 {
return _M_param.stddev(); }
2061 {
return _M_param; }
2069 { _M_param = __param; }
2088 template<
typename _UniformRandomNumberGenerator>
2093 template<
typename _UniformRandomNumberGenerator>
2095 operator()(_UniformRandomNumberGenerator& __urng,
2096 const param_type& __p);
2103 template<
typename _RealType1>
2118 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2120 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2133 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2139 param_type _M_param;
2141 bool _M_saved_available;
2147 template<
typename _RealType>
2151 {
return !(__d1 == __d2); }
2163 template<
typename _RealType =
double>
2167 "template argument not a floating point type");
2179 _RealType __s = _RealType(1))
2180 : _M_m(__m), _M_s(__s)
2193 {
return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2202 _RealType __s = _RealType(1))
2203 : _M_param(__m, __s), _M_nd()
2208 : _M_param(__p), _M_nd()
2223 {
return _M_param.m(); }
2227 {
return _M_param.s(); }
2234 {
return _M_param; }
2242 { _M_param = __param; }
2261 template<
typename _UniformRandomNumberGenerator>
2266 template<
typename _UniformRandomNumberGenerator>
2268 operator()(_UniformRandomNumberGenerator& __urng,
2269 const param_type& __p)
2270 {
return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2277 template<
typename _RealType1>
2282 && __d1._M_nd == __d2._M_nd); }
2294 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2296 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2309 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2315 param_type _M_param;
2323 template<
typename _RealType>
2327 {
return !(__d1 == __d2); }
2339 template<
typename _RealType =
double>
2343 "template argument not a floating point type");
2355 param_type(_RealType __alpha_val = _RealType(1),
2356 _RealType __beta_val = _RealType(1))
2357 : _M_alpha(__alpha_val), _M_beta(__beta_val)
2359 _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
2365 {
return _M_alpha; }
2372 operator==(
const param_type& __p1,
const param_type& __p2)
2373 {
return (__p1._M_alpha == __p2._M_alpha
2374 && __p1._M_beta == __p2._M_beta); }
2383 _RealType _M_malpha, _M_a2;
2393 _RealType __beta_val = _RealType(1))
2394 : _M_param(__alpha_val, __beta_val), _M_nd()
2399 : _M_param(__p), _M_nd()
2414 {
return _M_param.alpha(); }
2421 {
return _M_param.beta(); }
2428 {
return _M_param; }
2436 { _M_param = __param; }
2455 template<
typename _UniformRandomNumberGenerator>
2460 template<
typename _UniformRandomNumberGenerator>
2462 operator()(_UniformRandomNumberGenerator& __urng,
2463 const param_type& __p);
2470 template<
typename _RealType1>
2475 && __d1._M_nd == __d2._M_nd); }
2487 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2489 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2501 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2507 param_type _M_param;
2515 template<
typename _RealType>
2519 {
return !(__d1 == __d2); }
2528 template<
typename _RealType =
double>
2532 "template argument not a floating point type");
2553 {
return __p1._M_n == __p2._M_n; }
2561 : _M_param(__n), _M_gd(__n / 2)
2566 : _M_param(__p), _M_gd(__p.n() / 2)
2581 {
return _M_param.n(); }
2588 {
return _M_param; }
2596 { _M_param = __param; }
2615 template<
typename _UniformRandomNumberGenerator>
2618 {
return 2 * _M_gd(__urng); }
2620 template<
typename _UniformRandomNumberGenerator>
2622 operator()(_UniformRandomNumberGenerator& __urng,
2623 const param_type& __p)
2627 return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2635 template<
typename _RealType1>
2639 {
return __d1.
param() == __d2.
param() && __d1._M_gd == __d2._M_gd; }
2651 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2653 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2666 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2672 param_type _M_param;
2680 template<
typename _RealType>
2684 {
return !(__d1 == __d2); }
2693 template<
typename _RealType =
double>
2697 "template argument not a floating point type");
2709 _RealType __b = _RealType(1))
2710 : _M_a(__a), _M_b(__b)
2723 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
2732 _RealType __b = _RealType(1))
2733 : _M_param(__a, __b)
2753 {
return _M_param.a(); }
2757 {
return _M_param.b(); }
2764 {
return _M_param; }
2772 { _M_param = __param; }
2791 template<
typename _UniformRandomNumberGenerator>
2796 template<
typename _UniformRandomNumberGenerator>
2798 operator()(_UniformRandomNumberGenerator& __urng,
2799 const param_type& __p);
2802 param_type _M_param;
2809 template<
typename _RealType>
2819 template<
typename _RealType>
2823 {
return !(__d1 == __d2); }
2835 template<
typename _RealType,
typename _CharT,
typename _Traits>
2837 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2850 template<
typename _RealType,
typename _CharT,
typename _Traits>
2866 template<
typename _RealType =
double>
2870 "template argument not a floating point type");
2882 _RealType __n = _RealType(1))
2883 : _M_m(__m), _M_n(__n)
2896 {
return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
2905 _RealType __n = _RealType(1))
2906 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
2911 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
2929 {
return _M_param.m(); }
2933 {
return _M_param.n(); }
2940 {
return _M_param; }
2948 { _M_param = __param; }
2967 template<
typename _UniformRandomNumberGenerator>
2970 {
return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
2972 template<
typename _UniformRandomNumberGenerator>
2974 operator()(_UniformRandomNumberGenerator& __urng,
2975 const param_type& __p)
2979 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
2980 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
2988 template<
typename _RealType1>
2993 && __d1._M_gd_x == __d2._M_gd_x
2994 && __d1._M_gd_y == __d2._M_gd_y); }
3006 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3008 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3021 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3027 param_type _M_param;
3035 template<
typename _RealType>
3039 {
return !(__d1 == __d2); }
3050 template<
typename _RealType =
double>
3054 "template argument not a floating point type");
3065 param_type(_RealType __n = _RealType(1))
3074 operator==(
const param_type& __p1,
const param_type& __p2)
3075 {
return __p1._M_n == __p2._M_n; }
3083 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3088 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3106 {
return _M_param.n(); }
3113 {
return _M_param; }
3121 { _M_param = __param; }
3140 template<
typename _UniformRandomNumberGenerator>
3143 {
return _M_nd(__urng) *
std::sqrt(n() / _M_gd(__urng)); }
3145 template<
typename _UniformRandomNumberGenerator>
3147 operator()(_UniformRandomNumberGenerator& __urng,
3148 const param_type& __p)
3153 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3154 return _M_nd(__urng) *
std::sqrt(__p.n() / __g);
3162 template<
typename _RealType1>
3167 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3179 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3181 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3194 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3200 param_type _M_param;
3209 template<
typename _RealType>
3213 {
return !(__d1 == __d2); }
3241 param_type(
double __p = 0.5)
3244 _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
3252 operator==(
const param_type& __p1,
const param_type& __p2)
3253 {
return __p1._M_p == __p2._M_p; }
3289 {
return _M_param.p(); }
3296 {
return _M_param; }
3304 { _M_param = __param; }
3323 template<
typename _UniformRandomNumberGenerator>
3328 template<
typename _UniformRandomNumberGenerator>
3330 operator()(_UniformRandomNumberGenerator& __urng,
3331 const param_type& __p)
3333 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3335 if ((__aurng() - __aurng.min())
3336 < __p.p() * (__aurng.max() - __aurng.min()))
3342 param_type _M_param;
3361 {
return !(__d1 == __d2); }
3373 template<
typename _CharT,
typename _Traits>
3375 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3387 template<
typename _CharT,
typename _Traits>
3406 template<
typename _IntType =
int>
3410 "template argument not an integral type");
3422 param_type(_IntType __t = _IntType(1),
double __p = 0.5)
3423 : _M_t(__t), _M_p(__p)
3425 _GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0))
3440 operator==(
const param_type& __p1,
const param_type& __p2)
3441 {
return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3451 #if _GLIBCXX_USE_C99_MATH_TR1
3452 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
3453 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
3462 : _M_param(__t, __p), _M_nd()
3467 : _M_param(__p), _M_nd()
3482 {
return _M_param.t(); }
3489 {
return _M_param.p(); }
3496 {
return _M_param; }
3504 { _M_param = __param; }
3518 {
return _M_param.t(); }
3523 template<
typename _UniformRandomNumberGenerator>
3528 template<
typename _UniformRandomNumberGenerator>
3530 operator()(_UniformRandomNumberGenerator& __urng,
3531 const param_type& __p);
3538 template<
typename _IntType1>
3542 #ifdef _GLIBCXX_USE_C99_MATH_TR1
3543 {
return __d1.
param() == __d2.
param() && __d1._M_nd == __d2._M_nd; }
3558 template<
typename _IntType1,
3559 typename _CharT,
typename _Traits>
3561 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3574 template<
typename _IntType1,
3575 typename _CharT,
typename _Traits>
3581 template<
typename _UniformRandomNumberGenerator>
3583 _M_waiting(_UniformRandomNumberGenerator& __urng, _IntType __t);
3585 param_type _M_param;
3594 template<
typename _IntType>
3598 {
return !(__d1 == __d2); }
3608 template<
typename _IntType =
int>
3612 "template argument not an integral type");
3624 param_type(
double __p = 0.5)
3627 _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
3636 operator==(
const param_type& __p1,
const param_type& __p2)
3637 {
return __p1._M_p == __p2._M_p; }
3642 { _M_log_1_p =
std::log(1.0 - _M_p); }
3673 {
return _M_param.p(); }
3680 {
return _M_param; }
3688 { _M_param = __param; }
3707 template<
typename _UniformRandomNumberGenerator>
3712 template<
typename _UniformRandomNumberGenerator>
3714 operator()(_UniformRandomNumberGenerator& __urng,
3715 const param_type& __p);
3718 param_type _M_param;
3725 template<
typename _IntType>
3735 template<
typename _IntType>
3739 {
return !(__d1 == __d2); }
3751 template<
typename _IntType,
3752 typename _CharT,
typename _Traits>
3754 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3766 template<
typename _IntType,
3767 typename _CharT,
typename _Traits>
3780 template<
typename _IntType =
int>
3784 "template argument not an integral type");
3795 param_type(_IntType __k = 1,
double __p = 0.5)
3796 : _M_k(__k), _M_p(__p)
3798 _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
3810 operator==(
const param_type& __p1,
const param_type& __p2)
3811 {
return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
3820 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
3825 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
3840 {
return _M_param.k(); }
3847 {
return _M_param.p(); }
3854 {
return _M_param; }
3862 { _M_param = __param; }
3881 template<
typename _UniformRandomNumberGenerator>
3883 operator()(_UniformRandomNumberGenerator& __urng);
3885 template<
typename _UniformRandomNumberGenerator>
3887 operator()(_UniformRandomNumberGenerator& __urng,
3888 const param_type& __p);
3895 template<
typename _IntType1>
3899 {
return __d1.
param() == __d2.
param() && __d1._M_gd == __d2._M_gd; }
3912 template<
typename _IntType1,
typename _CharT,
typename _Traits>
3914 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3927 template<
typename _IntType1,
typename _CharT,
typename _Traits>
3933 param_type _M_param;
3941 template<
typename _IntType>
3945 {
return !(__d1 == __d2); }
3963 template<
typename _IntType =
int>
3967 "template argument not an integral type");
3979 param_type(
double __mean = 1.0)
3982 _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
3991 operator==(
const param_type& __p1,
const param_type& __p2)
3992 {
return __p1._M_mean == __p2._M_mean; }
4002 #if _GLIBCXX_USE_C99_MATH_TR1
4003 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4010 : _M_param(__mean), _M_nd()
4015 : _M_param(__p), _M_nd()
4030 {
return _M_param.mean(); }
4037 {
return _M_param; }
4045 { _M_param = __param; }
4064 template<
typename _UniformRandomNumberGenerator>
4069 template<
typename _UniformRandomNumberGenerator>
4071 operator()(_UniformRandomNumberGenerator& __urng,
4072 const param_type& __p);
4079 template<
typename _IntType1>
4083 #ifdef _GLIBCXX_USE_C99_MATH_TR1
4084 {
return __d1.
param() == __d2.
param() && __d1._M_nd == __d2._M_nd; }
4099 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4101 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4114 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4120 param_type _M_param;
4129 template<
typename _IntType>
4133 {
return !(__d1 == __d2); }
4151 template<
typename _RealType =
double>
4155 "template argument not a floating point type");
4166 param_type(_RealType __lambda = _RealType(1))
4167 : _M_lambda(__lambda)
4169 _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0));
4174 {
return _M_lambda; }
4177 operator==(
const param_type& __p1,
const param_type& __p2)
4178 {
return __p1._M_lambda == __p2._M_lambda; }
4181 _RealType _M_lambda;
4191 : _M_param(__lambda)
4212 {
return _M_param.lambda(); }
4219 {
return _M_param; }
4227 { _M_param = __param; }
4246 template<
typename _UniformRandomNumberGenerator>
4251 template<
typename _UniformRandomNumberGenerator>
4253 operator()(_UniformRandomNumberGenerator& __urng,
4254 const param_type& __p)
4256 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4258 return -
std::log(__aurng()) / __p.lambda();
4262 param_type _M_param;
4269 template<
typename _RealType>
4279 template<
typename _RealType>
4283 {
return !(__d1 == __d2); }
4295 template<
typename _RealType,
typename _CharT,
typename _Traits>
4297 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4310 template<
typename _RealType,
typename _CharT,
typename _Traits>
4325 template<
typename _RealType =
double>
4329 "template argument not a floating point type");
4340 param_type(_RealType __a = _RealType(1),
4341 _RealType __b = _RealType(1))
4342 : _M_a(__a), _M_b(__b)
4354 operator==(
const param_type& __p1,
const param_type& __p2)
4355 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
4364 _RealType __b = _RealType(1))
4365 : _M_param(__a, __b)
4385 {
return _M_param.a(); }
4392 {
return _M_param.b(); }
4399 {
return _M_param; }
4407 { _M_param = __param; }
4426 template<
typename _UniformRandomNumberGenerator>
4431 template<
typename _UniformRandomNumberGenerator>
4433 operator()(_UniformRandomNumberGenerator& __urng,
4434 const param_type& __p);
4437 param_type _M_param;
4444 template<
typename _RealType>
4454 template<
typename _RealType>
4458 {
return !(__d1 == __d2); }
4470 template<
typename _RealType,
typename _CharT,
typename _Traits>
4472 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4485 template<
typename _RealType,
typename _CharT,
typename _Traits>
4500 template<
typename _RealType =
double>
4504 "template argument not a floating point type");
4515 param_type(_RealType __a = _RealType(0),
4516 _RealType __b = _RealType(1))
4517 : _M_a(__a), _M_b(__b)
4529 operator==(
const param_type& __p1,
const param_type& __p2)
4530 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
4539 _RealType __b = _RealType(1))
4540 : _M_param(__a, __b)
4560 {
return _M_param.a(); }
4567 {
return _M_param.b(); }
4574 {
return _M_param; }
4582 { _M_param = __param; }
4601 template<
typename _UniformRandomNumberGenerator>
4606 template<
typename _UniformRandomNumberGenerator>
4608 operator()(_UniformRandomNumberGenerator& __urng,
4609 const param_type& __p);
4612 param_type _M_param;
4619 template<
typename _RealType>
4629 template<
typename _RealType>
4633 {
return !(__d1 == __d2); }
4645 template<
typename _RealType,
typename _CharT,
typename _Traits>
4647 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4660 template<
typename _RealType,
typename _CharT,
typename _Traits>
4672 template<
typename _IntType =
int>
4676 "template argument not an integral type");
4688 : _M_prob(), _M_cp()
4691 template<
typename _InputIterator>
4692 param_type(_InputIterator __wbegin,
4693 _InputIterator __wend)
4694 : _M_prob(__wbegin, __wend), _M_cp()
4695 { _M_initialize(); }
4698 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
4699 { _M_initialize(); }
4701 template<
typename _Func>
4702 param_type(
size_t __nw,
double __xmin,
double __xmax,
4706 param_type(
const param_type&) =
default;
4707 param_type& operator=(
const param_type&) =
default;
4710 probabilities()
const
4714 operator==(
const param_type& __p1,
const param_type& __p2)
4715 {
return __p1._M_prob == __p2._M_prob; }
4729 template<
typename _InputIterator>
4731 _InputIterator __wend)
4732 : _M_param(__wbegin, __wend)
4735 discrete_distribution(initializer_list<double> __wl)
4739 template<
typename _Func>
4740 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
4742 : _M_param(__nw, __xmin, __xmax, __fw)
4746 discrete_distribution(
const param_type& __p)
4763 return _M_param._M_prob.
empty()
4772 {
return _M_param; }
4780 { _M_param = __param; }
4795 return _M_param._M_prob.
empty()
4802 template<
typename _UniformRandomNumberGenerator>
4807 template<
typename _UniformRandomNumberGenerator>
4809 operator()(_UniformRandomNumberGenerator& __urng,
4810 const param_type& __p);
4822 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4824 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4838 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4844 param_type _M_param;
4851 template<
typename _IntType>
4861 template<
typename _IntType>
4865 {
return !(__d1 == __d2); }
4874 template<
typename _RealType =
double>
4878 "template argument not a floating point type");
4890 : _M_int(), _M_den(), _M_cp()
4893 template<
typename _InputIteratorB,
typename _InputIteratorW>
4894 param_type(_InputIteratorB __bfirst,
4895 _InputIteratorB __bend,
4896 _InputIteratorW __wbegin);
4898 template<
typename _Func>
4901 template<
typename _Func>
4902 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
4906 param_type(
const param_type&) =
default;
4907 param_type& operator=(
const param_type&) =
default;
4915 __tmp[1] = _RealType(1);
4927 operator==(
const param_type& __p1,
const param_type& __p2)
4928 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
4944 template<
typename _InputIteratorB,
typename _InputIteratorW>
4946 _InputIteratorB __bend,
4947 _InputIteratorW __wbegin)
4948 : _M_param(__bfirst, __bend, __wbegin)
4951 template<
typename _Func>
4952 piecewise_constant_distribution(initializer_list<_RealType> __bl,
4954 : _M_param(__bl, __fw)
4957 template<
typename _Func>
4958 piecewise_constant_distribution(
size_t __nw,
4959 _RealType __xmin, _RealType __xmax,
4961 : _M_param(__nw, __xmin, __xmax, __fw)
4965 piecewise_constant_distribution(
const param_type& __p)
4982 if (_M_param._M_int.
empty())
4985 __tmp[1] = _RealType(1);
4989 return _M_param._M_int;
4998 return _M_param._M_den.
empty()
5007 {
return _M_param; }
5015 { _M_param = __param; }
5023 return _M_param._M_int.
empty()
5033 return _M_param._M_int.
empty()
5040 template<
typename _UniformRandomNumberGenerator>
5045 template<
typename _UniformRandomNumberGenerator>
5047 operator()(_UniformRandomNumberGenerator& __urng,
5048 const param_type& __p);
5061 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5063 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5077 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5083 param_type _M_param;
5090 template<
typename _RealType>
5100 template<
typename _RealType>
5104 {
return !(__d1 == __d2); }
5113 template<
typename _RealType =
double>
5117 "template argument not a floating point type");
5129 : _M_int(), _M_den(), _M_cp(), _M_m()
5132 template<
typename _InputIteratorB,
typename _InputIteratorW>
5133 param_type(_InputIteratorB __bfirst,
5134 _InputIteratorB __bend,
5135 _InputIteratorW __wbegin);
5137 template<
typename _Func>
5140 template<
typename _Func>
5141 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5145 param_type(
const param_type&) =
default;
5146 param_type& operator=(
const param_type&) =
default;
5154 __tmp[1] = _RealType(1);
5166 operator==(
const param_type& __p1,
const param_type& __p2)
5167 {
return (__p1._M_int == __p2._M_int
5168 && __p1._M_den == __p2._M_den); }
5185 template<
typename _InputIteratorB,
typename _InputIteratorW>
5187 _InputIteratorB __bend,
5188 _InputIteratorW __wbegin)
5189 : _M_param(__bfirst, __bend, __wbegin)
5192 template<
typename _Func>
5193 piecewise_linear_distribution(initializer_list<_RealType> __bl,
5195 : _M_param(__bl, __fw)
5198 template<
typename _Func>
5199 piecewise_linear_distribution(
size_t __nw,
5200 _RealType __xmin, _RealType __xmax,
5202 : _M_param(__nw, __xmin, __xmax, __fw)
5206 piecewise_linear_distribution(
const param_type& __p)
5223 if (_M_param._M_int.
empty())
5226 __tmp[1] = _RealType(1);
5230 return _M_param._M_int;
5240 return _M_param._M_den.
empty()
5249 {
return _M_param; }
5257 { _M_param = __param; }
5265 return _M_param._M_int.
empty()
5275 return _M_param._M_int.
empty()
5282 template<
typename _UniformRandomNumberGenerator>
5287 template<
typename _UniformRandomNumberGenerator>
5289 operator()(_UniformRandomNumberGenerator& __urng,
5290 const param_type& __p);
5303 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5305 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5319 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5325 param_type _M_param;
5332 template<
typename _RealType>
5342 template<
typename _RealType>
5346 {
return !(__d1 == __d2); }
5375 template<
typename _IntType>
5378 template<
typename _InputIterator>
5379 seed_seq(_InputIterator __begin, _InputIterator __end);
5382 template<
typename _RandomAccessIterator>
5384 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
5388 {
return _M_v.
size(); }
5390 template<
typename OutputIterator>
5392 param(OutputIterator __dest)
const
5393 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
5404 _GLIBCXX_END_NAMESPACE_VERSION