37 namespace std _GLIBCXX_VISIBILITY(default)
39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
56 template<
typename _RealType,
size_t __bits,
57 typename _UniformRandomNumberGenerator>
61 _GLIBCXX_END_NAMESPACE_VERSION
68 _GLIBCXX_BEGIN_NAMESPACE_VERSION
70 template<
typename _UIntType,
size_t __w,
71 bool = __w < static_cast<size_t>
74 {
static const _UIntType __value = 0; };
76 template<
typename _UIntType,
size_t __w>
77 struct _Shift<_UIntType, __w, true>
78 {
static const _UIntType __value = _UIntType(1) << __w; };
81 int __which = ((__s <= __CHAR_BIT__ *
sizeof (int))
82 + (__s <= __CHAR_BIT__ *
sizeof (long))
83 + (__s <= __CHAR_BIT__ *
sizeof (
long long))
86 struct _Select_uint_least_t
88 static_assert(__which < 0,
89 "sorry, would be too much trouble for a slow result");
93 struct _Select_uint_least_t<__s, 4>
94 {
typedef unsigned int type; };
97 struct _Select_uint_least_t<__s, 3>
98 {
typedef unsigned long type; };
101 struct _Select_uint_least_t<__s, 2>
102 {
typedef unsigned long long type; };
104 #ifdef _GLIBCXX_USE_INT128 106 struct _Select_uint_least_t<__s, 1>
107 {
typedef unsigned __int128 type; };
111 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
112 bool __big_enough = (!(__m & (__m - 1))
113 || (_Tp(-1) - __c) / __a >= __m - 1),
114 bool __schrage_ok = __m % __a < __m / __a>
117 typedef typename _Select_uint_least_t<
std::__lg(__a)
121 {
return static_cast<_Tp
>((_Tp2(__a) * __x + __c) % __m); }
125 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
126 struct _Mod<_Tp, __m, __a, __c, false, true>
135 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
136 struct _Mod<_Tp, __m, __a, __c, true, __s>
141 _Tp __res = __a * __x + __c;
148 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
151 {
return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
157 template<
typename _Engine,
typename _DInputType>
161 "template argument not a floating point type");
164 _Adaptor(_Engine& __g)
169 {
return _DInputType(0); }
173 {
return _DInputType(1); }
192 _GLIBCXX_END_NAMESPACE_VERSION
195 _GLIBCXX_BEGIN_NAMESPACE_VERSION
235 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
238 static_assert(std::is_unsigned<_UIntType>::value,
"template argument " 239 "substituting _UIntType not an unsigned integral type");
240 static_assert(__m == 0u || (__a < __m && __c < __m),
241 "template argument substituting __m out of bounds");
248 static constexpr result_type multiplier = __a;
250 static constexpr result_type increment = __c;
253 static constexpr result_type default_seed = 1u;
272 template<
typename _Sseq,
typename =
typename 273 std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
286 seed(result_type __s = default_seed);
295 template<
typename _Sseq>
296 typename std::enable_if<std::is_class<_Sseq>::value>::type
305 static constexpr result_type
307 {
return __c == 0u ? 1u : 0u; }
312 static constexpr result_type
322 for (; __z != 0ULL; --__z)
332 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
350 {
return __lhs._M_x == __rhs._M_x; }
360 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
361 _UIntType1 __m1,
typename _CharT,
typename _Traits>
363 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
365 __a1, __c1, __m1>& __lcr);
380 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
381 _UIntType1 __m1,
typename _CharT,
typename _Traits>
402 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
408 {
return !(__lhs == __rhs); }
439 template<
typename _UIntType,
size_t __w,
440 size_t __n,
size_t __m,
size_t __r,
441 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
442 _UIntType __b,
size_t __t,
443 _UIntType __c,
size_t __l, _UIntType __f>
446 static_assert(std::is_unsigned<_UIntType>::value,
"template argument " 447 "substituting _UIntType not an unsigned integral type");
448 static_assert(1u <= __m && __m <= __n,
449 "template argument substituting __m out of bounds");
450 static_assert(__r <= __w,
"template argument substituting " 452 static_assert(__u <= __w,
"template argument substituting " 454 static_assert(__s <= __w,
"template argument substituting " 456 static_assert(__t <= __w,
"template argument substituting " 458 static_assert(__l <= __w,
"template argument substituting " 461 "template argument substituting __w out of bound");
462 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
463 "template argument substituting __a out of bound");
464 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
465 "template argument substituting __b out of bound");
466 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
467 "template argument substituting __c out of bound");
468 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
469 "template argument substituting __d out of bound");
470 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
471 "template argument substituting __f out of bound");
478 static constexpr
size_t word_size = __w;
479 static constexpr
size_t state_size = __n;
480 static constexpr
size_t shift_size = __m;
481 static constexpr
size_t mask_bits = __r;
482 static constexpr result_type xor_mask = __a;
483 static constexpr
size_t tempering_u = __u;
484 static constexpr result_type tempering_d = __d;
485 static constexpr
size_t tempering_s = __s;
486 static constexpr result_type tempering_b = __b;
487 static constexpr
size_t tempering_t = __t;
488 static constexpr result_type tempering_c = __c;
489 static constexpr
size_t tempering_l = __l;
490 static constexpr result_type initialization_multiplier = __f;
491 static constexpr result_type default_seed = 5489u;
504 template<
typename _Sseq,
typename =
typename 505 std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
512 seed(result_type __sd = default_seed);
514 template<
typename _Sseq>
515 typename std::enable_if<std::is_class<_Sseq>::value>::type
521 static constexpr result_type
528 static constexpr result_type
530 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
536 discard(
unsigned long long __z);
556 {
return (
std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
557 && __lhs._M_p == __rhs._M_p); }
571 template<
typename _UIntType1,
572 size_t __w1,
size_t __n1,
573 size_t __m1,
size_t __r1,
574 _UIntType1 __a1,
size_t __u1,
575 _UIntType1 __d1,
size_t __s1,
576 _UIntType1 __b1,
size_t __t1,
577 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
578 typename _CharT,
typename _Traits>
580 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
582 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
597 template<
typename _UIntType1,
598 size_t __w1,
size_t __n1,
599 size_t __m1,
size_t __r1,
600 _UIntType1 __a1,
size_t __u1,
601 _UIntType1 __d1,
size_t __s1,
602 _UIntType1 __b1,
size_t __t1,
603 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
604 typename _CharT,
typename _Traits>
608 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
614 _UIntType _M_x[state_size];
630 template<
typename _UIntType,
size_t __w,
631 size_t __n,
size_t __m,
size_t __r,
632 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
633 _UIntType __b,
size_t __t,
634 _UIntType __c,
size_t __l, _UIntType __f>
637 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
639 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
640 {
return !(__lhs == __rhs); }
658 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
661 static_assert(std::is_unsigned<_UIntType>::value,
"template argument " 662 "substituting _UIntType not an unsigned integral type");
663 static_assert(0u < __s && __s < __r,
664 "template argument substituting __s out of bounds");
666 "template argument substituting __w out of bounds");
673 static constexpr
size_t word_size = __w;
674 static constexpr
size_t short_lag = __s;
675 static constexpr
size_t long_lag = __r;
676 static constexpr result_type default_seed = 19780503u;
692 template<
typename _Sseq,
typename =
typename 693 std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
712 seed(result_type __sd = default_seed);
718 template<
typename _Sseq>
719 typename std::enable_if<std::is_class<_Sseq>::value>::type
726 static constexpr result_type
734 static constexpr result_type
736 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
744 for (; __z != 0ULL; --__z)
769 {
return (
std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
770 && __lhs._M_carry == __rhs._M_carry
771 && __lhs._M_p == __rhs._M_p); }
785 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
786 typename _CharT,
typename _Traits>
788 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
804 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
805 typename _CharT,
typename _Traits>
813 _UIntType _M_x[long_lag];
830 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
836 {
return !(__lhs == __rhs); }
845 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
848 static_assert(1 <= __r && __r <= __p,
849 "template argument substituting __r out of bounds");
853 typedef typename _RandomNumberEngine::result_type
result_type;
856 static constexpr
size_t block_size = __p;
857 static constexpr
size_t used_block = __r;
865 : _M_b(), _M_n(0) { }
875 : _M_b(__rng), _M_n(0) { }
885 : _M_b(
std::move(__rng)), _M_n(0) { }
895 : _M_b(__s), _M_n(0) { }
902 template<
typename _Sseq,
typename =
typename 903 std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
904 && !std::is_same<_Sseq, _RandomNumberEngine>::value>
938 template<
typename _Sseq>
950 const _RandomNumberEngine&
957 static constexpr result_type
964 static constexpr result_type
974 for (; __z != 0ULL; --__z)
998 {
return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1011 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1012 typename _CharT,
typename _Traits>
1014 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1029 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1030 typename _CharT,
typename _Traits>
1037 _RandomNumberEngine _M_b;
1052 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1058 {
return !(__lhs == __rhs); }
1065 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1068 static_assert(std::is_unsigned<_UIntType>::value,
"template argument " 1069 "substituting _UIntType not an unsigned integral type");
1071 "template argument substituting __w out of bounds");
1103 : _M_b(
std::move(__rng)) { }
1120 template<
typename _Sseq,
typename =
typename 1121 std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
1122 && !std::is_same<_Sseq, _RandomNumberEngine>::value>
1150 template<
typename _Sseq>
1159 const _RandomNumberEngine&
1166 static constexpr result_type
1173 static constexpr result_type
1175 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1183 for (; __z != 0ULL; --__z)
1208 {
return __lhs._M_b == __rhs._M_b; }
1222 template<
typename _CharT,
typename _Traits>
1226 __w, _UIntType>& __x)
1233 _RandomNumberEngine _M_b;
1248 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1254 {
return !(__lhs == __rhs); }
1266 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1267 typename _CharT,
typename _Traits>
1269 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1271 __w, _UIntType>& __x)
1283 template<
typename _RandomNumberEngine,
size_t __k>
1286 static_assert(1u <= __k,
"template argument substituting " 1287 "__k out of bound");
1291 typedef typename _RandomNumberEngine::result_type
result_type;
1293 static constexpr
size_t table_size = __k;
1302 { _M_initialize(); }
1313 { _M_initialize(); }
1323 : _M_b(
std::move(__rng))
1324 { _M_initialize(); }
1335 { _M_initialize(); }
1342 template<
typename _Sseq,
typename =
typename 1343 std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
1344 && !std::is_same<_Sseq, _RandomNumberEngine>::value>
1349 { _M_initialize(); }
1378 template<
typename _Sseq>
1389 const _RandomNumberEngine&
1396 static constexpr result_type
1403 static constexpr result_type
1413 for (; __z != 0ULL; --__z)
1437 {
return (__lhs._M_b == __rhs._M_b
1438 &&
std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1439 && __lhs._M_y == __rhs._M_y); }
1452 template<
typename _RandomNumberEngine1,
size_t __k1,
1453 typename _CharT,
typename _Traits>
1455 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1470 template<
typename _RandomNumberEngine1,
size_t __k1,
1471 typename _CharT,
typename _Traits>
1477 void _M_initialize()
1479 for (
size_t __i = 0; __i < __k; ++__i)
1484 _RandomNumberEngine _M_b;
1485 result_type _M_v[__k];
1500 template<
typename _RandomNumberEngine,
size_t __k>
1506 {
return !(__lhs == __rhs); }
1543 0xb5026f5aa96619e9ULL, 29,
1544 0x5555555555555555ULL, 17,
1545 0x71d67fffeda60000ULL, 37,
1546 0xfff7eee000000000ULL, 43,
1575 #ifdef _GLIBCXX_USE_RANDOM_TR1 1590 { _M_init_pretr1(__token); }
1596 static constexpr result_type
1600 static constexpr result_type
1605 entropy()
const noexcept
1611 #ifdef _GLIBCXX_USE_RANDOM_TR1 1612 return this->_M_getval();
1614 return this->_M_getval_pretr1();
1628 result_type _M_getval();
1629 result_type _M_getval_pretr1();
1658 template<
typename _IntType>
1662 {
return !(__d1 == __d2); }
1674 template<
typename _IntType,
typename _CharT,
typename _Traits>
1676 operator<<(std::basic_ostream<_CharT, _Traits>&,
1688 template<
typename _IntType,
typename _CharT,
typename _Traits>
1701 template<
typename _RealType =
double>
1705 "template argument not a floating point type");
1717 _RealType __b = _RealType(1))
1718 : _M_a(__a), _M_b(__b)
1720 _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
1733 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1749 _RealType __b = _RealType(1))
1750 : _M_param(__a, __b)
1768 {
return _M_param.a(); }
1772 {
return _M_param.b(); }
1779 {
return _M_param; }
1787 { _M_param = __param; }
1794 {
return this->a(); }
1801 {
return this->b(); }
1806 template<
typename _UniformRandomNumberGenerator>
1809 {
return this->operator()(__urng, _M_param); }
1811 template<
typename _UniformRandomNumberGenerator>
1813 operator()(_UniformRandomNumberGenerator& __urng,
1816 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1818 return (__aurng() * (__p.b() - __p.a())) + __p.a();
1821 template<
typename _ForwardIterator,
1822 typename _UniformRandomNumberGenerator>
1824 __generate(_ForwardIterator __f, _ForwardIterator __t,
1825 _UniformRandomNumberGenerator& __urng)
1826 { this->__generate(__f, __t, __urng, _M_param); }
1828 template<
typename _ForwardIterator,
1829 typename _UniformRandomNumberGenerator>
1831 __generate(_ForwardIterator __f, _ForwardIterator __t,
1832 _UniformRandomNumberGenerator& __urng,
1834 { this->__generate_impl(__f, __t, __urng, __p); }
1836 template<
typename _UniformRandomNumberGenerator>
1838 __generate(result_type* __f, result_type* __t,
1839 _UniformRandomNumberGenerator& __urng,
1841 { this->__generate_impl(__f, __t, __urng, __p); }
1850 {
return __d1._M_param == __d2._M_param; }
1853 template<
typename _ForwardIterator,
1854 typename _UniformRandomNumberGenerator>
1856 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1857 _UniformRandomNumberGenerator& __urng,
1867 template<
typename _IntType>
1871 {
return !(__d1 == __d2); }
1883 template<
typename _RealType,
typename _CharT,
typename _Traits>
1885 operator<<(std::basic_ostream<_CharT, _Traits>&,
1897 template<
typename _RealType,
typename _CharT,
typename _Traits>
1919 template<
typename _RealType =
double>
1923 "template argument not a floating point type");
1935 _RealType __stddev = _RealType(1))
1936 : _M_mean(__mean), _M_stddev(__stddev)
1938 _GLIBCXX_DEBUG_ASSERT(_M_stddev > _RealType(0));
1947 {
return _M_stddev; }
1951 {
return (__p1._M_mean == __p2._M_mean
1952 && __p1._M_stddev == __p2._M_stddev); }
1956 _RealType _M_stddev;
1966 result_type __stddev = result_type(1))
1967 : _M_param(__mean, __stddev), _M_saved_available(false)
1972 : _M_param(__p), _M_saved_available(
false)
1980 { _M_saved_available =
false; }
1987 {
return _M_param.mean(); }
1994 {
return _M_param.stddev(); }
2001 {
return _M_param; }
2009 { _M_param = __param; }
2028 template<
typename _UniformRandomNumberGenerator>
2031 {
return this->operator()(__urng, _M_param); }
2033 template<
typename _UniformRandomNumberGenerator>
2035 operator()(_UniformRandomNumberGenerator& __urng,
2036 const param_type& __p);
2038 template<
typename _ForwardIterator,
2039 typename _UniformRandomNumberGenerator>
2041 __generate(_ForwardIterator __f, _ForwardIterator __t,
2042 _UniformRandomNumberGenerator& __urng)
2043 { this->__generate(__f, __t, __urng, _M_param); }
2045 template<
typename _ForwardIterator,
2046 typename _UniformRandomNumberGenerator>
2048 __generate(_ForwardIterator __f, _ForwardIterator __t,
2049 _UniformRandomNumberGenerator& __urng,
2050 const param_type& __p)
2051 { this->__generate_impl(__f, __t, __urng, __p); }
2053 template<
typename _UniformRandomNumberGenerator>
2055 __generate(result_type* __f, result_type* __t,
2056 _UniformRandomNumberGenerator& __urng,
2057 const param_type& __p)
2058 { this->__generate_impl(__f, __t, __urng, __p); }
2065 template<
typename _RealType1>
2080 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2082 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2095 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2101 template<
typename _ForwardIterator,
2102 typename _UniformRandomNumberGenerator>
2104 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2105 _UniformRandomNumberGenerator& __urng,
2106 const param_type& __p);
2108 param_type _M_param;
2109 result_type _M_saved;
2110 bool _M_saved_available;
2116 template<
typename _RealType>
2120 {
return !(__d1 == __d2); }
2132 template<
typename _RealType =
double>
2136 "template argument not a floating point type");
2148 _RealType __s = _RealType(1))
2149 : _M_m(__m), _M_s(__s)
2162 {
return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2171 _RealType __s = _RealType(1))
2172 : _M_param(__m, __s), _M_nd()
2177 : _M_param(__p), _M_nd()
2192 {
return _M_param.m(); }
2196 {
return _M_param.s(); }
2203 {
return _M_param; }
2211 { _M_param = __param; }
2218 {
return result_type(0); }
2230 template<
typename _UniformRandomNumberGenerator>
2233 {
return this->operator()(__urng, _M_param); }
2235 template<
typename _UniformRandomNumberGenerator>
2237 operator()(_UniformRandomNumberGenerator& __urng,
2239 {
return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2241 template<
typename _ForwardIterator,
2242 typename _UniformRandomNumberGenerator>
2244 __generate(_ForwardIterator __f, _ForwardIterator __t,
2245 _UniformRandomNumberGenerator& __urng)
2246 { this->__generate(__f, __t, __urng, _M_param); }
2248 template<
typename _ForwardIterator,
2249 typename _UniformRandomNumberGenerator>
2251 __generate(_ForwardIterator __f, _ForwardIterator __t,
2252 _UniformRandomNumberGenerator& __urng,
2254 { this->__generate_impl(__f, __t, __urng, __p); }
2256 template<
typename _UniformRandomNumberGenerator>
2258 __generate(result_type* __f, result_type* __t,
2259 _UniformRandomNumberGenerator& __urng,
2261 { this->__generate_impl(__f, __t, __urng, __p); }
2271 {
return (__d1._M_param == __d2._M_param
2272 && __d1._M_nd == __d2._M_nd); }
2284 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2286 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2299 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2305 template<
typename _ForwardIterator,
2306 typename _UniformRandomNumberGenerator>
2308 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2309 _UniformRandomNumberGenerator& __urng,
2320 template<
typename _RealType>
2324 {
return !(__d1 == __d2); }
2336 template<
typename _RealType =
double>
2340 "template argument not a floating point type");
2352 param_type(_RealType __alpha_val = _RealType(1),
2353 _RealType __beta_val = _RealType(1))
2354 : _M_alpha(__alpha_val), _M_beta(__beta_val)
2356 _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
2362 {
return _M_alpha; }
2369 operator==(
const param_type& __p1,
const param_type& __p2)
2370 {
return (__p1._M_alpha == __p2._M_alpha
2371 && __p1._M_beta == __p2._M_beta); }
2380 _RealType _M_malpha, _M_a2;
2390 _RealType __beta_val = _RealType(1))
2391 : _M_param(__alpha_val, __beta_val), _M_nd()
2396 : _M_param(__p), _M_nd()
2411 {
return _M_param.alpha(); }
2418 {
return _M_param.beta(); }
2425 {
return _M_param; }
2433 { _M_param = __param; }
2440 {
return result_type(0); }
2452 template<
typename _UniformRandomNumberGenerator>
2455 {
return this->operator()(__urng, _M_param); }
2457 template<
typename _UniformRandomNumberGenerator>
2459 operator()(_UniformRandomNumberGenerator& __urng,
2460 const param_type& __p);
2462 template<
typename _ForwardIterator,
2463 typename _UniformRandomNumberGenerator>
2465 __generate(_ForwardIterator __f, _ForwardIterator __t,
2466 _UniformRandomNumberGenerator& __urng)
2467 { this->__generate(__f, __t, __urng, _M_param); }
2469 template<
typename _ForwardIterator,
2470 typename _UniformRandomNumberGenerator>
2472 __generate(_ForwardIterator __f, _ForwardIterator __t,
2473 _UniformRandomNumberGenerator& __urng,
2474 const param_type& __p)
2475 { this->__generate_impl(__f, __t, __urng, __p); }
2477 template<
typename _UniformRandomNumberGenerator>
2479 __generate(result_type* __f, result_type* __t,
2480 _UniformRandomNumberGenerator& __urng,
2481 const param_type& __p)
2482 { this->__generate_impl(__f, __t, __urng, __p); }
2492 {
return (__d1._M_param == __d2._M_param
2493 && __d1._M_nd == __d2._M_nd); }
2505 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2507 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2519 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2525 template<
typename _ForwardIterator,
2526 typename _UniformRandomNumberGenerator>
2528 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2529 _UniformRandomNumberGenerator& __urng,
2530 const param_type& __p);
2532 param_type _M_param;
2540 template<
typename _RealType>
2544 {
return !(__d1 == __d2); }
2553 template<
typename _RealType =
double>
2557 "template argument not a floating point type");
2578 {
return __p1._M_n == __p2._M_n; }
2586 : _M_param(__n), _M_gd(__n / 2)
2591 : _M_param(__p), _M_gd(__p.n() / 2)
2606 {
return _M_param.n(); }
2613 {
return _M_param; }
2621 { _M_param = __param; }
2628 {
return result_type(0); }
2640 template<
typename _UniformRandomNumberGenerator>
2643 {
return 2 * _M_gd(__urng); }
2645 template<
typename _UniformRandomNumberGenerator>
2647 operator()(_UniformRandomNumberGenerator& __urng,
2652 return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2655 template<
typename _ForwardIterator,
2656 typename _UniformRandomNumberGenerator>
2658 __generate(_ForwardIterator __f, _ForwardIterator __t,
2659 _UniformRandomNumberGenerator& __urng)
2660 { this->__generate_impl(__f, __t, __urng); }
2662 template<
typename _ForwardIterator,
2663 typename _UniformRandomNumberGenerator>
2665 __generate(_ForwardIterator __f, _ForwardIterator __t,
2666 _UniformRandomNumberGenerator& __urng,
2670 this->__generate_impl(__f, __t, __urng, __p2); }
2672 template<
typename _UniformRandomNumberGenerator>
2674 __generate(result_type* __f, result_type* __t,
2675 _UniformRandomNumberGenerator& __urng)
2676 { this->__generate_impl(__f, __t, __urng); }
2678 template<
typename _UniformRandomNumberGenerator>
2680 __generate(result_type* __f, result_type* __t,
2681 _UniformRandomNumberGenerator& __urng,
2685 this->__generate_impl(__f, __t, __urng, __p2); }
2695 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2707 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2709 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2722 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2728 template<
typename _ForwardIterator,
2729 typename _UniformRandomNumberGenerator>
2731 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2732 _UniformRandomNumberGenerator& __urng);
2734 template<
typename _ForwardIterator,
2735 typename _UniformRandomNumberGenerator>
2737 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2738 _UniformRandomNumberGenerator& __urng,
2750 template<
typename _RealType>
2754 {
return !(__d1 == __d2); }
2763 template<
typename _RealType =
double>
2767 "template argument not a floating point type");
2779 _RealType __b = _RealType(1))
2780 : _M_a(__a), _M_b(__b)
2793 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
2802 _RealType __b = _RealType(1))
2803 : _M_param(__a, __b)
2823 {
return _M_param.a(); }
2827 {
return _M_param.b(); }
2834 {
return _M_param; }
2842 { _M_param = __param; }
2861 template<
typename _UniformRandomNumberGenerator>
2864 {
return this->operator()(__urng, _M_param); }
2866 template<
typename _UniformRandomNumberGenerator>
2868 operator()(_UniformRandomNumberGenerator& __urng,
2871 template<
typename _ForwardIterator,
2872 typename _UniformRandomNumberGenerator>
2874 __generate(_ForwardIterator __f, _ForwardIterator __t,
2875 _UniformRandomNumberGenerator& __urng)
2876 { this->__generate(__f, __t, __urng, _M_param); }
2878 template<
typename _ForwardIterator,
2879 typename _UniformRandomNumberGenerator>
2881 __generate(_ForwardIterator __f, _ForwardIterator __t,
2882 _UniformRandomNumberGenerator& __urng,
2884 { this->__generate_impl(__f, __t, __urng, __p); }
2886 template<
typename _UniformRandomNumberGenerator>
2888 __generate(result_type* __f, result_type* __t,
2889 _UniformRandomNumberGenerator& __urng,
2891 { this->__generate_impl(__f, __t, __urng, __p); }
2900 {
return __d1._M_param == __d2._M_param; }
2903 template<
typename _ForwardIterator,
2904 typename _UniformRandomNumberGenerator>
2906 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2907 _UniformRandomNumberGenerator& __urng,
2917 template<
typename _RealType>
2921 {
return !(__d1 == __d2); }
2933 template<
typename _RealType,
typename _CharT,
typename _Traits>
2935 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2948 template<
typename _RealType,
typename _CharT,
typename _Traits>
2964 template<
typename _RealType =
double>
2968 "template argument not a floating point type");
2980 _RealType __n = _RealType(1))
2981 : _M_m(__m), _M_n(__n)
2994 {
return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3003 _RealType __n = _RealType(1))
3004 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3009 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3027 {
return _M_param.m(); }
3031 {
return _M_param.n(); }
3038 {
return _M_param; }
3046 { _M_param = __param; }
3053 {
return result_type(0); }
3065 template<
typename _UniformRandomNumberGenerator>
3068 {
return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3070 template<
typename _UniformRandomNumberGenerator>
3072 operator()(_UniformRandomNumberGenerator& __urng,
3077 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3078 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3081 template<
typename _ForwardIterator,
3082 typename _UniformRandomNumberGenerator>
3084 __generate(_ForwardIterator __f, _ForwardIterator __t,
3085 _UniformRandomNumberGenerator& __urng)
3086 { this->__generate_impl(__f, __t, __urng); }
3088 template<
typename _ForwardIterator,
3089 typename _UniformRandomNumberGenerator>
3091 __generate(_ForwardIterator __f, _ForwardIterator __t,
3092 _UniformRandomNumberGenerator& __urng,
3094 { this->__generate_impl(__f, __t, __urng, __p); }
3096 template<
typename _UniformRandomNumberGenerator>
3098 __generate(result_type* __f, result_type* __t,
3099 _UniformRandomNumberGenerator& __urng)
3100 { this->__generate_impl(__f, __t, __urng); }
3102 template<
typename _UniformRandomNumberGenerator>
3104 __generate(result_type* __f, result_type* __t,
3105 _UniformRandomNumberGenerator& __urng,
3107 { this->__generate_impl(__f, __t, __urng, __p); }
3117 {
return (__d1._M_param == __d2._M_param
3118 && __d1._M_gd_x == __d2._M_gd_x
3119 && __d1._M_gd_y == __d2._M_gd_y); }
3131 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3133 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3146 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3152 template<
typename _ForwardIterator,
3153 typename _UniformRandomNumberGenerator>
3155 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3156 _UniformRandomNumberGenerator& __urng);
3158 template<
typename _ForwardIterator,
3159 typename _UniformRandomNumberGenerator>
3161 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3162 _UniformRandomNumberGenerator& __urng,
3173 template<
typename _RealType>
3177 {
return !(__d1 == __d2); }
3188 template<
typename _RealType =
double>
3192 "template argument not a floating point type");
3213 {
return __p1._M_n == __p2._M_n; }
3221 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3226 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3244 {
return _M_param.n(); }
3251 {
return _M_param; }
3259 { _M_param = __param; }
3278 template<
typename _UniformRandomNumberGenerator>
3281 {
return _M_nd(__urng) *
std::sqrt(n() / _M_gd(__urng)); }
3283 template<
typename _UniformRandomNumberGenerator>
3285 operator()(_UniformRandomNumberGenerator& __urng,
3291 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3292 return _M_nd(__urng) *
std::sqrt(__p.n() / __g);
3295 template<
typename _ForwardIterator,
3296 typename _UniformRandomNumberGenerator>
3298 __generate(_ForwardIterator __f, _ForwardIterator __t,
3299 _UniformRandomNumberGenerator& __urng)
3300 { this->__generate_impl(__f, __t, __urng); }
3302 template<
typename _ForwardIterator,
3303 typename _UniformRandomNumberGenerator>
3305 __generate(_ForwardIterator __f, _ForwardIterator __t,
3306 _UniformRandomNumberGenerator& __urng,
3308 { this->__generate_impl(__f, __t, __urng, __p); }
3310 template<
typename _UniformRandomNumberGenerator>
3312 __generate(result_type* __f, result_type* __t,
3313 _UniformRandomNumberGenerator& __urng)
3314 { this->__generate_impl(__f, __t, __urng); }
3316 template<
typename _UniformRandomNumberGenerator>
3318 __generate(result_type* __f, result_type* __t,
3319 _UniformRandomNumberGenerator& __urng,
3321 { this->__generate_impl(__f, __t, __urng, __p); }
3331 {
return (__d1._M_param == __d2._M_param
3332 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3344 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3346 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3359 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3365 template<
typename _ForwardIterator,
3366 typename _UniformRandomNumberGenerator>
3368 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3369 _UniformRandomNumberGenerator& __urng);
3370 template<
typename _ForwardIterator,
3371 typename _UniformRandomNumberGenerator>
3373 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3374 _UniformRandomNumberGenerator& __urng,
3386 template<
typename _RealType>
3390 {
return !(__d1 == __d2); }
3421 _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
3430 {
return __p1._M_p == __p2._M_p; }
3466 {
return _M_param.p(); }
3473 {
return _M_param; }
3481 { _M_param = __param; }
3500 template<
typename _UniformRandomNumberGenerator>
3503 {
return this->operator()(__urng, _M_param); }
3505 template<
typename _UniformRandomNumberGenerator>
3507 operator()(_UniformRandomNumberGenerator& __urng,
3510 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3512 if ((__aurng() - __aurng.min())
3513 < __p.p() * (__aurng.max() - __aurng.min()))
3518 template<
typename _ForwardIterator,
3519 typename _UniformRandomNumberGenerator>
3521 __generate(_ForwardIterator __f, _ForwardIterator __t,
3522 _UniformRandomNumberGenerator& __urng)
3523 { this->__generate(__f, __t, __urng, _M_param); }
3525 template<
typename _ForwardIterator,
3526 typename _UniformRandomNumberGenerator>
3528 __generate(_ForwardIterator __f, _ForwardIterator __t,
3529 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3530 { this->__generate_impl(__f, __t, __urng, __p); }
3532 template<
typename _UniformRandomNumberGenerator>
3534 __generate(result_type* __f, result_type* __t,
3535 _UniformRandomNumberGenerator& __urng,
3537 { this->__generate_impl(__f, __t, __urng, __p); }
3546 {
return __d1._M_param == __d2._M_param; }
3549 template<
typename _ForwardIterator,
3550 typename _UniformRandomNumberGenerator>
3552 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3553 _UniformRandomNumberGenerator& __urng,
3566 {
return !(__d1 == __d2); }
3578 template<
typename _CharT,
typename _Traits>
3580 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3592 template<
typename _CharT,
typename _Traits>
3611 template<
typename _IntType =
int>
3615 "template argument not an integral type");
3627 param_type(_IntType __t = _IntType(1),
double __p = 0.5)
3628 : _M_t(__t), _M_p(__p)
3630 _GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0))
3645 operator==(
const param_type& __p1,
const param_type& __p2)
3646 {
return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3656 #if _GLIBCXX_USE_C99_MATH_TR1 3657 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
3658 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
3667 : _M_param(__t, __p), _M_nd()
3672 : _M_param(__p), _M_nd()
3687 {
return _M_param.t(); }
3694 {
return _M_param.p(); }
3701 {
return _M_param; }
3709 { _M_param = __param; }
3723 {
return _M_param.t(); }
3728 template<
typename _UniformRandomNumberGenerator>
3731 {
return this->operator()(__urng, _M_param); }
3733 template<
typename _UniformRandomNumberGenerator>
3735 operator()(_UniformRandomNumberGenerator& __urng,
3738 template<
typename _ForwardIterator,
3739 typename _UniformRandomNumberGenerator>
3741 __generate(_ForwardIterator __f, _ForwardIterator __t,
3742 _UniformRandomNumberGenerator& __urng)
3743 { this->__generate(__f, __t, __urng, _M_param); }
3745 template<
typename _ForwardIterator,
3746 typename _UniformRandomNumberGenerator>
3748 __generate(_ForwardIterator __f, _ForwardIterator __t,
3749 _UniformRandomNumberGenerator& __urng,
3751 { this->__generate_impl(__f, __t, __urng, __p); }
3753 template<
typename _UniformRandomNumberGenerator>
3756 _UniformRandomNumberGenerator& __urng,
3758 { this->__generate_impl(__f, __t, __urng, __p); }
3768 #ifdef _GLIBCXX_USE_C99_MATH_TR1 3769 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
3771 {
return __d1._M_param == __d2._M_param; }
3784 template<
typename _IntType1,
3785 typename _CharT,
typename _Traits>
3787 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3800 template<
typename _IntType1,
3801 typename _CharT,
typename _Traits>
3807 template<
typename _ForwardIterator,
3808 typename _UniformRandomNumberGenerator>
3810 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3811 _UniformRandomNumberGenerator& __urng,
3814 template<
typename _UniformRandomNumberGenerator>
3816 _M_waiting(_UniformRandomNumberGenerator& __urng,
3817 _IntType __t,
double __q);
3828 template<
typename _IntType>
3832 {
return !(__d1 == __d2); }
3842 template<
typename _IntType =
int>
3846 "template argument not an integral type");
3861 _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
3870 operator==(
const param_type& __p1,
const param_type& __p2)
3871 {
return __p1._M_p == __p2._M_p; }
3876 { _M_log_1_p =
std::log(1.0 - _M_p); }
3907 {
return _M_param.p(); }
3914 {
return _M_param; }
3922 { _M_param = __param; }
3941 template<
typename _UniformRandomNumberGenerator>
3944 {
return this->operator()(__urng, _M_param); }
3946 template<
typename _UniformRandomNumberGenerator>
3948 operator()(_UniformRandomNumberGenerator& __urng,
3951 template<
typename _ForwardIterator,
3952 typename _UniformRandomNumberGenerator>
3954 __generate(_ForwardIterator __f, _ForwardIterator __t,
3955 _UniformRandomNumberGenerator& __urng)
3956 { this->__generate(__f, __t, __urng, _M_param); }
3958 template<
typename _ForwardIterator,
3959 typename _UniformRandomNumberGenerator>
3961 __generate(_ForwardIterator __f, _ForwardIterator __t,
3962 _UniformRandomNumberGenerator& __urng,
3964 { this->__generate_impl(__f, __t, __urng, __p); }
3966 template<
typename _UniformRandomNumberGenerator>
3969 _UniformRandomNumberGenerator& __urng,
3971 { this->__generate_impl(__f, __t, __urng, __p); }
3980 {
return __d1._M_param == __d2._M_param; }
3983 template<
typename _ForwardIterator,
3984 typename _UniformRandomNumberGenerator>
3986 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3987 _UniformRandomNumberGenerator& __urng,
3997 template<
typename _IntType>
4001 {
return !(__d1 == __d2); }
4013 template<
typename _IntType,
4014 typename _CharT,
typename _Traits>
4016 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4028 template<
typename _IntType,
4029 typename _CharT,
typename _Traits>
4042 template<
typename _IntType =
int>
4046 "template argument not an integral type");
4057 param_type(_IntType __k = 1,
double __p = 0.5)
4058 : _M_k(__k), _M_p(__p)
4060 _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4073 {
return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4082 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4087 : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
4102 {
return _M_param.k(); }
4109 {
return _M_param.p(); }
4116 {
return _M_param; }
4124 { _M_param = __param; }
4143 template<
typename _UniformRandomNumberGenerator>
4145 operator()(_UniformRandomNumberGenerator& __urng);
4147 template<
typename _UniformRandomNumberGenerator>
4149 operator()(_UniformRandomNumberGenerator& __urng,
4152 template<
typename _ForwardIterator,
4153 typename _UniformRandomNumberGenerator>
4155 __generate(_ForwardIterator __f, _ForwardIterator __t,
4156 _UniformRandomNumberGenerator& __urng)
4157 { this->__generate_impl(__f, __t, __urng); }
4159 template<
typename _ForwardIterator,
4160 typename _UniformRandomNumberGenerator>
4162 __generate(_ForwardIterator __f, _ForwardIterator __t,
4163 _UniformRandomNumberGenerator& __urng,
4165 { this->__generate_impl(__f, __t, __urng, __p); }
4167 template<
typename _UniformRandomNumberGenerator>
4170 _UniformRandomNumberGenerator& __urng)
4171 { this->__generate_impl(__f, __t, __urng); }
4173 template<
typename _UniformRandomNumberGenerator>
4176 _UniformRandomNumberGenerator& __urng,
4178 { this->__generate_impl(__f, __t, __urng, __p); }
4188 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4201 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4203 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4216 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4222 template<
typename _ForwardIterator,
4223 typename _UniformRandomNumberGenerator>
4225 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4226 _UniformRandomNumberGenerator& __urng);
4227 template<
typename _ForwardIterator,
4228 typename _UniformRandomNumberGenerator>
4230 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4231 _UniformRandomNumberGenerator& __urng,
4242 template<
typename _IntType>
4246 {
return !(__d1 == __d2); }
4264 template<
typename _IntType =
int>
4268 "template argument not an integral type");
4283 _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
4292 operator==(
const param_type& __p1,
const param_type& __p2)
4293 {
return __p1._M_mean == __p2._M_mean; }
4303 #if _GLIBCXX_USE_C99_MATH_TR1 4304 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4311 : _M_param(__mean), _M_nd()
4316 : _M_param(__p), _M_nd()
4331 {
return _M_param.mean(); }
4338 {
return _M_param; }
4346 { _M_param = __param; }
4365 template<
typename _UniformRandomNumberGenerator>
4368 {
return this->operator()(__urng, _M_param); }
4370 template<
typename _UniformRandomNumberGenerator>
4372 operator()(_UniformRandomNumberGenerator& __urng,
4375 template<
typename _ForwardIterator,
4376 typename _UniformRandomNumberGenerator>
4378 __generate(_ForwardIterator __f, _ForwardIterator __t,
4379 _UniformRandomNumberGenerator& __urng)
4380 { this->__generate(__f, __t, __urng, _M_param); }
4382 template<
typename _ForwardIterator,
4383 typename _UniformRandomNumberGenerator>
4385 __generate(_ForwardIterator __f, _ForwardIterator __t,
4386 _UniformRandomNumberGenerator& __urng,
4388 { this->__generate_impl(__f, __t, __urng, __p); }
4390 template<
typename _UniformRandomNumberGenerator>
4393 _UniformRandomNumberGenerator& __urng,
4395 { this->__generate_impl(__f, __t, __urng, __p); }
4405 #ifdef _GLIBCXX_USE_C99_MATH_TR1 4406 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4408 {
return __d1._M_param == __d2._M_param; }
4421 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4423 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4436 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4442 template<
typename _ForwardIterator,
4443 typename _UniformRandomNumberGenerator>
4445 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4446 _UniformRandomNumberGenerator& __urng,
4458 template<
typename _IntType>
4462 {
return !(__d1 == __d2); }
4480 template<
typename _RealType =
double>
4484 "template argument not a floating point type");
4495 param_type(_RealType __lambda = _RealType(1))
4496 : _M_lambda(__lambda)
4498 _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0));
4503 {
return _M_lambda; }
4507 {
return __p1._M_lambda == __p2._M_lambda; }
4510 _RealType _M_lambda;
4520 : _M_param(__lambda)
4541 {
return _M_param.lambda(); }
4548 {
return _M_param; }
4556 { _M_param = __param; }
4575 template<
typename _UniformRandomNumberGenerator>
4578 {
return this->operator()(__urng, _M_param); }
4580 template<
typename _UniformRandomNumberGenerator>
4582 operator()(_UniformRandomNumberGenerator& __urng,
4585 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4590 template<
typename _ForwardIterator,
4591 typename _UniformRandomNumberGenerator>
4593 __generate(_ForwardIterator __f, _ForwardIterator __t,
4594 _UniformRandomNumberGenerator& __urng)
4595 { this->__generate(__f, __t, __urng, _M_param); }
4597 template<
typename _ForwardIterator,
4598 typename _UniformRandomNumberGenerator>
4600 __generate(_ForwardIterator __f, _ForwardIterator __t,
4601 _UniformRandomNumberGenerator& __urng,
4603 { this->__generate_impl(__f, __t, __urng, __p); }
4605 template<
typename _UniformRandomNumberGenerator>
4608 _UniformRandomNumberGenerator& __urng,
4610 { this->__generate_impl(__f, __t, __urng, __p); }
4619 {
return __d1._M_param == __d2._M_param; }
4622 template<
typename _ForwardIterator,
4623 typename _UniformRandomNumberGenerator>
4625 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4626 _UniformRandomNumberGenerator& __urng,
4636 template<
typename _RealType>
4640 {
return !(__d1 == __d2); }
4652 template<
typename _RealType,
typename _CharT,
typename _Traits>
4654 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4667 template<
typename _RealType,
typename _CharT,
typename _Traits>
4682 template<
typename _RealType =
double>
4686 "template argument not a floating point type");
4698 _RealType __b = _RealType(1))
4699 : _M_a(__a), _M_b(__b)
4712 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
4721 _RealType __b = _RealType(1))
4722 : _M_param(__a, __b)
4742 {
return _M_param.a(); }
4749 {
return _M_param.b(); }
4756 {
return _M_param; }
4764 { _M_param = __param; }
4783 template<
typename _UniformRandomNumberGenerator>
4786 {
return this->operator()(__urng, _M_param); }
4788 template<
typename _UniformRandomNumberGenerator>
4790 operator()(_UniformRandomNumberGenerator& __urng,
4793 template<
typename _ForwardIterator,
4794 typename _UniformRandomNumberGenerator>
4796 __generate(_ForwardIterator __f, _ForwardIterator __t,
4797 _UniformRandomNumberGenerator& __urng)
4798 { this->__generate(__f, __t, __urng, _M_param); }
4800 template<
typename _ForwardIterator,
4801 typename _UniformRandomNumberGenerator>
4803 __generate(_ForwardIterator __f, _ForwardIterator __t,
4804 _UniformRandomNumberGenerator& __urng,
4806 { this->__generate_impl(__f, __t, __urng, __p); }
4808 template<
typename _UniformRandomNumberGenerator>
4811 _UniformRandomNumberGenerator& __urng,
4813 { this->__generate_impl(__f, __t, __urng, __p); }
4822 {
return __d1._M_param == __d2._M_param; }
4825 template<
typename _ForwardIterator,
4826 typename _UniformRandomNumberGenerator>
4828 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4829 _UniformRandomNumberGenerator& __urng,
4839 template<
typename _RealType>
4843 {
return !(__d1 == __d2); }
4855 template<
typename _RealType,
typename _CharT,
typename _Traits>
4857 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4870 template<
typename _RealType,
typename _CharT,
typename _Traits>
4885 template<
typename _RealType =
double>
4889 "template argument not a floating point type");
4901 _RealType __b = _RealType(1))
4902 : _M_a(__a), _M_b(__b)
4915 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
4924 _RealType __b = _RealType(1))
4925 : _M_param(__a, __b)
4945 {
return _M_param.a(); }
4952 {
return _M_param.b(); }
4959 {
return _M_param; }
4967 { _M_param = __param; }
4986 template<
typename _UniformRandomNumberGenerator>
4989 {
return this->operator()(__urng, _M_param); }
4991 template<
typename _UniformRandomNumberGenerator>
4993 operator()(_UniformRandomNumberGenerator& __urng,
4996 template<
typename _ForwardIterator,
4997 typename _UniformRandomNumberGenerator>
4999 __generate(_ForwardIterator __f, _ForwardIterator __t,
5000 _UniformRandomNumberGenerator& __urng)
5001 { this->__generate(__f, __t, __urng, _M_param); }
5003 template<
typename _ForwardIterator,
5004 typename _UniformRandomNumberGenerator>
5006 __generate(_ForwardIterator __f, _ForwardIterator __t,
5007 _UniformRandomNumberGenerator& __urng,
5009 { this->__generate_impl(__f, __t, __urng, __p); }
5011 template<
typename _UniformRandomNumberGenerator>
5014 _UniformRandomNumberGenerator& __urng,
5016 { this->__generate_impl(__f, __t, __urng, __p); }
5025 {
return __d1._M_param == __d2._M_param; }
5028 template<
typename _ForwardIterator,
5029 typename _UniformRandomNumberGenerator>
5031 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5032 _UniformRandomNumberGenerator& __urng,
5042 template<
typename _RealType>
5046 {
return !(__d1 == __d2); }
5058 template<
typename _RealType,
typename _CharT,
typename _Traits>
5060 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5073 template<
typename _RealType,
typename _CharT,
typename _Traits>
5085 template<
typename _IntType =
int>
5089 "template argument not an integral type");
5101 : _M_prob(), _M_cp()
5104 template<
typename _InputIterator>
5105 param_type(_InputIterator __wbegin,
5106 _InputIterator __wend)
5107 : _M_prob(__wbegin, __wend), _M_cp()
5108 { _M_initialize(); }
5111 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5112 { _M_initialize(); }
5114 template<
typename _Func>
5115 param_type(
size_t __nw,
double __xmin,
double __xmax,
5119 param_type(
const param_type&) =
default;
5120 param_type& operator=(
const param_type&) =
default;
5123 probabilities()
const 5127 operator==(
const param_type& __p1,
const param_type& __p2)
5128 {
return __p1._M_prob == __p2._M_prob; }
5142 template<
typename _InputIterator>
5144 _InputIterator __wend)
5145 : _M_param(__wbegin, __wend)
5152 template<
typename _Func>
5155 : _M_param(__nw, __xmin, __xmax, __fw)
5176 return _M_param._M_prob.empty()
5185 {
return _M_param; }
5193 { _M_param = __param; }
5208 return _M_param._M_prob.empty()
5215 template<
typename _UniformRandomNumberGenerator>
5218 {
return this->operator()(__urng, _M_param); }
5220 template<
typename _UniformRandomNumberGenerator>
5222 operator()(_UniformRandomNumberGenerator& __urng,
5225 template<
typename _ForwardIterator,
5226 typename _UniformRandomNumberGenerator>
5228 __generate(_ForwardIterator __f, _ForwardIterator __t,
5229 _UniformRandomNumberGenerator& __urng)
5230 { this->__generate(__f, __t, __urng, _M_param); }
5232 template<
typename _ForwardIterator,
5233 typename _UniformRandomNumberGenerator>
5235 __generate(_ForwardIterator __f, _ForwardIterator __t,
5236 _UniformRandomNumberGenerator& __urng,
5238 { this->__generate_impl(__f, __t, __urng, __p); }
5240 template<
typename _UniformRandomNumberGenerator>
5243 _UniformRandomNumberGenerator& __urng,
5245 { this->__generate_impl(__f, __t, __urng, __p); }
5254 {
return __d1._M_param == __d2._M_param; }
5266 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5268 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5282 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5288 template<
typename _ForwardIterator,
5289 typename _UniformRandomNumberGenerator>
5291 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5292 _UniformRandomNumberGenerator& __urng,
5302 template<
typename _IntType>
5306 {
return !(__d1 == __d2); }
5315 template<
typename _RealType =
double>
5319 "template argument not a floating point type");
5331 : _M_int(), _M_den(), _M_cp()
5334 template<
typename _InputIteratorB,
typename _InputIteratorW>
5335 param_type(_InputIteratorB __bfirst,
5336 _InputIteratorB __bend,
5337 _InputIteratorW __wbegin);
5339 template<
typename _Func>
5342 template<
typename _Func>
5343 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5347 param_type(
const param_type&) =
default;
5348 param_type& operator=(
const param_type&) =
default;
5356 __tmp[1] = _RealType(1);
5368 operator==(
const param_type& __p1,
const param_type& __p2)
5369 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5385 template<
typename _InputIteratorB,
typename _InputIteratorW>
5387 _InputIteratorB __bend,
5388 _InputIteratorW __wbegin)
5389 : _M_param(__bfirst, __bend, __wbegin)
5392 template<
typename _Func>
5395 : _M_param(__bl, __fw)
5398 template<
typename _Func>
5400 _RealType __xmin, _RealType __xmax,
5402 : _M_param(__nw, __xmin, __xmax, __fw)
5423 if (_M_param._M_int.empty())
5426 __tmp[1] = _RealType(1);
5430 return _M_param._M_int;
5439 return _M_param._M_den.empty()
5448 {
return _M_param; }
5456 { _M_param = __param; }
5464 return _M_param._M_int.empty()
5474 return _M_param._M_int.empty()
5481 template<
typename _UniformRandomNumberGenerator>
5484 {
return this->operator()(__urng, _M_param); }
5486 template<
typename _UniformRandomNumberGenerator>
5488 operator()(_UniformRandomNumberGenerator& __urng,
5491 template<
typename _ForwardIterator,
5492 typename _UniformRandomNumberGenerator>
5494 __generate(_ForwardIterator __f, _ForwardIterator __t,
5495 _UniformRandomNumberGenerator& __urng)
5496 { this->__generate(__f, __t, __urng, _M_param); }
5498 template<
typename _ForwardIterator,
5499 typename _UniformRandomNumberGenerator>
5501 __generate(_ForwardIterator __f, _ForwardIterator __t,
5502 _UniformRandomNumberGenerator& __urng,
5504 { this->__generate_impl(__f, __t, __urng, __p); }
5506 template<
typename _UniformRandomNumberGenerator>
5509 _UniformRandomNumberGenerator& __urng,
5511 { this->__generate_impl(__f, __t, __urng, __p); }
5520 {
return __d1._M_param == __d2._M_param; }
5533 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5535 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5549 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5555 template<
typename _ForwardIterator,
5556 typename _UniformRandomNumberGenerator>
5558 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5559 _UniformRandomNumberGenerator& __urng,
5569 template<
typename _RealType>
5573 {
return !(__d1 == __d2); }
5582 template<
typename _RealType =
double>
5586 "template argument not a floating point type");
5598 : _M_int(), _M_den(), _M_cp(), _M_m()
5601 template<
typename _InputIteratorB,
typename _InputIteratorW>
5602 param_type(_InputIteratorB __bfirst,
5603 _InputIteratorB __bend,
5604 _InputIteratorW __wbegin);
5606 template<
typename _Func>
5609 template<
typename _Func>
5610 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5614 param_type(
const param_type&) =
default;
5615 param_type& operator=(
const param_type&) =
default;
5623 __tmp[1] = _RealType(1);
5635 operator==(
const param_type& __p1,
const param_type& __p2)
5636 {
return (__p1._M_int == __p2._M_int
5637 && __p1._M_den == __p2._M_den); }
5654 template<
typename _InputIteratorB,
typename _InputIteratorW>
5656 _InputIteratorB __bend,
5657 _InputIteratorW __wbegin)
5658 : _M_param(__bfirst, __bend, __wbegin)
5661 template<
typename _Func>
5664 : _M_param(__bl, __fw)
5667 template<
typename _Func>
5669 _RealType __xmin, _RealType __xmax,
5671 : _M_param(__nw, __xmin, __xmax, __fw)
5692 if (_M_param._M_int.
empty())
5695 __tmp[1] = _RealType(1);
5699 return _M_param._M_int;
5709 return _M_param._M_den.
empty()
5718 {
return _M_param; }
5726 { _M_param = __param; }
5734 return _M_param._M_int.
empty()
5744 return _M_param._M_int.
empty()
5751 template<
typename _UniformRandomNumberGenerator>
5754 {
return this->operator()(__urng, _M_param); }
5756 template<
typename _UniformRandomNumberGenerator>
5758 operator()(_UniformRandomNumberGenerator& __urng,
5761 template<
typename _ForwardIterator,
5762 typename _UniformRandomNumberGenerator>
5764 __generate(_ForwardIterator __f, _ForwardIterator __t,
5765 _UniformRandomNumberGenerator& __urng)
5766 { this->__generate(__f, __t, __urng, _M_param); }
5768 template<
typename _ForwardIterator,
5769 typename _UniformRandomNumberGenerator>
5771 __generate(_ForwardIterator __f, _ForwardIterator __t,
5772 _UniformRandomNumberGenerator& __urng,
5774 { this->__generate_impl(__f, __t, __urng, __p); }
5776 template<
typename _UniformRandomNumberGenerator>
5779 _UniformRandomNumberGenerator& __urng,
5781 { this->__generate_impl(__f, __t, __urng, __p); }
5790 {
return __d1._M_param == __d2._M_param; }
5803 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5805 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5819 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5825 template<
typename _ForwardIterator,
5826 typename _UniformRandomNumberGenerator>
5828 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5829 _UniformRandomNumberGenerator& __urng,
5839 template<
typename _RealType>
5843 {
return !(__d1 == __d2); }
5872 template<
typename _IntType>
5875 template<
typename _InputIterator>
5876 seed_seq(_InputIterator __begin, _InputIterator __end);
5879 template<
typename _RandomAccessIterator>
5881 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
5885 {
return _M_v.size(); }
5887 template<
typename OutputIterator>
5889 param(OutputIterator __dest)
const 5890 { std::copy(_M_v.begin(), _M_v.end(), __dest); }
5901 _GLIBCXX_END_NAMESPACE_VERSION
void seed()
Reseeds the discard_block_engine object with the default seed for the underlying base class generator...
independent_bits_engine(_Sseq &__q)
Generator construct a independent_bits_engine engine.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend bool operator==(const piecewise_constant_distribution &__d1, const piecewise_constant_distribution &__d2)
Return true if two piecewise constant distributions have the same parameters.
friend bool operator==(const discard_block_engine &__lhs, const discard_block_engine &__rhs)
Compares two discard_block_engine random number generator objects of the same type for equality...
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
mersenne_twister_engine(_Sseq &__q)
Constructs a mersenne_twister_engine random number generator engine seeded from the seed sequence __q...
param_type param() const
Returns the parameter set of the distribution.
void reset()
Resets the distribution state.
void reset()
Resets the distribution state.
_RealType lambda() const
Returns the inverse scale parameter of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
static constexpr result_type min()
Gets the smallest possible value in the output range.
independent_bits_engine(const _RandomNumberEngine &__rng)
Copy constructs a independent_bits_engine engine.
std::vector< _RealType > intervals() const
Return the intervals of the distribution.
_IntType t() const
Returns the distribution t parameter.
param_type param() const
Returns the parameter set of the distribution.
subtract_with_carry_engine(result_type __sd=default_seed)
Constructs an explicitly seeded % subtract_with_carry_engine random number generator.
A piecewise_constant_distribution random number distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
double p() const
Return the parameter of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Template class basic_ostream.
_GLIBCXX14_CONSTEXPR const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
void param(const param_type &__param)
Sets the parameter set of the distribution.
param_type param() const
Returns the parameter set of the distribution.
__gnu_cxx::__promote_2< _Tpx, _Tpy >::__type beta(_Tpx __x, _Tpy __y)
5.2.1.3 Beta functions.
_RealType mean() const
Returns the mean of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
friend bool operator==(const bernoulli_distribution &__d1, const bernoulli_distribution &__d2)
Return true if two Bernoulli distributions have the same parameters.
_RandomNumberEngine::result_type result_type
constexpr int __lg(int __n)
This is a helper function for the sort routines and for random.tcc.
friend bool operator==(const uniform_real_distribution &__d1, const uniform_real_distribution &__d2)
Return true if two uniform real distributions have the same parameters.
void param(const param_type &__param)
Sets the parameter set of the distribution.
param_type param() const
Returns the parameter set of the distribution.
normal_distribution(result_type __mean=result_type(0), result_type __stddev=result_type(1))
void seed(_Sseq &__q)
Reseeds the discard_block_engine object with the given seed sequence.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend bool operator==(const subtract_with_carry_engine &__lhs, const subtract_with_carry_engine &__rhs)
Compares two % subtract_with_carry_engine random number generator objects of the same type for equali...
A student_t_distribution random number distribution.
bernoulli_distribution(double __p=0.5)
Constructs a Bernoulli distribution with likelihood p.
result_type max() const
Returns the least upper bound value of the distribution.
independent_bits_engine()
Constructs a default independent_bits_engine engine.
independent_bits_engine(_RandomNumberEngine &&__rng)
Move constructs a independent_bits_engine engine.
result_type min() const
Returns the greatest lower bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
std::vector< double > densities() const
Return a vector of the probability densities of the distribution.
void reset()
Resets the distribution state.
result_type min() const
Returns the inclusive lower bound of the distribution range.
result_type min() const
Returns the greatest lower bound value of the distribution.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, const _Quoted_string< basic_string< _CharT, _Traits, _Alloc > &, _CharT > &__str)
Extractor for delimited strings. The left and right delimiters can be different.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
_RealType alpha() const
Returns the of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
static constexpr result_type min()
Gets the minimum value in the generated random number range.
friend bool operator==(const negative_binomial_distribution &__d1, const negative_binomial_distribution &__d2)
Return true if two negative binomial distributions have the same parameters and the sequences that wo...
A gamma continuous distribution for random numbers.
result_type max() const
Returns the least upper bound value of the distribution.
friend bool operator==(const gamma_distribution &__d1, const gamma_distribution &__d2)
Return true if two gamma distributions have the same parameters and the sequences that would be gener...
result_type min() const
Returns the greatest lower bound value of the distribution.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
const _RandomNumberEngine & base() const noexcept
Gets a const reference to the underlying generator engine object.
param_type param() const
Returns the parameter set of the distribution.
The Marsaglia-Zaman generator.
void seed(result_type __s)
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
friend bool operator==(const independent_bits_engine &__lhs, const independent_bits_engine &__rhs)
Compares two independent_bits_engine random number generator objects of the same type for equality...
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
gamma_distribution(_RealType __alpha_val=_RealType(1), _RealType __beta_val=_RealType(1))
Constructs a gamma distribution with parameters and .
param_type param() const
Returns the parameter set of the distribution.
double p() const
Returns the distribution p parameter.
result_type max() const
Returns the least upper bound value of the distribution.
uniform_real_distribution(_RealType __a=_RealType(0), _RealType __b=_RealType(1))
Constructs a uniform_real_distribution object.
result_type min() const
Returns the greatest lower bound value of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
uint_least32_t result_type
result_type min() const
Returns the greatest lower bound value of the distribution.
param_type param() const
Returns the parameter set of the distribution.
discard_block_engine(_RandomNumberEngine &&__rng)
Move constructs a discard_block_engine engine.
result_type max() const
Returns the least upper bound value of the distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
shuffle_order_engine()
Constructs a default shuffle_order_engine engine.
void seed(_Sseq &__q)
Reseeds the shuffle_order_engine object with the given seed sequence.
_RealType a() const
Return the parameter of the distribution.
friend bool operator==(const poisson_distribution &__d1, const poisson_distribution &__d2)
Return true if two Poisson distributions have the same parameters and the sequences that would be gen...
A piecewise_linear_distribution random number distribution.
A discrete Poisson random number distribution.
void reset()
Resets the distribution state.
A chi_squared_distribution random number distribution.
void discard(unsigned long long __z)
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend bool operator==(const mersenne_twister_engine &__lhs, const mersenne_twister_engine &__rhs)
Compares two % mersenne_twister_engine random number generator objects of the same type for equality...
bool operator!=(const std::piecewise_linear_distribution< _RealType > &__d1, const std::piecewise_linear_distribution< _RealType > &__d2)
Return true if two piecewise linear distributions have different parameters.
_GLIBCXX14_CONSTEXPR const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
A extreme_value_distribution random number distribution.
param_type param() const
Returns the parameter set of the distribution.
linear_congruential_engine< uint_fast32_t, 48271UL, 0UL, 2147483647UL > minstd_rand
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
void seed()
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
friend bool operator==(const fisher_f_distribution &__d1, const fisher_f_distribution &__d2)
Return true if two Fisher f distributions have the same parameters and the sequences that would be ge...
friend bool operator==(const shuffle_order_engine &__lhs, const shuffle_order_engine &__rhs)
linear_congruential_engine< uint_fast32_t, 16807UL, 0UL, 2147483647UL > minstd_rand0
param_type param() const
Returns the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
A Bernoulli random number distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
param_type param() const
Returns the parameter set of the distribution.
double mean() const
Returns the distribution parameter mean.
_IntType k() const
Return the parameter of the distribution.
The seed_seq class generates sequences of seeds for random number generators.
friend bool operator==(const chi_squared_distribution &__d1, const chi_squared_distribution &__d2)
Return true if two Chi-squared distributions have the same parameters and the sequences that would be...
A cauchy_distribution random number distribution.
_RealType beta() const
Returns the of the distribution.
linear_congruential_engine(result_type __s=default_seed)
Constructs a linear_congruential_engine random number generator engine with seed __s. The default seed value is 1.
friend bool operator==(const exponential_distribution &__d1, const exponential_distribution &__d2)
Return true if two exponential distributions have the same parameters.
Uniform discrete distribution for random numbers.
void seed()
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
result_type min() const
Returns the greatest lower bound value of the distribution.
ISO C++ entities toplevel namespace is std.
param_type param() const
Returns the parameter set of the distribution.
mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > mt19937
void param(const param_type &__param)
Sets the parameter set of the distribution.
param_type param() const
Returns the parameter set of the distribution.
A discrete_distribution random number distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
double p() const
Returns the distribution parameter p.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
result_type max() const
Returns the least upper bound value of the distribution.
bool empty() const noexcept
static constexpr _Tp min() noexcept
result_type max() const
Returns the least upper bound value of the distribution.
A discrete binomial random number distribution.
param_type param() const
Returns the parameter set of the distribution.
discard_block_engine(_Sseq &__q)
Generator construct a discard_block_engine engine.
std::vector< double > probabilities() const
Returns the probabilities of the distribution.
static constexpr result_type min()
Gets the inclusive minimum value of the range of random integers returned by this generator...
static constexpr result_type max()
Gets the largest possible value in the output range.
_RealType stddev() const
Returns the standard deviation of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
std::vector< double > densities() const
Returns a vector of the probability densities.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
std::vector< _RealType > intervals() const
Returns a vector of the intervals.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::independent_bits_engine< _RandomNumberEngine, __w, _UIntType > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
result_type min() const
Returns the greatest lower bound value of the distribution.
A fisher_f_distribution random number distribution.
const _RandomNumberEngine & base() const noexcept
void reset()
Resets the distribution state.
friend bool operator==(const weibull_distribution &__d1, const weibull_distribution &__d2)
Return true if two Weibull distributions have the same parameters.
static constexpr result_type min()
Gets the smallest possible value in the output range.
reference front() noexcept
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
void param(const param_type &__param)
Sets the parameter set of the distribution.
bool equal(_IIter1 __first1, _IIter1 __last1, _IIter2 __first2, _IIter2 __last2, _BinaryPredicate __binary_pred)
Tests a range for element-wise equality.
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
discard_block_engine(result_type __s)
Seed constructs a discard_block_engine engine.
An exponential continuous distribution for random numbers.
shuffle_order_engine(const _RandomNumberEngine &__rng)
Copy constructs a shuffle_order_engine engine.
void seed(_Sseq &__q)
Reseeds the independent_bits_engine object with the given seed sequence.
static constexpr result_type max()
Gets the inclusive maximum value of the range of random integers returned by this generator...
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
static constexpr result_type max()
Gets the maximum value in the generated random number range.
shuffle_order_engine(_RandomNumberEngine &&__rng)
Move constructs a shuffle_order_engine engine.
friend bool operator==(const geometric_distribution &__d1, const geometric_distribution &__d2)
Return true if two geometric distributions have the same parameters.
void param(const param_type &__param)
Sets the parameter set of the distribution.
A discrete geometric random number distribution.
subtract_with_carry_engine(_Sseq &__q)
Constructs a subtract_with_carry_engine random number engine seeded from the seed sequence __q...
Template class basic_istream.
A model of a linear congruential random number generator.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
_RealType generate_canonical(_UniformRandomNumberGenerator &__g)
A function template for converting the output of a (integral) uniform random number generator to a fl...
mersenne_twister_engine< uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL > mt19937_64
reference back() noexcept
void reset()
Resets the distribution state.
friend bool operator==(const extreme_value_distribution &__d1, const extreme_value_distribution &__d2)
Return true if two extreme value distributions have the same parameters.
static constexpr result_type min()
shuffle_order_engine(result_type __s)
Seed constructs a shuffle_order_engine engine.
static constexpr result_type max()
result_type operator()()
Gets the next random number in the sequence.
A weibull_distribution random number distribution.
friend bool operator==(const student_t_distribution &__d1, const student_t_distribution &__d2)
Return true if two Student t distributions have the same parameters and the sequences that would be g...
param_type param() const
Returns the parameter set of the distribution.
result_type max() const
Returns the inclusive upper bound of the distribution range.
void reset()
Resets the distribution state.
static constexpr result_type min()
Gets the minimum value in the generated random number range.
shuffle_order_engine(_Sseq &__q)
Generator construct a shuffle_order_engine engine.
friend bool operator==(const discrete_distribution &__d1, const discrete_distribution &__d2)
Return true if two discrete distributions have the same parameters.
linear_congruential_engine(_Sseq &__q)
Constructs a linear_congruential_engine random number generator engine seeded from the seed sequence ...
Uniform continuous distribution for random numbers.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void reset()
Resets the distribution state.
A negative_binomial_distribution random number distribution.
discard_block_engine(const _RandomNumberEngine &__rng)
Copy constructs a discard_block_engine engine.
Produces random numbers by combining random numbers from some base engine to produce random numbers w...
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
friend bool operator==(const cauchy_distribution &__d1, const cauchy_distribution &__d2)
Return true if two Cauchy distributions have the same parameters.
friend bool operator==(const lognormal_distribution &__d1, const lognormal_distribution &__d2)
Return true if two lognormal distributions have the same parameters and the sequences that would be g...
One of the math functors.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const binomial_distribution &__d1, const binomial_distribution &__d2)
Return true if two binomial distributions have the same parameters and the sequences that would be ge...
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
static constexpr result_type max()
Gets the largest possible value in the output range.
double p() const
Returns the p parameter of the distribution.
Properties of fundamental types.
friend bool operator==(const piecewise_linear_distribution &__d1, const piecewise_linear_distribution &__d2)
Return true if two piecewise linear distributions have the same parameters.
exponential_distribution(const result_type &__lambda=result_type(1))
Constructs an exponential distribution with inverse scale parameter .
friend bool operator==(const linear_congruential_engine &__lhs, const linear_congruential_engine &__rhs)
Compares two linear congruential random number generator objects of the same type for equality...
result_type min() const
Returns the greatest lower bound value of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type max() const
Returns the least upper bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
static constexpr result_type max()
Gets the maximum value in the generated random number range.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void reset()
Resets the distribution state.
A normal continuous distribution for random numbers.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void reset()
Resets the distribution state.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type min() const
Returns the greatest lower bound value of the distribution.
_RealType b() const
Return the parameter of the distribution.
const _RandomNumberEngine & base() const noexcept
Gets a const reference to the underlying generator engine object.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
_RandomNumberEngine::result_type result_type
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void reset()
Resets the distribution state.
result_type min() const
Returns the greatest lower bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
independent_bits_engine(result_type __s)
Seed constructs a independent_bits_engine engine.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
param_type param() const
Returns the parameter set of the distribution.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
static constexpr _Tp max() noexcept
_RealType a() const
Return the parameter of the distribution.
result_type min() const
Returns the greatest lower bound value of the distribution.
discard_block_engine()
Constructs a default discard_block_engine engine.
result_type max() const
Returns the least upper bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
A lognormal_distribution random number distribution.
_RealType b() const
Return the parameter of the distribution.
void seed(result_type __s)
Reseeds the discard_block_engine object with the default seed for the underlying base class generator...
void reset()
Resets the distribution state.
static constexpr _Tp lowest() noexcept
void seed(result_type __s)
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
result_type max() const
Returns the least upper bound value of the distribution.