37namespace std _GLIBCXX_VISIBILITY(default)
39_GLIBCXX_BEGIN_NAMESPACE_VERSION
58 template<
typename _RealType,
size_t __bits,
59 typename _UniformRandomNumberGenerator>
67#pragma GCC diagnostic push
68#pragma GCC diagnostic ignored "-Wc++17-extensions"
70 template<
typename _UIntType,
size_t __w,
71 bool = __w < static_cast<size_t>
74 {
static constexpr _UIntType __value = 0; };
76 template<
typename _UIntType,
size_t __w>
77 struct _Shift<_UIntType, __w, true>
78 {
static constexpr _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 {
using type =
unsigned int; };
97 struct _Select_uint_least_t<__s, 3>
98 {
using type =
unsigned long; };
101 struct _Select_uint_least_t<__s, 2>
102 {
using type =
unsigned long long; };
104#if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
106 struct _Select_uint_least_t<__s, 1>
107 { __extension__
using type =
unsigned __int128; };
108#elif __has_builtin(__builtin_add_overflow) \
109 && __has_builtin(__builtin_sub_overflow) \
110 && defined __UINT64_TYPE__
112 struct _Select_uint_least_t<__s, 1>
119 type(uint64_t __a) noexcept : _M_lo(__a), _M_hi(0) { }
123 operator*(type __l, uint64_t __x)
noexcept
129 constexpr uint64_t __mask = 0xffffffff;
130 uint64_t __ll[2] = { __l._M_lo >> 32, __l._M_lo & __mask };
131 uint64_t __xx[2] = { __x >> 32, __x & __mask };
132 uint64_t __l0x0 = __ll[0] * __xx[0];
133 uint64_t __l0x1 = __ll[0] * __xx[1];
134 uint64_t __l1x0 = __ll[1] * __xx[0];
135 uint64_t __l1x1 = __ll[1] * __xx[1];
139 = (__l0x1 & __mask) + (__l1x0 & __mask) + (__l1x1 >> 32);
140 __l._M_hi = __l0x0 + (__l0x1 >> 32) + (__l1x0 >> 32) + (__mid >> 32);
141 __l._M_lo = (__mid << 32) + (__l1x1 & __mask);
146 operator+(type __l, uint64_t __c)
noexcept
148 __l._M_hi += __builtin_add_overflow(__l._M_lo, __c, &__l._M_lo);
153 operator%(type __l, uint64_t __m)
noexcept
155 if (__builtin_expect(__l._M_hi == 0, 0))
161 int __shift = __builtin_clzll(__m) + 64
162 - __builtin_clzll(__l._M_hi);
166 __x._M_hi = __m << (__shift - 64);
171 __x._M_hi = __m >> (64 - __shift);
172 __x._M_lo = __m << __shift;
175 while (__l._M_hi != 0 || __l._M_lo >= __m)
179 __l._M_hi -= __x._M_hi;
180 __l._M_hi -= __builtin_sub_overflow(__l._M_lo, __x._M_lo,
183 __x._M_lo = (__x._M_lo >> 1) | (__x._M_hi << 63);
190 explicit operator uint64_t() const noexcept
193 friend bool operator<(
const type& __l,
const type& __r)
noexcept
195 if (__l._M_hi < __r._M_hi)
197 else if (__l._M_hi == __r._M_hi)
198 return __l._M_lo < __r._M_lo;
203 friend bool operator<=(
const type& __l,
const type& __r)
noexcept
204 {
return !(__r < __l); }
213 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
214 bool __big_enough = (!(__m & (__m - 1))
215 || (_Tp(-1) - __c) / __a >= __m - 1),
216 bool __schrage_ok = __m % __a < __m / __a>
223 =
typename _Select_uint_least_t<
std::__lg(__a)
225 return static_cast<_Tp
>((_Tp2(__a) * __x + __c) % __m);
230 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
231 struct _Mod<_Tp, __m, __a, __c, false, true>
240 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
241 struct _Mod<_Tp, __m, __a, __c, true, __s>
246 _Tp __res = __a * __x + __c;
253 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
257 if constexpr (__a == 0)
260 return _Mod<_Tp, __m, __a, __c>::__calc(__x);
267 template<
typename _Engine,
typename _DInputType>
271 "template argument must be a floating point type");
274 _Adaptor(_Engine& __g)
279 {
return _DInputType(0); }
283 {
return _DInputType(1); }
307 template<
typename _Sseq>
308 using __seed_seq_generate_t =
decltype(
309 std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
310 std::declval<uint_least32_t*>()));
312 template<
typename _Sseq,
typename _Engine,
typename _Res,
313 typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
314 using _If_seed_seq_for = _Require<
315 __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
316 is_unsigned<typename _Sseq::result_type>,
317 __not_<is_convertible<_Sseq, _Res>>
320#pragma GCC diagnostic pop
365 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
369 "result_type must be an unsigned integral type");
370 static_assert(__m == 0u || (__a < __m && __c < __m),
371 "template argument substituting __m out of bounds");
373 template<
typename _Sseq>
414 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
435 template<
typename _Sseq>
447 {
return __c == 0u ? 1u : 0u; }
462 for (; __z != 0ULL; --__z)
472 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
490 {
return __lhs._M_x == __rhs._M_x; }
500 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
501 _UIntType1 __m1,
typename _CharT,
typename _Traits>
505 __a1, __c1, __m1>& __lcr);
520 template<
typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
521 _UIntType1 __m1,
typename _CharT,
typename _Traits>
531#if __cpp_impl_three_way_comparison < 201907L
543 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
549 {
return !(__lhs == __rhs); }
583 template<
typename _UIntType,
size_t __w,
584 size_t __n,
size_t __m,
size_t __r,
585 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
586 _UIntType __b,
size_t __t,
587 _UIntType __c,
size_t __l, _UIntType __f>
591 "result_type must be an unsigned integral type");
592 static_assert(1u <= __m && __m <= __n,
593 "template argument substituting __m out of bounds");
594 static_assert(__r <= __w,
"template argument substituting "
596 static_assert(__u <= __w,
"template argument substituting "
598 static_assert(__s <= __w,
"template argument substituting "
600 static_assert(__t <= __w,
"template argument substituting "
602 static_assert(__l <= __w,
"template argument substituting "
604 static_assert(__w <= std::numeric_limits<_UIntType>::digits,
605 "template argument substituting __w out of bound");
606 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
607 "template argument substituting __a out of bound");
608 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
609 "template argument substituting __b out of bound");
610 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
611 "template argument substituting __c out of bound");
612 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
613 "template argument substituting __d out of bound");
614 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
615 "template argument substituting __f out of bound");
617 template<
typename _Sseq>
627 static constexpr size_t word_size = __w;
628 static constexpr size_t state_size = __n;
629 static constexpr size_t shift_size = __m;
630 static constexpr size_t mask_bits = __r;
632 static constexpr size_t tempering_u = __u;
634 static constexpr size_t tempering_s = __s;
636 static constexpr size_t tempering_t = __t;
638 static constexpr size_t tempering_l = __l;
639 static constexpr result_type initialization_multiplier = __f;
656 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
664 template<
typename _Sseq>
680 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
686 discard(
unsigned long long __z);
706 {
return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
707 && __lhs._M_p == __rhs._M_p); }
721 template<
typename _UIntType1,
722 size_t __w1,
size_t __n1,
723 size_t __m1,
size_t __r1,
724 _UIntType1 __a1,
size_t __u1,
725 _UIntType1 __d1,
size_t __s1,
726 _UIntType1 __b1,
size_t __t1,
727 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
728 typename _CharT,
typename _Traits>
732 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
747 template<
typename _UIntType1,
748 size_t __w1,
size_t __n1,
749 size_t __m1,
size_t __r1,
750 _UIntType1 __a1,
size_t __u1,
751 _UIntType1 __d1,
size_t __s1,
752 _UIntType1 __b1,
size_t __t1,
753 _UIntType1 __c1,
size_t __l1, _UIntType1 __f1,
754 typename _CharT,
typename _Traits>
758 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
764 _UIntType _M_x[state_size];
768#if __cpp_impl_three_way_comparison < 201907L
781 template<
typename _UIntType,
size_t __w,
782 size_t __n,
size_t __m,
size_t __r,
783 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
784 _UIntType __b,
size_t __t,
785 _UIntType __c,
size_t __l, _UIntType __f>
788 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
790 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
791 {
return !(__lhs == __rhs); }
812 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
816 "result_type must be an unsigned integral type");
817 static_assert(0u < __s && __s < __r,
819 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
820 "template argument substituting __w out of bounds");
822 template<
typename _Sseq>
832 static constexpr size_t word_size = __w;
833 static constexpr size_t short_lag = __s;
834 static constexpr size_t long_lag = __r;
835 static constexpr uint_least32_t default_seed = 19780503u;
854 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
878 template<
typename _Sseq>
896 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
904 for (; __z != 0ULL; --__z)
929 {
return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
930 && __lhs._M_carry == __rhs._M_carry
931 && __lhs._M_p == __rhs._M_p); }
945 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
946 typename _CharT,
typename _Traits>
964 template<
typename _UIntType1,
size_t __w1,
size_t __s1,
size_t __r1,
965 typename _CharT,
typename _Traits>
973 _UIntType _M_x[long_lag];
978#if __cpp_impl_three_way_comparison < 201907L
991 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
997 {
return !(__lhs == __rhs); }
1009 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1012 static_assert(1 <= __r && __r <= __p,
1013 "template argument substituting __r out of bounds");
1019 template<
typename _Sseq>
1025 static constexpr size_t block_size = __p;
1026 static constexpr size_t used_block = __r;
1034 : _M_b(), _M_n(0) { }
1044 : _M_b(__rng), _M_n(0) { }
1054 : _M_b(
std::
move(__rng)), _M_n(0) { }
1064 : _M_b(__s), _M_n(0) { }
1071 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1074 : _M_b(__q), _M_n(0)
1104 template<
typename _Sseq>
1116 const _RandomNumberEngine&
1125 {
return _RandomNumberEngine::min(); }
1132 {
return _RandomNumberEngine::max(); }
1140 for (; __z != 0ULL; --__z)
1164 {
return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1177 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1178 typename _CharT,
typename _Traits>
1195 template<
typename _RandomNumberEngine1,
size_t __p1,
size_t __r1,
1196 typename _CharT,
typename _Traits>
1203 _RandomNumberEngine _M_b;
1207#if __cpp_impl_three_way_comparison < 201907L
1219 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1225 {
return !(__lhs == __rhs); }
1235 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1239 "result_type must be an unsigned integral type");
1240 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
1241 "template argument substituting __w out of bounds");
1243 template<
typename _Sseq>
1295 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1322 template<
typename _Sseq>
1331 const _RandomNumberEngine&
1347 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1355 for (; __z != 0ULL; --__z)
1380 {
return __lhs._M_b == __rhs._M_b; }
1394 template<
typename _CharT,
typename _Traits>
1398 __w, _UIntType>& __x)
1405 _RandomNumberEngine _M_b;
1408#if __cpp_impl_three_way_comparison < 201907L
1421 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1427 {
return !(__lhs == __rhs); }
1440 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1441 typename _CharT,
typename _Traits>
1445 __w, _UIntType>& __x)
1462 template<
typename _RandomNumberEngine,
size_t __k>
1465 static_assert(1u <= __k,
"template argument substituting "
1466 "__k out of bound");
1472 template<
typename _Sseq>
1477 static constexpr size_t table_size = __k;
1486 { _M_initialize(); }
1497 { _M_initialize(); }
1508 { _M_initialize(); }
1519 { _M_initialize(); }
1526 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1530 { _M_initialize(); }
1559 template<
typename _Sseq>
1570 const _RandomNumberEngine&
1579 {
return _RandomNumberEngine::min(); }
1586 {
return _RandomNumberEngine::max(); }
1594 for (; __z != 0ULL; --__z)
1618 {
return (__lhs._M_b == __rhs._M_b
1619 && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1620 && __lhs._M_y == __rhs._M_y); }
1633 template<
typename _RandomNumberEngine1,
size_t __k1,
1634 typename _CharT,
typename _Traits>
1651 template<
typename _RandomNumberEngine1,
size_t __k1,
1652 typename _CharT,
typename _Traits>
1658 void _M_initialize()
1660 for (
size_t __i = 0; __i < __k; ++__i)
1665 _RandomNumberEngine _M_b;
1670#if __cpp_impl_three_way_comparison < 201907L
1682 template<
typename _RandomNumberEngine,
size_t __k>
1688 {
return !(__lhs == __rhs); }
1694 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1725 0xb5026f5aa96619e9ULL, 29,
1726 0x5555555555555555ULL, 17,
1727 0x71d67fffeda60000ULL, 37,
1728 0xfff7eee000000000ULL, 43,
1777 entropy() const noexcept
1778 {
return this->_M_getentropy(); }
1782 {
return this->_M_getval(); }
1785 random_device(
const random_device&) =
delete;
1786 void operator=(
const random_device&) =
delete;
1796 double _M_getentropy() const noexcept;
1798 void _M_init(const
char*,
size_t);
1828#if __cpp_impl_three_way_comparison < 201907L
1833 template<
typename _IntType>
1837 {
return !(__d1 == __d2); }
1850 template<
typename _IntType,
typename _CharT,
typename _Traits>
1864 template<
typename _IntType,
typename _CharT,
typename _Traits>
1880 template<
typename _RealType =
double>
1884 "result_type must be a floating point type");
1898 param_type(_RealType __a, _RealType __b = _RealType(1))
1899 : _M_a(__a), _M_b(__b)
1901 __glibcxx_assert(_M_a <= _M_b);
1914 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1916#if __cpp_impl_three_way_comparison < 201907L
1919 {
return !(__p1 == __p2); }
1943 : _M_param(__a, __b)
1961 {
return _M_param.a(); }
1965 {
return _M_param.b(); }
1972 {
return _M_param; }
1980 { _M_param = __param; }
1987 {
return this->a(); }
1994 {
return this->b(); }
1999 template<
typename _UniformRandomNumberGenerator>
2002 {
return this->
operator()(__urng, _M_param); }
2004 template<
typename _UniformRandomNumberGenerator>
2006 operator()(_UniformRandomNumberGenerator& __urng,
2007 const param_type& __p)
2009 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2011 return (__aurng() * (__p.b() - __p.a())) + __p.a();
2014 template<
typename _ForwardIterator,
2015 typename _UniformRandomNumberGenerator>
2017 __generate(_ForwardIterator __f, _ForwardIterator __t,
2018 _UniformRandomNumberGenerator& __urng)
2019 { this->__generate(__f, __t, __urng, _M_param); }
2021 template<
typename _ForwardIterator,
2022 typename _UniformRandomNumberGenerator>
2024 __generate(_ForwardIterator __f, _ForwardIterator __t,
2025 _UniformRandomNumberGenerator& __urng,
2026 const param_type& __p)
2027 { this->__generate_impl(__f, __t, __urng, __p); }
2029 template<
typename _UniformRandomNumberGenerator>
2032 _UniformRandomNumberGenerator& __urng,
2033 const param_type& __p)
2034 { this->__generate_impl(__f, __t, __urng, __p); }
2043 {
return __d1._M_param == __d2._M_param; }
2046 template<
typename _ForwardIterator,
2047 typename _UniformRandomNumberGenerator>
2049 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2050 _UniformRandomNumberGenerator& __urng,
2051 const param_type& __p);
2053 param_type _M_param;
2056#if __cpp_impl_three_way_comparison < 201907L
2061 template<
typename _IntType>
2065 {
return !(__d1 == __d2); }
2078 template<
typename _RealType,
typename _CharT,
typename _Traits>
2092 template<
typename _RealType,
typename _CharT,
typename _Traits>
2117 template<
typename _RealType =
double>
2121 "result_type must be a floating point type");
2135 param_type(_RealType __mean, _RealType __stddev = _RealType(1))
2136 : _M_mean(__mean), _M_stddev(__stddev)
2138 __glibcxx_assert(_M_stddev > _RealType(0));
2147 {
return _M_stddev; }
2151 {
return (__p1._M_mean == __p2._M_mean
2152 && __p1._M_stddev == __p2._M_stddev); }
2154#if __cpp_impl_three_way_comparison < 201907L
2157 {
return !(__p1 == __p2); }
2162 _RealType _M_stddev;
2175 : _M_param(__mean, __stddev)
2188 { _M_saved_available =
false; }
2195 {
return _M_param.mean(); }
2202 {
return _M_param.stddev(); }
2209 {
return _M_param; }
2217 { _M_param = __param; }
2236 template<
typename _UniformRandomNumberGenerator>
2239 {
return this->
operator()(__urng, _M_param); }
2241 template<
typename _UniformRandomNumberGenerator>
2243 operator()(_UniformRandomNumberGenerator& __urng,
2244 const param_type& __p);
2246 template<
typename _ForwardIterator,
2247 typename _UniformRandomNumberGenerator>
2249 __generate(_ForwardIterator __f, _ForwardIterator __t,
2250 _UniformRandomNumberGenerator& __urng)
2251 { this->__generate(__f, __t, __urng, _M_param); }
2253 template<
typename _ForwardIterator,
2254 typename _UniformRandomNumberGenerator>
2256 __generate(_ForwardIterator __f, _ForwardIterator __t,
2257 _UniformRandomNumberGenerator& __urng,
2258 const param_type& __p)
2259 { this->__generate_impl(__f, __t, __urng, __p); }
2261 template<
typename _UniformRandomNumberGenerator>
2264 _UniformRandomNumberGenerator& __urng,
2265 const param_type& __p)
2266 { this->__generate_impl(__f, __t, __urng, __p); }
2273 template<
typename _RealType1>
2288 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2303 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2309 template<
typename _ForwardIterator,
2310 typename _UniformRandomNumberGenerator>
2312 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2313 _UniformRandomNumberGenerator& __urng,
2318 bool _M_saved_available =
false;
2321#if __cpp_impl_three_way_comparison < 201907L
2325 template<
typename _RealType>
2329 {
return !(__d1 == __d2); }
2344 template<
typename _RealType =
double>
2348 "result_type must be a floating point type");
2362 param_type(_RealType __m, _RealType __s = _RealType(1))
2363 : _M_m(__m), _M_s(__s)
2376 {
return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2378#if __cpp_impl_three_way_comparison < 201907L
2381 {
return !(__p1 == __p2); }
2393 : _M_param(__m, __s), _M_nd()
2397 lognormal_distribution(
const param_type& __p)
2398 : _M_param(__p), _M_nd()
2413 {
return _M_param.m(); }
2417 {
return _M_param.s(); }
2424 {
return _M_param; }
2432 { _M_param = __param; }
2451 template<
typename _UniformRandomNumberGenerator>
2454 {
return this->
operator()(__urng, _M_param); }
2456 template<
typename _UniformRandomNumberGenerator>
2458 operator()(_UniformRandomNumberGenerator& __urng,
2459 const param_type& __p)
2460 {
return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
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>
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>
2520 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2526 template<
typename _ForwardIterator,
2527 typename _UniformRandomNumberGenerator>
2529 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2530 _UniformRandomNumberGenerator& __urng,
2538#if __cpp_impl_three_way_comparison < 201907L
2542 template<
typename _RealType>
2546 {
return !(__d1 == __d2); }
2569 template<
typename _RealType =
double>
2573 "result_type must be a floating point type");
2588 param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1))
2589 : _M_alpha(__alpha_val), _M_beta(__beta_val)
2591 __glibcxx_assert(_M_alpha > _RealType(0));
2597 {
return _M_alpha; }
2605 {
return (__p1._M_alpha == __p2._M_alpha
2606 && __p1._M_beta == __p2._M_beta); }
2608#if __cpp_impl_three_way_comparison < 201907L
2611 {
return !(__p1 == __p2); }
2621 _RealType _M_malpha, _M_a2;
2636 _RealType __beta_val = _RealType(1))
2637 : _M_param(__alpha_val, __beta_val), _M_nd()
2642 : _M_param(__p), _M_nd()
2657 {
return _M_param.alpha(); }
2664 {
return _M_param.beta(); }
2671 {
return _M_param; }
2679 { _M_param = __param; }
2698 template<
typename _UniformRandomNumberGenerator>
2701 {
return this->
operator()(__urng, _M_param); }
2703 template<
typename _UniformRandomNumberGenerator>
2705 operator()(_UniformRandomNumberGenerator& __urng,
2706 const param_type& __p);
2708 template<
typename _ForwardIterator,
2709 typename _UniformRandomNumberGenerator>
2711 __generate(_ForwardIterator __f, _ForwardIterator __t,
2712 _UniformRandomNumberGenerator& __urng)
2713 { this->__generate(__f, __t, __urng, _M_param); }
2715 template<
typename _ForwardIterator,
2716 typename _UniformRandomNumberGenerator>
2718 __generate(_ForwardIterator __f, _ForwardIterator __t,
2719 _UniformRandomNumberGenerator& __urng,
2720 const param_type& __p)
2721 { this->__generate_impl(__f, __t, __urng, __p); }
2723 template<
typename _UniformRandomNumberGenerator>
2726 _UniformRandomNumberGenerator& __urng,
2727 const param_type& __p)
2728 { this->__generate_impl(__f, __t, __urng, __p); }
2738 {
return (__d1._M_param == __d2._M_param
2739 && __d1._M_nd == __d2._M_nd); }
2751 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2765 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2771 template<
typename _ForwardIterator,
2772 typename _UniformRandomNumberGenerator>
2774 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2775 _UniformRandomNumberGenerator& __urng,
2783#if __cpp_impl_three_way_comparison < 201907L
2787 template<
typename _RealType>
2791 {
return !(__d1 == __d2); }
2811 template<
typename _RealType =
double>
2815 "result_type must be a floating point type");
2839 {
return __p1._M_n == __p2._M_n; }
2841#if __cpp_impl_three_way_comparison < 201907L
2844 {
return !(__p1 == __p2); }
2855 : _M_param(__n), _M_gd(__n / 2)
2859 chi_squared_distribution(
const param_type& __p)
2860 : _M_param(__p), _M_gd(__p.n() / 2)
2875 {
return _M_param.n(); }
2882 {
return _M_param; }
2914 template<
typename _UniformRandomNumberGenerator>
2917 {
return 2 * _M_gd(__urng); }
2919 template<
typename _UniformRandomNumberGenerator>
2921 operator()(_UniformRandomNumberGenerator& __urng,
2922 const param_type& __p)
2926 return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2929 template<
typename _ForwardIterator,
2930 typename _UniformRandomNumberGenerator>
2932 __generate(_ForwardIterator __f, _ForwardIterator __t,
2933 _UniformRandomNumberGenerator& __urng)
2934 { this->__generate_impl(__f, __t, __urng); }
2936 template<
typename _ForwardIterator,
2937 typename _UniformRandomNumberGenerator>
2939 __generate(_ForwardIterator __f, _ForwardIterator __t,
2940 _UniformRandomNumberGenerator& __urng,
2941 const param_type& __p)
2944 this->__generate_impl(__f, __t, __urng, __p2); }
2946 template<
typename _UniformRandomNumberGenerator>
2949 _UniformRandomNumberGenerator& __urng)
2950 { this->__generate_impl(__f, __t, __urng); }
2952 template<
typename _UniformRandomNumberGenerator>
2955 _UniformRandomNumberGenerator& __urng,
2956 const param_type& __p)
2959 this->__generate_impl(__f, __t, __urng, __p2); }
2969 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2981 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2996 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3002 template<
typename _ForwardIterator,
3003 typename _UniformRandomNumberGenerator>
3005 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3006 _UniformRandomNumberGenerator& __urng);
3008 template<
typename _ForwardIterator,
3009 typename _UniformRandomNumberGenerator>
3011 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3012 _UniformRandomNumberGenerator& __urng,
3021#if __cpp_impl_three_way_comparison < 201907L
3025 template<
typename _RealType>
3029 {
return !(__d1 == __d2); }
3041 template<
typename _RealType =
double>
3045 "result_type must be a floating point type");
3059 param_type(_RealType __a, _RealType __b = _RealType(1))
3060 : _M_a(__a), _M_b(__b)
3073 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
3075#if __cpp_impl_three_way_comparison < 201907L
3078 {
return !(__p1 == __p2); }
3090 : _M_param(__a, __b)
3094 cauchy_distribution(
const param_type& __p)
3110 {
return _M_param.a(); }
3114 {
return _M_param.b(); }
3121 {
return _M_param; }
3129 { _M_param = __param; }
3148 template<
typename _UniformRandomNumberGenerator>
3151 {
return this->
operator()(__urng, _M_param); }
3153 template<
typename _UniformRandomNumberGenerator>
3155 operator()(_UniformRandomNumberGenerator& __urng,
3156 const param_type& __p);
3158 template<
typename _ForwardIterator,
3159 typename _UniformRandomNumberGenerator>
3161 __generate(_ForwardIterator __f, _ForwardIterator __t,
3162 _UniformRandomNumberGenerator& __urng)
3163 { this->__generate(__f, __t, __urng, _M_param); }
3165 template<
typename _ForwardIterator,
3166 typename _UniformRandomNumberGenerator>
3168 __generate(_ForwardIterator __f, _ForwardIterator __t,
3169 _UniformRandomNumberGenerator& __urng,
3170 const param_type& __p)
3171 { this->__generate_impl(__f, __t, __urng, __p); }
3173 template<
typename _UniformRandomNumberGenerator>
3176 _UniformRandomNumberGenerator& __urng,
3177 const param_type& __p)
3178 { this->__generate_impl(__f, __t, __urng, __p); }
3187 {
return __d1._M_param == __d2._M_param; }
3190 template<
typename _ForwardIterator,
3191 typename _UniformRandomNumberGenerator>
3193 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3194 _UniformRandomNumberGenerator& __urng,
3195 const param_type& __p);
3197 param_type _M_param;
3200#if __cpp_impl_three_way_comparison < 201907L
3205 template<
typename _RealType>
3209 {
return !(__d1 == __d2); }
3222 template<
typename _RealType,
typename _CharT,
typename _Traits>
3237 template<
typename _RealType,
typename _CharT,
typename _Traits>
3256 template<
typename _RealType =
double>
3260 "result_type must be a floating point type");
3274 param_type(_RealType __m, _RealType __n = _RealType(1))
3275 : _M_m(__m), _M_n(__n)
3288 {
return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3290#if __cpp_impl_three_way_comparison < 201907L
3293 {
return !(__p1 == __p2); }
3305 _RealType __n = _RealType(1))
3306 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3310 fisher_f_distribution(
const param_type& __p)
3311 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3329 {
return _M_param.m(); }
3333 {
return _M_param.n(); }
3340 {
return _M_param; }
3348 { _M_param = __param; }
3367 template<
typename _UniformRandomNumberGenerator>
3370 {
return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3372 template<
typename _UniformRandomNumberGenerator>
3374 operator()(_UniformRandomNumberGenerator& __urng,
3375 const param_type& __p)
3379 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3380 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3383 template<
typename _ForwardIterator,
3384 typename _UniformRandomNumberGenerator>
3386 __generate(_ForwardIterator __f, _ForwardIterator __t,
3387 _UniformRandomNumberGenerator& __urng)
3388 { this->__generate_impl(__f, __t, __urng); }
3390 template<
typename _ForwardIterator,
3391 typename _UniformRandomNumberGenerator>
3393 __generate(_ForwardIterator __f, _ForwardIterator __t,
3394 _UniformRandomNumberGenerator& __urng,
3395 const param_type& __p)
3396 { this->__generate_impl(__f, __t, __urng, __p); }
3398 template<
typename _UniformRandomNumberGenerator>
3401 _UniformRandomNumberGenerator& __urng)
3402 { this->__generate_impl(__f, __t, __urng); }
3404 template<
typename _UniformRandomNumberGenerator>
3407 _UniformRandomNumberGenerator& __urng,
3408 const param_type& __p)
3409 { this->__generate_impl(__f, __t, __urng, __p); }
3419 {
return (__d1._M_param == __d2._M_param
3420 && __d1._M_gd_x == __d2._M_gd_x
3421 && __d1._M_gd_y == __d2._M_gd_y); }
3433 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3448 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3454 template<
typename _ForwardIterator,
3455 typename _UniformRandomNumberGenerator>
3457 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3458 _UniformRandomNumberGenerator& __urng);
3460 template<
typename _ForwardIterator,
3461 typename _UniformRandomNumberGenerator>
3463 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3464 _UniformRandomNumberGenerator& __urng,
3472#if __cpp_impl_three_way_comparison < 201907L
3476 template<
typename _RealType>
3480 {
return !(__d1 == __d2); }
3495 template<
typename _RealType =
double>
3499 "result_type must be a floating point type");
3523 {
return __p1._M_n == __p2._M_n; }
3525#if __cpp_impl_three_way_comparison < 201907L
3528 {
return !(__p1 == __p2); }
3539 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3543 student_t_distribution(
const param_type& __p)
3544 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3562 {
return _M_param.n(); }
3569 {
return _M_param; }
3577 { _M_param = __param; }
3596 template<
typename _UniformRandomNumberGenerator>
3599 {
return _M_nd(__urng) *
std::sqrt(n() / _M_gd(__urng)); }
3601 template<
typename _UniformRandomNumberGenerator>
3603 operator()(_UniformRandomNumberGenerator& __urng,
3604 const param_type& __p)
3609 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3610 return _M_nd(__urng) *
std::sqrt(__p.n() / __g);
3613 template<
typename _ForwardIterator,
3614 typename _UniformRandomNumberGenerator>
3616 __generate(_ForwardIterator __f, _ForwardIterator __t,
3617 _UniformRandomNumberGenerator& __urng)
3618 { this->__generate_impl(__f, __t, __urng); }
3620 template<
typename _ForwardIterator,
3621 typename _UniformRandomNumberGenerator>
3623 __generate(_ForwardIterator __f, _ForwardIterator __t,
3624 _UniformRandomNumberGenerator& __urng,
3625 const param_type& __p)
3626 { this->__generate_impl(__f, __t, __urng, __p); }
3628 template<
typename _UniformRandomNumberGenerator>
3631 _UniformRandomNumberGenerator& __urng)
3632 { this->__generate_impl(__f, __t, __urng); }
3634 template<
typename _UniformRandomNumberGenerator>
3637 _UniformRandomNumberGenerator& __urng,
3638 const param_type& __p)
3639 { this->__generate_impl(__f, __t, __urng, __p); }
3649 {
return (__d1._M_param == __d2._M_param
3650 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3662 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3677 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3683 template<
typename _ForwardIterator,
3684 typename _UniformRandomNumberGenerator>
3686 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3687 _UniformRandomNumberGenerator& __urng);
3688 template<
typename _ForwardIterator,
3689 typename _UniformRandomNumberGenerator>
3691 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3692 _UniformRandomNumberGenerator& __urng,
3701#if __cpp_impl_three_way_comparison < 201907L
3705 template<
typename _RealType>
3709 {
return !(__d1 == __d2); }
3746 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3755 {
return __p1._M_p == __p2._M_p; }
3757#if __cpp_impl_three_way_comparison < 201907L
3760 {
return !(__p1 == __p2); }
3802 {
return _M_param.p(); }
3809 {
return _M_param; }
3817 { _M_param = __param; }
3836 template<
typename _UniformRandomNumberGenerator>
3839 {
return this->
operator()(__urng, _M_param); }
3841 template<
typename _UniformRandomNumberGenerator>
3843 operator()(_UniformRandomNumberGenerator& __urng,
3844 const param_type& __p)
3846 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3848 if ((__aurng() - __aurng.min())
3849 < __p.p() * (__aurng.max() - __aurng.min()))
3854 template<
typename _ForwardIterator,
3855 typename _UniformRandomNumberGenerator>
3857 __generate(_ForwardIterator __f, _ForwardIterator __t,
3858 _UniformRandomNumberGenerator& __urng)
3859 { this->__generate(__f, __t, __urng, _M_param); }
3861 template<
typename _ForwardIterator,
3862 typename _UniformRandomNumberGenerator>
3864 __generate(_ForwardIterator __f, _ForwardIterator __t,
3865 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3866 { this->__generate_impl(__f, __t, __urng, __p); }
3868 template<
typename _UniformRandomNumberGenerator>
3871 _UniformRandomNumberGenerator& __urng,
3872 const param_type& __p)
3873 { this->__generate_impl(__f, __t, __urng, __p); }
3882 {
return __d1._M_param == __d2._M_param; }
3885 template<
typename _ForwardIterator,
3886 typename _UniformRandomNumberGenerator>
3888 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3889 _UniformRandomNumberGenerator& __urng,
3890 const param_type& __p);
3892 param_type _M_param;
3895#if __cpp_impl_three_way_comparison < 201907L
3903 {
return !(__d1 == __d2); }
3916 template<
typename _CharT,
typename _Traits>
3930 template<
typename _CharT,
typename _Traits>
3952 template<
typename _IntType =
int>
3956 "result_type must be an integral type");
3972 : _M_t(__t), _M_p(__p)
3974 __glibcxx_assert((_M_t >= _IntType(0))
3990 {
return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3992#if __cpp_impl_three_way_comparison < 201907L
3995 {
return !(__p1 == __p2); }
4006#if _GLIBCXX_USE_C99_MATH_FUNCS
4007 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
4008 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
4019 : _M_param(__t, __p), _M_nd()
4023 binomial_distribution(
const param_type& __p)
4024 : _M_param(__p), _M_nd()
4039 {
return _M_param.t(); }
4046 {
return _M_param.p(); }
4053 {
return _M_param; }
4061 { _M_param = __param; }
4075 {
return _M_param.t(); }
4080 template<
typename _UniformRandomNumberGenerator>
4083 {
return this->
operator()(__urng, _M_param); }
4085 template<
typename _UniformRandomNumberGenerator>
4087 operator()(_UniformRandomNumberGenerator& __urng,
4088 const param_type& __p);
4090 template<
typename _ForwardIterator,
4091 typename _UniformRandomNumberGenerator>
4093 __generate(_ForwardIterator __f, _ForwardIterator __t,
4094 _UniformRandomNumberGenerator& __urng)
4095 { this->__generate(__f, __t, __urng, _M_param); }
4097 template<
typename _ForwardIterator,
4098 typename _UniformRandomNumberGenerator>
4100 __generate(_ForwardIterator __f, _ForwardIterator __t,
4101 _UniformRandomNumberGenerator& __urng,
4102 const param_type& __p)
4103 { this->__generate_impl(__f, __t, __urng, __p); }
4105 template<
typename _UniformRandomNumberGenerator>
4108 _UniformRandomNumberGenerator& __urng,
4109 const param_type& __p)
4110 { this->__generate_impl(__f, __t, __urng, __p); }
4120#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
4121 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4123 {
return __d1._M_param == __d2._M_param; }
4136 template<
typename _IntType1,
4137 typename _CharT,
typename _Traits>
4152 template<
typename _IntType1,
4153 typename _CharT,
typename _Traits>
4159 template<
typename _ForwardIterator,
4160 typename _UniformRandomNumberGenerator>
4162 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4163 _UniformRandomNumberGenerator& __urng,
4166 template<
typename _UniformRandomNumberGenerator>
4168 _M_waiting(_UniformRandomNumberGenerator& __urng,
4169 _IntType __t,
double __q);
4177#if __cpp_impl_three_way_comparison < 201907L
4181 template<
typename _IntType>
4185 {
return !(__d1 == __d2); }
4198 template<
typename _IntType =
int>
4202 "result_type must be an integral type");
4220 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4230 {
return __p1._M_p == __p2._M_p; }
4232#if __cpp_impl_three_way_comparison < 201907L
4235 {
return !(__p1 == __p2); }
4241 { _M_log_1_p =
std::log(1.0 - _M_p); }
4258 geometric_distribution(
const param_type& __p)
4275 {
return _M_param.p(); }
4282 {
return _M_param; }
4290 { _M_param = __param; }
4309 template<
typename _UniformRandomNumberGenerator>
4312 {
return this->
operator()(__urng, _M_param); }
4314 template<
typename _UniformRandomNumberGenerator>
4316 operator()(_UniformRandomNumberGenerator& __urng,
4317 const param_type& __p);
4319 template<
typename _ForwardIterator,
4320 typename _UniformRandomNumberGenerator>
4322 __generate(_ForwardIterator __f, _ForwardIterator __t,
4323 _UniformRandomNumberGenerator& __urng)
4324 { this->__generate(__f, __t, __urng, _M_param); }
4326 template<
typename _ForwardIterator,
4327 typename _UniformRandomNumberGenerator>
4329 __generate(_ForwardIterator __f, _ForwardIterator __t,
4330 _UniformRandomNumberGenerator& __urng,
4331 const param_type& __p)
4332 { this->__generate_impl(__f, __t, __urng, __p); }
4334 template<
typename _UniformRandomNumberGenerator>
4337 _UniformRandomNumberGenerator& __urng,
4338 const param_type& __p)
4339 { this->__generate_impl(__f, __t, __urng, __p); }
4348 {
return __d1._M_param == __d2._M_param; }
4351 template<
typename _ForwardIterator,
4352 typename _UniformRandomNumberGenerator>
4354 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4355 _UniformRandomNumberGenerator& __urng,
4356 const param_type& __p);
4358 param_type _M_param;
4361#if __cpp_impl_three_way_comparison < 201907L
4366 template<
typename _IntType>
4370 {
return !(__d1 == __d2); }
4383 template<
typename _IntType,
4384 typename _CharT,
typename _Traits>
4398 template<
typename _IntType,
4399 typename _CharT,
typename _Traits>
4415 template<
typename _IntType =
int>
4419 "result_type must be an integral type");
4434 : _M_k(__k), _M_p(__p)
4436 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4449 {
return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4451#if __cpp_impl_three_way_comparison < 201907L
4454 {
return !(__p1 == __p2); }
4466 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4470 negative_binomial_distribution(
const param_type& __p)
4471 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4486 {
return _M_param.k(); }
4493 {
return _M_param.p(); }
4500 {
return _M_param; }
4508 { _M_param = __param; }
4527 template<
typename _UniformRandomNumberGenerator>
4529 operator()(_UniformRandomNumberGenerator& __urng);
4531 template<
typename _UniformRandomNumberGenerator>
4533 operator()(_UniformRandomNumberGenerator& __urng,
4534 const param_type& __p);
4536 template<
typename _ForwardIterator,
4537 typename _UniformRandomNumberGenerator>
4539 __generate(_ForwardIterator __f, _ForwardIterator __t,
4540 _UniformRandomNumberGenerator& __urng)
4541 { this->__generate_impl(__f, __t, __urng); }
4543 template<
typename _ForwardIterator,
4544 typename _UniformRandomNumberGenerator>
4546 __generate(_ForwardIterator __f, _ForwardIterator __t,
4547 _UniformRandomNumberGenerator& __urng,
4548 const param_type& __p)
4549 { this->__generate_impl(__f, __t, __urng, __p); }
4551 template<
typename _UniformRandomNumberGenerator>
4554 _UniformRandomNumberGenerator& __urng)
4555 { this->__generate_impl(__f, __t, __urng); }
4557 template<
typename _UniformRandomNumberGenerator>
4560 _UniformRandomNumberGenerator& __urng,
4561 const param_type& __p)
4562 { this->__generate_impl(__f, __t, __urng, __p); }
4572 {
return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4585 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4600 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4606 template<
typename _ForwardIterator,
4607 typename _UniformRandomNumberGenerator>
4609 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4610 _UniformRandomNumberGenerator& __urng);
4611 template<
typename _ForwardIterator,
4612 typename _UniformRandomNumberGenerator>
4614 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4615 _UniformRandomNumberGenerator& __urng,
4623#if __cpp_impl_three_way_comparison < 201907L
4627 template<
typename _IntType>
4631 {
return !(__d1 == __d2); }
4652 template<
typename _IntType =
int>
4656 "result_type must be an integral type");
4674 __glibcxx_assert(_M_mean > 0.0);
4684 {
return __p1._M_mean == __p2._M_mean; }
4686#if __cpp_impl_three_way_comparison < 201907L
4689 {
return !(__p1 == __p2); }
4700#if _GLIBCXX_USE_C99_MATH_FUNCS
4701 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4711 : _M_param(__mean), _M_nd()
4715 poisson_distribution(
const param_type& __p)
4716 : _M_param(__p), _M_nd()
4731 {
return _M_param.mean(); }
4738 {
return _M_param; }
4746 { _M_param = __param; }
4765 template<
typename _UniformRandomNumberGenerator>
4768 {
return this->
operator()(__urng, _M_param); }
4770 template<
typename _UniformRandomNumberGenerator>
4772 operator()(_UniformRandomNumberGenerator& __urng,
4773 const param_type& __p);
4775 template<
typename _ForwardIterator,
4776 typename _UniformRandomNumberGenerator>
4778 __generate(_ForwardIterator __f, _ForwardIterator __t,
4779 _UniformRandomNumberGenerator& __urng)
4780 { this->__generate(__f, __t, __urng, _M_param); }
4782 template<
typename _ForwardIterator,
4783 typename _UniformRandomNumberGenerator>
4785 __generate(_ForwardIterator __f, _ForwardIterator __t,
4786 _UniformRandomNumberGenerator& __urng,
4787 const param_type& __p)
4788 { this->__generate_impl(__f, __t, __urng, __p); }
4790 template<
typename _UniformRandomNumberGenerator>
4793 _UniformRandomNumberGenerator& __urng,
4794 const param_type& __p)
4795 { this->__generate_impl(__f, __t, __urng, __p); }
4805#ifdef _GLIBCXX_USE_C99_MATH_FUNCS
4806 {
return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4808 {
return __d1._M_param == __d2._M_param; }
4821 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4836 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4842 template<
typename _ForwardIterator,
4843 typename _UniformRandomNumberGenerator>
4845 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4846 _UniformRandomNumberGenerator& __urng,
4855#if __cpp_impl_three_way_comparison < 201907L
4859 template<
typename _IntType>
4863 {
return !(__d1 == __d2); }
4884 template<
typename _RealType =
double>
4888 "result_type must be a floating point type");
4903 : _M_lambda(__lambda)
4905 __glibcxx_assert(_M_lambda > _RealType(0));
4910 {
return _M_lambda; }
4914 {
return __p1._M_lambda == __p2._M_lambda; }
4916#if __cpp_impl_three_way_comparison < 201907L
4919 {
return !(__p1 == __p2); }
4923 _RealType _M_lambda;
4939 : _M_param(__lambda)
4960 {
return _M_param.lambda(); }
4967 {
return _M_param; }
4975 { _M_param = __param; }
4994 template<
typename _UniformRandomNumberGenerator>
4997 {
return this->
operator()(__urng, _M_param); }
4999 template<
typename _UniformRandomNumberGenerator>
5001 operator()(_UniformRandomNumberGenerator& __urng,
5002 const param_type& __p)
5004 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
5009 template<
typename _ForwardIterator,
5010 typename _UniformRandomNumberGenerator>
5012 __generate(_ForwardIterator __f, _ForwardIterator __t,
5013 _UniformRandomNumberGenerator& __urng)
5014 { this->__generate(__f, __t, __urng, _M_param); }
5016 template<
typename _ForwardIterator,
5017 typename _UniformRandomNumberGenerator>
5019 __generate(_ForwardIterator __f, _ForwardIterator __t,
5020 _UniformRandomNumberGenerator& __urng,
5021 const param_type& __p)
5022 { this->__generate_impl(__f, __t, __urng, __p); }
5024 template<
typename _UniformRandomNumberGenerator>
5027 _UniformRandomNumberGenerator& __urng,
5028 const param_type& __p)
5029 { this->__generate_impl(__f, __t, __urng, __p); }
5038 {
return __d1._M_param == __d2._M_param; }
5041 template<
typename _ForwardIterator,
5042 typename _UniformRandomNumberGenerator>
5044 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5045 _UniformRandomNumberGenerator& __urng,
5046 const param_type& __p);
5048 param_type _M_param;
5051#if __cpp_impl_three_way_comparison < 201907L
5056 template<
typename _RealType>
5060 {
return !(__d1 == __d2); }
5073 template<
typename _RealType,
typename _CharT,
typename _Traits>
5088 template<
typename _RealType,
typename _CharT,
typename _Traits>
5106 template<
typename _RealType =
double>
5110 "result_type must be a floating point type");
5124 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5125 : _M_a(__a), _M_b(__b)
5138 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5140#if __cpp_impl_three_way_comparison < 201907L
5143 {
return !(__p1 == __p2); }
5155 : _M_param(__a, __b)
5159 weibull_distribution(
const param_type& __p)
5175 {
return _M_param.a(); }
5182 {
return _M_param.b(); }
5189 {
return _M_param; }
5197 { _M_param = __param; }
5216 template<
typename _UniformRandomNumberGenerator>
5219 {
return this->
operator()(__urng, _M_param); }
5221 template<
typename _UniformRandomNumberGenerator>
5223 operator()(_UniformRandomNumberGenerator& __urng,
5224 const param_type& __p);
5226 template<
typename _ForwardIterator,
5227 typename _UniformRandomNumberGenerator>
5229 __generate(_ForwardIterator __f, _ForwardIterator __t,
5230 _UniformRandomNumberGenerator& __urng)
5231 { this->__generate(__f, __t, __urng, _M_param); }
5233 template<
typename _ForwardIterator,
5234 typename _UniformRandomNumberGenerator>
5236 __generate(_ForwardIterator __f, _ForwardIterator __t,
5237 _UniformRandomNumberGenerator& __urng,
5238 const param_type& __p)
5239 { this->__generate_impl(__f, __t, __urng, __p); }
5241 template<
typename _UniformRandomNumberGenerator>
5244 _UniformRandomNumberGenerator& __urng,
5245 const param_type& __p)
5246 { this->__generate_impl(__f, __t, __urng, __p); }
5255 {
return __d1._M_param == __d2._M_param; }
5258 template<
typename _ForwardIterator,
5259 typename _UniformRandomNumberGenerator>
5261 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5262 _UniformRandomNumberGenerator& __urng,
5263 const param_type& __p);
5265 param_type _M_param;
5268#if __cpp_impl_three_way_comparison < 201907L
5273 template<
typename _RealType>
5277 {
return !(__d1 == __d2); }
5290 template<
typename _RealType,
typename _CharT,
typename _Traits>
5305 template<
typename _RealType,
typename _CharT,
typename _Traits>
5323 template<
typename _RealType =
double>
5327 "result_type must be a floating point type");
5341 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5342 : _M_a(__a), _M_b(__b)
5355 {
return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5357#if __cpp_impl_three_way_comparison < 201907L
5360 {
return !(__p1 == __p2); }
5372 : _M_param(__a, __b)
5376 extreme_value_distribution(
const param_type& __p)
5392 {
return _M_param.a(); }
5399 {
return _M_param.b(); }
5406 {
return _M_param; }
5414 { _M_param = __param; }
5433 template<
typename _UniformRandomNumberGenerator>
5436 {
return this->
operator()(__urng, _M_param); }
5438 template<
typename _UniformRandomNumberGenerator>
5440 operator()(_UniformRandomNumberGenerator& __urng,
5441 const param_type& __p);
5443 template<
typename _ForwardIterator,
5444 typename _UniformRandomNumberGenerator>
5446 __generate(_ForwardIterator __f, _ForwardIterator __t,
5447 _UniformRandomNumberGenerator& __urng)
5448 { this->__generate(__f, __t, __urng, _M_param); }
5450 template<
typename _ForwardIterator,
5451 typename _UniformRandomNumberGenerator>
5453 __generate(_ForwardIterator __f, _ForwardIterator __t,
5454 _UniformRandomNumberGenerator& __urng,
5455 const param_type& __p)
5456 { this->__generate_impl(__f, __t, __urng, __p); }
5458 template<
typename _UniformRandomNumberGenerator>
5461 _UniformRandomNumberGenerator& __urng,
5462 const param_type& __p)
5463 { this->__generate_impl(__f, __t, __urng, __p); }
5472 {
return __d1._M_param == __d2._M_param; }
5475 template<
typename _ForwardIterator,
5476 typename _UniformRandomNumberGenerator>
5478 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5479 _UniformRandomNumberGenerator& __urng,
5480 const param_type& __p);
5482 param_type _M_param;
5485#if __cpp_impl_three_way_comparison < 201907L
5490 template<
typename _RealType>
5494 {
return !(__d1 == __d2); }
5507 template<
typename _RealType,
typename _CharT,
typename _Traits>
5522 template<
typename _RealType,
typename _CharT,
typename _Traits>
5545 template<
typename _IntType =
int>
5549 "result_type must be an integral type");
5562 : _M_prob(), _M_cp()
5565 template<
typename _InputIterator>
5567 _InputIterator __wend)
5568 : _M_prob(__wbegin, __wend), _M_cp()
5569 { _M_initialize(); }
5572 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5573 { _M_initialize(); }
5575 template<
typename _Func>
5576 param_type(
size_t __nw,
double __xmin,
double __xmax,
5584 probabilities()
const
5589 {
return __p1._M_prob == __p2._M_prob; }
5591#if __cpp_impl_three_way_comparison < 201907L
5594 {
return !(__p1 == __p2); }
5609 template<
typename _InputIterator>
5611 _InputIterator __wend)
5612 : _M_param(__wbegin, __wend)
5615 discrete_distribution(initializer_list<double> __wl)
5619 template<
typename _Func>
5620 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5622 : _M_param(__nw, __xmin, __xmax, __fw)
5626 discrete_distribution(
const param_type& __p)
5643 return _M_param._M_prob.
empty()
5652 {
return _M_param; }
5660 { _M_param = __param; }
5675 return _M_param._M_prob.
empty()
5682 template<
typename _UniformRandomNumberGenerator>
5685 {
return this->
operator()(__urng, _M_param); }
5687 template<
typename _UniformRandomNumberGenerator>
5689 operator()(_UniformRandomNumberGenerator& __urng,
5690 const param_type& __p);
5692 template<
typename _ForwardIterator,
5693 typename _UniformRandomNumberGenerator>
5695 __generate(_ForwardIterator __f, _ForwardIterator __t,
5696 _UniformRandomNumberGenerator& __urng)
5697 { this->__generate(__f, __t, __urng, _M_param); }
5699 template<
typename _ForwardIterator,
5700 typename _UniformRandomNumberGenerator>
5702 __generate(_ForwardIterator __f, _ForwardIterator __t,
5703 _UniformRandomNumberGenerator& __urng,
5704 const param_type& __p)
5705 { this->__generate_impl(__f, __t, __urng, __p); }
5707 template<
typename _UniformRandomNumberGenerator>
5710 _UniformRandomNumberGenerator& __urng,
5711 const param_type& __p)
5712 { this->__generate_impl(__f, __t, __urng, __p); }
5721 {
return __d1._M_param == __d2._M_param; }
5733 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5749 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5755 template<
typename _ForwardIterator,
5756 typename _UniformRandomNumberGenerator>
5758 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5759 _UniformRandomNumberGenerator& __urng,
5765#if __cpp_impl_three_way_comparison < 201907L
5770 template<
typename _IntType>
5774 {
return !(__d1 == __d2); }
5793 template<
typename _RealType =
double>
5797 "result_type must be a floating point type");
5810 : _M_int(), _M_den(), _M_cp()
5813 template<
typename _InputIteratorB,
typename _InputIteratorW>
5815 _InputIteratorB __bend,
5816 _InputIteratorW __wbegin);
5818 template<
typename _Func>
5821 template<
typename _Func>
5822 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
5835 __tmp[1] = _RealType(1);
5848 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5850#if __cpp_impl_three_way_comparison < 201907L
5853 {
return !(__p1 == __p2); }
5869 template<
typename _InputIteratorB,
typename _InputIteratorW>
5871 _InputIteratorB __bend,
5872 _InputIteratorW __wbegin)
5873 : _M_param(__bfirst, __bend, __wbegin)
5876 template<
typename _Func>
5877 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5879 : _M_param(__bl, __fw)
5882 template<
typename _Func>
5883 piecewise_constant_distribution(
size_t __nw,
5884 _RealType __xmin, _RealType __xmax,
5886 : _M_param(__nw, __xmin, __xmax, __fw)
5890 piecewise_constant_distribution(
const param_type& __p)
5907 if (_M_param._M_int.
empty())
5910 __tmp[1] = _RealType(1);
5914 return _M_param._M_int;
5923 return _M_param._M_den.
empty()
5932 {
return _M_param; }
5940 { _M_param = __param; }
5948 return _M_param._M_int.
empty()
5958 return _M_param._M_int.
empty()
5965 template<
typename _UniformRandomNumberGenerator>
5968 {
return this->
operator()(__urng, _M_param); }
5970 template<
typename _UniformRandomNumberGenerator>
5972 operator()(_UniformRandomNumberGenerator& __urng,
5973 const param_type& __p);
5975 template<
typename _ForwardIterator,
5976 typename _UniformRandomNumberGenerator>
5978 __generate(_ForwardIterator __f, _ForwardIterator __t,
5979 _UniformRandomNumberGenerator& __urng)
5980 { this->__generate(__f, __t, __urng, _M_param); }
5982 template<
typename _ForwardIterator,
5983 typename _UniformRandomNumberGenerator>
5985 __generate(_ForwardIterator __f, _ForwardIterator __t,
5986 _UniformRandomNumberGenerator& __urng,
5987 const param_type& __p)
5988 { this->__generate_impl(__f, __t, __urng, __p); }
5990 template<
typename _UniformRandomNumberGenerator>
5993 _UniformRandomNumberGenerator& __urng,
5994 const param_type& __p)
5995 { this->__generate_impl(__f, __t, __urng, __p); }
6004 {
return __d1._M_param == __d2._M_param; }
6017 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6033 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6039 template<
typename _ForwardIterator,
6040 typename _UniformRandomNumberGenerator>
6042 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6043 _UniformRandomNumberGenerator& __urng,
6049#if __cpp_impl_three_way_comparison < 201907L
6054 template<
typename _RealType>
6058 {
return !(__d1 == __d2); }
6073 template<
typename _RealType =
double>
6077 "result_type must be a floating point type");
6090 : _M_int(), _M_den(), _M_cp(), _M_m()
6093 template<
typename _InputIteratorB,
typename _InputIteratorW>
6095 _InputIteratorB __bend,
6096 _InputIteratorW __wbegin);
6098 template<
typename _Func>
6101 template<
typename _Func>
6102 param_type(
size_t __nw, _RealType __xmin, _RealType __xmax,
6115 __tmp[1] = _RealType(1);
6128 {
return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
6130#if __cpp_impl_three_way_comparison < 201907L
6133 {
return !(__p1 == __p2); }
6150 template<
typename _InputIteratorB,
typename _InputIteratorW>
6152 _InputIteratorB __bend,
6153 _InputIteratorW __wbegin)
6154 : _M_param(__bfirst, __bend, __wbegin)
6157 template<
typename _Func>
6158 piecewise_linear_distribution(initializer_list<_RealType> __bl,
6160 : _M_param(__bl, __fw)
6163 template<
typename _Func>
6164 piecewise_linear_distribution(
size_t __nw,
6165 _RealType __xmin, _RealType __xmax,
6167 : _M_param(__nw, __xmin, __xmax, __fw)
6171 piecewise_linear_distribution(
const param_type& __p)
6188 if (_M_param._M_int.
empty())
6191 __tmp[1] = _RealType(1);
6195 return _M_param._M_int;
6205 return _M_param._M_den.
empty()
6214 {
return _M_param; }
6222 { _M_param = __param; }
6230 return _M_param._M_int.
empty()
6240 return _M_param._M_int.
empty()
6247 template<
typename _UniformRandomNumberGenerator>
6250 {
return this->
operator()(__urng, _M_param); }
6252 template<
typename _UniformRandomNumberGenerator>
6254 operator()(_UniformRandomNumberGenerator& __urng,
6255 const param_type& __p);
6257 template<
typename _ForwardIterator,
6258 typename _UniformRandomNumberGenerator>
6260 __generate(_ForwardIterator __f, _ForwardIterator __t,
6261 _UniformRandomNumberGenerator& __urng)
6262 { this->__generate(__f, __t, __urng, _M_param); }
6264 template<
typename _ForwardIterator,
6265 typename _UniformRandomNumberGenerator>
6267 __generate(_ForwardIterator __f, _ForwardIterator __t,
6268 _UniformRandomNumberGenerator& __urng,
6269 const param_type& __p)
6270 { this->__generate_impl(__f, __t, __urng, __p); }
6272 template<
typename _UniformRandomNumberGenerator>
6275 _UniformRandomNumberGenerator& __urng,
6276 const param_type& __p)
6277 { this->__generate_impl(__f, __t, __urng, __p); }
6286 {
return __d1._M_param == __d2._M_param; }
6299 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6315 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6321 template<
typename _ForwardIterator,
6322 typename _UniformRandomNumberGenerator>
6324 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6325 _UniformRandomNumberGenerator& __urng,
6331#if __cpp_impl_three_way_comparison < 201907L
6336 template<
typename _RealType>
6340 {
return !(__d1 == __d2); }
6371 template<
typename _IntType,
typename = _Require<is_
integral<_IntType>>>
6374 template<
typename _InputIterator>
6375 seed_seq(_InputIterator __begin, _InputIterator __end);
6378 template<
typename _RandomAccessIterator>
6380 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6383 size_t size() const noexcept
6384 {
return _M_v.
size(); }
6386 template<
typename _OutputIterator>
6388 param(_OutputIterator __dest)
const
6389 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
6403_GLIBCXX_END_NAMESPACE_VERSION
constexpr bool operator<=(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr duration< __common_rep_t< _Rep1, __disable_if_is_duration< _Rep2 > >, _Period > operator%(const duration< _Rep1, _Period > &__d, const _Rep2 &__s)
constexpr bool operator<(const duration< _Rep1, _Period1 > &__lhs, const duration< _Rep2, _Period2 > &__rhs)
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
constexpr complex< _Tp > operator+(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x plus y.
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
_RealType generate_canonical(_UniformRandomNumberGenerator &__g)
A function template for converting the output of a (integral) uniform random number generator to a fl...
linear_congruential_engine< uint_fast32_t, 48271UL, 0UL, 2147483647UL > minstd_rand
linear_congruential_engine< uint_fast32_t, 16807UL, 0UL, 2147483647UL > minstd_rand0
mersenne_twister_engine< uint_fast32_t, 32, 624, 397, 31, 0x9908b0dfUL, 11, 0xffffffffUL, 7, 0x9d2c5680UL, 15, 0xefc60000UL, 18, 1812433253UL > mt19937
mersenne_twister_engine< uint_fast64_t, 64, 312, 156, 31, 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL, 17, 0x71d67fffeda60000ULL, 37, 0xfff7eee000000000ULL, 43, 6364136223846793005ULL > mt19937_64
ISO C++ entities toplevel namespace is std.
constexpr _Tp __lg(_Tp __n)
This is a helper function for the sort routines and for random.tcc.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Template class basic_istream.
Template class basic_ostream.
Properties of fundamental types.
static constexpr _Tp max() noexcept
static constexpr _Tp lowest() noexcept
static constexpr _Tp min() noexcept
A model of a linear congruential random number generator.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::linear_congruential_engine< _UIntType1, __a1, __c1, __m1 > &__lcr)
Sets the state of the engine by reading its textual representation from __is.
linear_congruential_engine(result_type __s)
Constructs a linear_congruential_engine random number generator engine with seed __s....
linear_congruential_engine(_Sseq &__q)
Constructs a linear_congruential_engine random number generator engine seeded from the seed sequence ...
static constexpr result_type min()
Gets the smallest possible value in the output range.
static constexpr result_type multiplier
void discard(unsigned long long __z)
Discard a sequence of random numbers.
linear_congruential_engine()
Constructs a linear_congruential_engine random number generator engine with seed 1.
void seed(result_type __s=default_seed)
Reseeds the linear_congruential_engine random number generator engine sequence to the seed __s.
static constexpr result_type increment
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the linear_congruential_engine random number generator engine sequence using values from the ...
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.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::linear_congruential_engine< _UIntType1, __a1, __c1, __m1 > &__lcr)
Writes the textual representation of the state x(i) of x to __os.
result_type operator()()
Gets the next random number in the sequence.
static constexpr result_type max()
Gets the largest possible value in the output range.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
mersenne_twister_engine(_Sseq &__q)
Constructs a mersenne_twister_engine random number generator engine seeded from the seed sequence __q...
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::mersenne_twister_engine< _UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1 > &__x)
Extracts the current state of a % mersenne_twister_engine random number generator engine __x from the...
static constexpr result_type max()
Gets the largest possible value in the output range.
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.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::mersenne_twister_engine< _UIntType1, __w1, __n1, __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, __l1, __f1 > &__x)
Inserts the current state of a % mersenne_twister_engine random number generator engine __x into the ...
static constexpr result_type min()
Gets the smallest possible value in the output range.
The Marsaglia-Zaman generator.
void seed(result_type __sd=0u)
Seeds the initial state of the random number generator.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::subtract_with_carry_engine< _UIntType1, __w1, __s1, __r1 > &__x)
Inserts the current state of a % subtract_with_carry_engine random number generator engine __x into t...
subtract_with_carry_engine(result_type __sd)
Constructs an explicitly seeded subtract_with_carry_engine random number generator.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
result_type operator()()
Gets the next random number in the sequence.
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Seeds the initial state of the % subtract_with_carry_engine random number generator.
static constexpr result_type min()
Gets the inclusive minimum value of the range of random integers returned by this generator.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::subtract_with_carry_engine< _UIntType1, __w1, __s1, __r1 > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
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...
subtract_with_carry_engine(_Sseq &__q)
Constructs a subtract_with_carry_engine random number engine seeded from the seed sequence __q.
static constexpr result_type max()
Gets the inclusive maximum value of the range of random integers returned by this generator.
void seed(result_type __s)
Reseeds the discard_block_engine object with the default seed for the underlying base class generator...
static constexpr result_type min()
Gets the minimum value in the generated random number range.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::discard_block_engine< _RandomNumberEngine1, __p1, __r1 > &__x)
Inserts the current state of a discard_block_engine random number generator engine __x into the outpu...
const _RandomNumberEngine & base() const noexcept
Gets a const reference to the underlying generator engine object.
void seed()
Reseeds the discard_block_engine object with the default seed for the underlying base class generator...
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the discard_block_engine object with the given seed sequence.
discard_block_engine(const _RandomNumberEngine &__rng)
Copy constructs a discard_block_engine engine.
void discard(unsigned long long __z)
Discard a sequence of random numbers.
discard_block_engine(_RandomNumberEngine &&__rng)
Move constructs a discard_block_engine engine.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::discard_block_engine< _RandomNumberEngine1, __p1, __r1 > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
static constexpr result_type max()
Gets the maximum value in the generated random number range.
discard_block_engine()
Constructs a default discard_block_engine engine.
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.
discard_block_engine(_Sseq &__q)
Generator construct a discard_block_engine engine.
result_type operator()()
Gets the next value in the generated random number sequence.
discard_block_engine(result_type __s)
Seed constructs a discard_block_engine engine.
_RandomNumberEngine::result_type result_type
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the independent_bits_engine object with the given seed sequence.
independent_bits_engine(_Sseq &__q)
Generator construct a independent_bits_engine engine.
independent_bits_engine(const _RandomNumberEngine &__rng)
Copy constructs a independent_bits_engine engine.
static constexpr result_type min()
Gets the minimum value in the generated random number range.
result_type operator()()
Gets the next value in the generated random number sequence.
void seed()
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
void discard(unsigned long long __z)
Discard a sequence of random numbers.
void seed(result_type __s)
Reseeds the independent_bits_engine object with the default seed for the underlying base class genera...
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 ...
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.
static constexpr result_type max()
Gets the maximum value in the generated random number range.
independent_bits_engine()
Constructs a default independent_bits_engine engine.
const _RandomNumberEngine & base() const noexcept
Gets a const reference to the underlying generator engine object.
independent_bits_engine(result_type __s)
Seed constructs a independent_bits_engine engine.
independent_bits_engine(_RandomNumberEngine &&__rng)
Move constructs a independent_bits_engine engine.
Produces random numbers by reordering random numbers from some base engine.
_If_seed_seq< _Sseq > seed(_Sseq &__q)
Reseeds the shuffle_order_engine object with the given seed sequence.
static constexpr result_type min()
shuffle_order_engine()
Constructs a default shuffle_order_engine engine.
static constexpr result_type max()
shuffle_order_engine(const _RandomNumberEngine &__rng)
Copy constructs a shuffle_order_engine engine.
shuffle_order_engine(_Sseq &__q)
Generator construct a shuffle_order_engine engine.
const _RandomNumberEngine & base() const noexcept
shuffle_order_engine(_RandomNumberEngine &&__rng)
Move constructs a shuffle_order_engine engine.
void seed()
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
shuffle_order_engine(result_type __s)
Seed constructs a shuffle_order_engine engine.
_RandomNumberEngine::result_type result_type
friend bool operator==(const shuffle_order_engine &__lhs, const shuffle_order_engine &__rhs)
void discard(unsigned long long __z)
void seed(result_type __s)
Reseeds the shuffle_order_engine object with the default seed for the underlying base class generator...
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::shuffle_order_engine< _RandomNumberEngine1, __k1 > &__x)
Inserts the current state of a shuffle_order_engine random number generator engine __x into the outpu...
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::shuffle_order_engine< _RandomNumberEngine1, __k1 > &__x)
Extracts the current state of a % subtract_with_carry_engine random number generator engine __x from ...
Uniform continuous distribution for random numbers.
param_type param() const
Returns the parameter set of the distribution.
void reset()
Resets the distribution state.
uniform_real_distribution(_RealType __a, _RealType __b=_RealType(1))
Constructs a uniform_real_distribution object.
result_type min() const
Returns the inclusive lower bound of the distribution range.
friend bool operator==(const uniform_real_distribution &__d1, const uniform_real_distribution &__d2)
Return true if two uniform real distributions have the same parameters.
result_type max() const
Returns the inclusive upper bound of the distribution range.
uniform_real_distribution()
Constructs a uniform_real_distribution object.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void param(const param_type &__param)
Sets the parameter set of the distribution.
A normal continuous distribution for random numbers.
_RealType stddev() const
Returns the standard deviation of the distribution.
param_type param() const
Returns the parameter set of the distribution.
void reset()
Resets the distribution state.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::normal_distribution< _RealType1 > &__x)
Extracts a normal_distribution random number distribution __x from the input stream __is.
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.
_RealType mean() const
Returns the mean of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::normal_distribution< _RealType1 > &__x)
Inserts a normal_distribution random number distribution __x into the output stream __os.
normal_distribution(result_type __mean, result_type __stddev=result_type(1))
result_type max() const
Returns the least upper bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend bool operator==(const std::normal_distribution< _RealType1 > &__d1, const std::normal_distribution< _RealType1 > &__d2)
Return true if two normal distributions have the same parameters and the sequences that would be gene...
A lognormal_distribution random number distribution.
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...
param_type param() const
Returns the parameter set of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::lognormal_distribution< _RealType1 > &__x)
Extracts a lognormal_distribution random number distribution __x from the input stream __is.
result_type min() const
Returns the greatest lower bound value of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::lognormal_distribution< _RealType1 > &__x)
Inserts a lognormal_distribution random number distribution __x into the output stream __os.
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 operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
A gamma continuous distribution for random numbers.
gamma_distribution(_RealType __alpha_val, _RealType __beta_val=_RealType(1))
Constructs a gamma distribution with parameters and .
void reset()
Resets the distribution state.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::gamma_distribution< _RealType1 > &__x)
Inserts a gamma_distribution random number distribution __x into the output stream __os.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type min() const
Returns the greatest lower bound value of the distribution.
_RealType alpha() const
Returns the of the distribution.
gamma_distribution()
Constructs a gamma distribution with parameters 1 and 1.
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...
void param(const param_type &__param)
Sets the parameter set of the distribution.
_RealType beta() const
Returns the of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::gamma_distribution< _RealType1 > &__x)
Extracts a gamma_distribution random number distribution __x from the input stream __is.
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 chi_squared_distribution random number distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
param_type param() const
Returns the parameter set of the distribution.
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...
result_type min() const
Returns the greatest lower bound value of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::chi_squared_distribution< _RealType1 > &__x)
Inserts a chi_squared_distribution random number distribution __x into the output stream __os.
void reset()
Resets the distribution state.
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.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::chi_squared_distribution< _RealType1 > &__x)
Extracts a chi_squared_distribution random number distribution __x from the input stream __is.
A cauchy_distribution random number distribution.
result_type min() const
Returns the greatest lower 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.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type max() const
Returns the least upper bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
A fisher_f_distribution random number 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.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
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...
result_type min() const
Returns the greatest lower bound value of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::fisher_f_distribution< _RealType1 > &__x)
Inserts a fisher_f_distribution random number distribution __x into the output stream __os.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::fisher_f_distribution< _RealType1 > &__x)
Extracts a fisher_f_distribution random number distribution __x from the input stream __is.
A student_t_distribution random number 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.
result_type min() const
Returns the greatest lower bound value of the distribution.
void reset()
Resets the distribution state.
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...
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::student_t_distribution< _RealType1 > &__x)
Inserts a student_t_distribution random number distribution __x into the output stream __os.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::student_t_distribution< _RealType1 > &__x)
Extracts a student_t_distribution random number distribution __x from the input stream __is.
param_type param() const
Returns the parameter set of the distribution.
A Bernoulli random number distribution.
void reset()
Resets the distribution state.
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.
param_type param() const
Returns the parameter set of the distribution.
bernoulli_distribution()
Constructs a Bernoulli distribution with likelihood 0.5.
bernoulli_distribution(double __p)
Constructs a Bernoulli distribution with likelihood p.
result_type min() const
Returns the greatest lower bound value of the distribution.
double p() const
Returns the p parameter of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
A discrete binomial random number distribution.
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.
void param(const param_type &__param)
Sets the parameter set of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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...
param_type param() const
Returns the parameter set of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::binomial_distribution< _IntType1 > &__x)
Extracts a binomial_distribution random number distribution __x from the input stream __is.
_IntType t() const
Returns the distribution t parameter.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::binomial_distribution< _IntType1 > &__x)
Inserts a binomial_distribution random number distribution __x into the output stream __os.
void reset()
Resets the distribution state.
double p() const
Returns the distribution p parameter.
A discrete geometric random number distribution.
double p() const
Returns the distribution parameter p.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type max() const
Returns the least upper bound value of the distribution.
friend bool operator==(const geometric_distribution &__d1, const geometric_distribution &__d2)
Return true if two geometric distributions have the same parameters.
param_type param() const
Returns the parameter set of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
void reset()
Resets the distribution state.
result_type min() const
Returns the greatest lower bound value of the distribution.
A negative_binomial_distribution random number distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::negative_binomial_distribution< _IntType1 > &__x)
Inserts a negative_binomial_distribution random number distribution __x into the output stream __os.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::negative_binomial_distribution< _IntType1 > &__x)
Extracts a negative_binomial_distribution random number distribution __x from the input stream __is.
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.
result_type max() const
Returns the least upper bound value of the distribution.
double p() const
Return the parameter of the distribution.
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...
param_type param() const
Returns the parameter set of the distribution.
_IntType k() const
Return the parameter of the distribution.
void reset()
Resets the distribution state.
A discrete Poisson random number distribution.
void reset()
Resets the distribution state.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
double mean() const
Returns the distribution parameter mean.
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...
result_type max() const
Returns the least upper bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::poisson_distribution< _IntType1 > &__x)
Inserts a poisson_distribution random number distribution __x into the output stream __os.
param_type param() const
Returns the parameter set of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::poisson_distribution< _IntType1 > &__x)
Extracts a poisson_distribution random number distribution __x from the input stream __is.
result_type min() const
Returns the greatest lower bound value of the distribution.
An exponential continuous distribution for random numbers.
_RealType lambda() const
Returns the inverse scale parameter of the distribution.
exponential_distribution()
Constructs an exponential distribution with inverse scale parameter 1.0.
exponential_distribution(_RealType __lambda)
Constructs an exponential distribution with inverse scale parameter .
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.
param_type param() const
Returns the parameter set of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
void param(const param_type &__param)
Sets the parameter set of the distribution.
friend bool operator==(const exponential_distribution &__d1, const exponential_distribution &__d2)
Return true if two exponential distributions have the same parameters.
A weibull_distribution random number distribution.
param_type param() const
Returns the parameter set of the distribution.
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.
friend bool operator==(const weibull_distribution &__d1, const weibull_distribution &__d2)
Return true if two Weibull distributions have the same parameters.
void param(const param_type &__param)
Sets the parameter set of the distribution.
_RealType b() const
Return the parameter of the distribution.
result_type max() const
Returns the least upper bound value of the distribution.
_RealType a() const
Return the parameter of the distribution.
A extreme_value_distribution random number distribution.
void reset()
Resets the distribution state.
_RealType b() const
Return the parameter of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
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.
result_type max() const
Returns the least upper bound value of the distribution.
_RealType a() const
Return the parameter of the distribution.
friend bool operator==(const extreme_value_distribution &__d1, const extreme_value_distribution &__d2)
Return true if two extreme value distributions have the same parameters.
param_type param() const
Returns the parameter set of the distribution.
A discrete_distribution random number distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::discrete_distribution< _IntType1 > &__x)
Inserts a discrete_distribution random number distribution __x into the output stream __os.
result_type min() const
Returns the greatest lower bound value of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::discrete_distribution< _IntType1 > &__x)
Extracts a discrete_distribution random number distribution __x from the input stream __is.
result_type max() const
Returns the least upper bound value of the distribution.
void reset()
Resets the distribution state.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const discrete_distribution &__d1, const discrete_distribution &__d2)
Return true if two discrete distributions have the same parameters.
std::vector< double > probabilities() const
Returns the probabilities of the distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
void param(const param_type &__param)
Sets the parameter set of the distribution.
A piecewise_constant_distribution random number distribution.
std::vector< double > densities() const
Returns a vector of the probability densities.
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.
result_type max() const
Returns the least upper bound value of the distribution.
void reset()
Resets the distribution state.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::piecewise_constant_distribution< _RealType1 > &__x)
Inserts a piecewise_constant_distribution random number distribution __x into the output stream __os.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const piecewise_constant_distribution &__d1, const piecewise_constant_distribution &__d2)
Return true if two piecewise constant distributions have the same parameters.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::piecewise_constant_distribution< _RealType1 > &__x)
Extracts a piecewise_constant_distribution random number distribution __x from the input stream __is.
std::vector< _RealType > intervals() const
Returns a vector of the intervals.
A piecewise_linear_distribution random number distribution.
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
result_type max() const
Returns the least upper bound value of the distribution.
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::piecewise_linear_distribution< _RealType1 > &__x)
Extracts a piecewise_linear_distribution random number distribution __x from the input stream __is.
std::vector< _RealType > intervals() const
Return the intervals of the distribution.
param_type param() const
Returns the parameter set of the distribution.
friend bool operator==(const piecewise_linear_distribution &__d1, const piecewise_linear_distribution &__d2)
Return true if two piecewise linear distributions have the same parameters.
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.
std::vector< double > densities() const
Return a vector of the probability densities of the distribution.
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::piecewise_linear_distribution< _RealType1 > &__x)
Inserts a piecewise_linear_distribution random number distribution __x into the output stream __os.
The seed_seq class generates sequences of seeds for random number generators.
uint_least32_t result_type
One of the math functors.
A standard container which offers fixed time access to individual elements in any order.
constexpr iterator end() noexcept
constexpr iterator begin() noexcept
constexpr reference front() noexcept
constexpr bool empty() const noexcept
constexpr size_type size() const noexcept
constexpr reference back() noexcept
Uniform discrete distribution for random numbers. A discrete random distribution on the range with e...