37namespace std _GLIBCXX_VISIBILITY(default)
39_GLIBCXX_BEGIN_NAMESPACE_VERSION
58 template<
typename _RealType,
size_t __bits,
59 typename _UniformRandomNumberGenerator>
68 template<
typename _UIntType,
size_t __w,
69 bool = __w < static_cast<size_t>
72 {
static const _UIntType __value = 0; };
74 template<
typename _UIntType,
size_t __w>
75 struct _Shift<_UIntType, __w, true>
76 {
static const _UIntType __value = _UIntType(1) << __w; };
79 int __which = ((__s <= __CHAR_BIT__ *
sizeof (int))
80 + (__s <= __CHAR_BIT__ *
sizeof (long))
81 + (__s <= __CHAR_BIT__ *
sizeof (
long long))
84 struct _Select_uint_least_t
86 static_assert(__which < 0,
87 "sorry, would be too much trouble for a slow result");
91 struct _Select_uint_least_t<__s, 4>
92 {
typedef unsigned int type; };
95 struct _Select_uint_least_t<__s, 3>
96 {
typedef unsigned long type; };
99 struct _Select_uint_least_t<__s, 2>
100 {
typedef unsigned long long type; };
102#ifdef _GLIBCXX_USE_INT128
104 struct _Select_uint_least_t<__s, 1>
105 {
typedef unsigned __int128 type; };
109 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
110 bool __big_enough = (!(__m & (__m - 1))
111 || (_Tp(-1) - __c) / __a >= __m - 1),
112 bool __schrage_ok = __m % __a < __m / __a>
115 typedef typename _Select_uint_least_t<
std::__lg(__a)
119 {
return static_cast<_Tp
>((_Tp2(__a) * __x + __c) % __m); }
123 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
124 struct _Mod<_Tp, __m, __a, __c, false, true>
133 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
134 struct _Mod<_Tp, __m, __a, __c, true, __s>
139 _Tp __res = __a * __x + __c;
146 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
150 if _GLIBCXX17_CONSTEXPR (__a == 0)
155 constexpr _Tp __a1 = __a ? __a : 1;
156 return _Mod<_Tp, __m, __a1, __c>::__calc(__x);
164 template<
typename _Engine,
typename _DInputType>
168 "template argument must be a floating point type");
171 _Adaptor(_Engine& __g)
176 {
return _DInputType(0); }
180 {
return _DInputType(1); }
199 template<
typename _Sseq>
200 using __seed_seq_generate_t =
decltype(
206 template<
typename _Sseq,
typename _Engine,
typename _Res,
207 typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
208 using __is_seed_seq = __and_<
209 __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
210 is_unsigned<typename _Sseq::result_type>,
211 __not_<is_convertible<_Sseq, _Res>>
254 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
258 "result_type must be an unsigned integral type");
259 static_assert(
__m == 0
u || (__a <
__m && __c <
__m),
260 "template argument substituting __m out of bounds");
262 template<
typename _Sseq>
263 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
302 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
323 template<
typename _Sseq>
335 {
return __c == 0
u ? 1u : 0
u; }
360 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
430 template<
typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
467 template<
typename _UIntType,
size_t __w,
468 size_t __n,
size_t __m,
size_t __r,
469 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
470 _UIntType __b,
size_t __t,
471 _UIntType __c,
size_t __l, _UIntType __f>
475 "result_type must be an unsigned integral type");
476 static_assert(1u <=
__m &&
__m <= __n,
477 "template argument substituting __m out of bounds");
478 static_assert(__r <=
__w,
"template argument substituting "
480 static_assert(
__u <=
__w,
"template argument substituting "
482 static_assert(
__s <=
__w,
"template argument substituting "
484 static_assert(__t <=
__w,
"template argument substituting "
486 static_assert(
__l <=
__w,
"template argument substituting "
489 "template argument substituting __w out of bound");
490 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
491 "template argument substituting __a out of bound");
492 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
493 "template argument substituting __b out of bound");
494 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
495 "template argument substituting __c out of bound");
496 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
497 "template argument substituting __d out of bound");
498 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
499 "template argument substituting __f out of bound");
501 template<
typename _Sseq>
502 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
510 static constexpr size_t word_size =
__w;
511 static constexpr size_t state_size = __n;
512 static constexpr size_t shift_size =
__m;
513 static constexpr size_t mask_bits = __r;
515 static constexpr size_t tempering_u =
__u;
517 static constexpr size_t tempering_s =
__s;
519 static constexpr size_t tempering_t = __t;
521 static constexpr size_t tempering_l =
__l;
522 static constexpr result_type initialization_multiplier = __f;
539 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
547 template<
typename _Sseq>
563 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
611 typename _CharT,
typename _Traits>
637 typename _CharT,
typename _Traits>
647 _UIntType _M_x[state_size];
663 template<
typename _UIntType,
size_t __w,
664 size_t __n,
size_t __m,
size_t __r,
665 _UIntType __a,
size_t __u, _UIntType __d,
size_t __s,
666 _UIntType __b,
size_t __t,
667 _UIntType __c,
size_t __l, _UIntType __f>
670 __r, __a,
__u, __d,
__s, __b, __t, __c,
__l, __f>&
__lhs,
691 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
695 "result_type must be an unsigned integral type");
696 static_assert(0
u <
__s &&
__s < __r,
699 "template argument substituting __w out of bounds");
701 template<
typename _Sseq>
702 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
710 static constexpr size_t word_size =
__w;
711 static constexpr size_t short_lag =
__s;
712 static constexpr size_t long_lag = __r;
713 static constexpr result_type default_seed = 19780503u;
732 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
756 template<
typename _Sseq>
774 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
824 typename _CharT,
typename _Traits>
843 typename _CharT,
typename _Traits>
851 _UIntType _M_x[long_lag];
868 template<
typename _UIntType,
size_t __w,
size_t __s,
size_t __r>
883 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
886 static_assert(1 <= __r && __r <= __p,
887 "template argument substituting __r out of bounds");
893 template<
typename _Sseq>
894 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
898 static constexpr size_t block_size = __p;
899 static constexpr size_t used_block = __r;
907 : _M_b(), _M_n(0) { }
917 : _M_b(
__rng), _M_n(0) { }
937 : _M_b(
__s), _M_n(0) { }
944 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
977 template<
typename _Sseq>
989 const _RandomNumberEngine&
998 {
return _RandomNumberEngine::min(); }
1005 {
return _RandomNumberEngine::max(); }
1051 typename _CharT,
typename _Traits>
1069 typename _CharT,
typename _Traits>
1076 _RandomNumberEngine _M_b;
1091 template<
typename _RandomNumberEngine,
size_t __p,
size_t __r>
1104 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1108 "result_type must be an unsigned integral type");
1110 "template argument substituting __w out of bounds");
1112 template<
typename _Sseq>
1113 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
1163 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1190 template<
typename _Sseq>
1199 const _RandomNumberEngine&
1215 {
return __detail::_Shift<_UIntType, __w>::__value - 1; }
1262 template<
typename _CharT,
typename _Traits>
1266 __w, _UIntType>& __x)
1273 _RandomNumberEngine _M_b;
1288 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType>
1306 template<
typename _RandomNumberEngine,
size_t __w,
typename _UIntType,
1307 typename _CharT,
typename _Traits>
1311 __w, _UIntType>& __x)
1323 template<
typename _RandomNumberEngine,
size_t __k>
1326 static_assert(1u <=
__k,
"template argument substituting "
1327 "__k out of bound");
1333 template<
typename _Sseq>
1334 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
1337 static constexpr size_t table_size =
__k;
1346 { _M_initialize(); }
1357 { _M_initialize(); }
1368 { _M_initialize(); }
1379 { _M_initialize(); }
1386 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1390 { _M_initialize(); }
1419 template<
typename _Sseq>
1430 const _RandomNumberEngine&
1439 {
return _RandomNumberEngine::min(); }
1446 {
return _RandomNumberEngine::max(); }
1494 typename _CharT,
typename _Traits>
1512 typename _CharT,
typename _Traits>
1518 void _M_initialize()
1520 for (
size_t __i = 0; __i <
__k; ++__i)
1525 _RandomNumberEngine _M_b;
1541 template<
typename _RandomNumberEngine,
size_t __k>
1553 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1584 0xb5026f5aa96619e9ULL, 29,
1585 0x5555555555555555ULL, 17,
1586 0x71d67fffeda60000ULL, 37,
1587 0xfff7eee000000000ULL, 43,
1621#if defined _GLIBCXX_USE_DEV_RANDOM
1635 entropy() const noexcept
1637#ifdef _GLIBCXX_USE_DEV_RANDOM
1638 return this->_M_getentropy();
1646 {
return this->_M_getval(); }
1649 random_device(
const random_device&) =
delete;
1650 void operator=(
const random_device&) =
delete;
1660 double _M_getentropy() const noexcept;
1662 void _M_init(const
char*,
size_t);
1696 template<
typename _IntType>
1712 template<
typename _IntType,
typename _CharT,
typename _Traits>
1726 template<
typename _IntType,
typename _CharT,
typename _Traits>
1739 template<
typename _RealType =
double>
1743 "result_type must be a floating point type");
1757 param_type(_RealType __a, _RealType __b = _RealType(1))
1758 : _M_a(__a), _M_b(__b)
1760 __glibcxx_assert(_M_a <= _M_b);
1800 : _M_param(__a, __b)
1818 {
return _M_param.a(); }
1822 {
return _M_param.b(); }
1829 {
return _M_param; }
1844 {
return this->a(); }
1851 {
return this->b(); }
1856 template<
typename _UniformRandomNumberGenerator>
1859 {
return this->
operator()(__urng, _M_param); }
1861 template<
typename _UniformRandomNumberGenerator>
1864 const param_type& __p)
1866 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1868 return (
__aurng() * (__p.b() - __p.a())) + __p.a();
1871 template<
typename _ForwardIterator,
1872 typename _UniformRandomNumberGenerator>
1874 __generate(_ForwardIterator __f, _ForwardIterator __t,
1875 _UniformRandomNumberGenerator& __urng)
1876 { this->__generate(__f, __t, __urng, _M_param); }
1878 template<
typename _ForwardIterator,
1879 typename _UniformRandomNumberGenerator>
1881 __generate(_ForwardIterator __f, _ForwardIterator __t,
1882 _UniformRandomNumberGenerator& __urng,
1883 const param_type& __p)
1884 { this->__generate_impl(__f, __t, __urng, __p); }
1886 template<
typename _UniformRandomNumberGenerator>
1889 _UniformRandomNumberGenerator& __urng,
1890 const param_type& __p)
1891 { this->__generate_impl(__f, __t, __urng, __p); }
1900 {
return __d1._M_param ==
__d2._M_param; }
1908 const param_type& __p);
1910 param_type _M_param;
1917 template<
typename _IntType>
1933 template<
typename _RealType,
typename _CharT,
typename _Traits>
1947 template<
typename _RealType,
typename _CharT,
typename _Traits>
1969 template<
typename _RealType =
double>
1973 "result_type must be a floating point type");
1990 __glibcxx_assert(_M_stddev > _RealType(0));
1999 {
return _M_stddev; }
2003 {
return (
__p1._M_mean ==
__p2._M_mean
2004 &&
__p1._M_stddev ==
__p2._M_stddev); }
2012 _RealType _M_stddev;
2038 { _M_saved_available =
false; }
2045 {
return _M_param.mean(); }
2052 {
return _M_param.stddev(); }
2059 {
return _M_param; }
2086 template<
typename _UniformRandomNumberGenerator>
2089 {
return this->
operator()(__urng, _M_param); }
2091 template<
typename _UniformRandomNumberGenerator>
2094 const param_type& __p);
2101 { this->__generate(__f, __t,
__urng, _M_param); }
2103 template<
typename _ForwardIterator,
2104 typename _UniformRandomNumberGenerator>
2106 __generate(_ForwardIterator __f, _ForwardIterator __t,
2107 _UniformRandomNumberGenerator& __urng,
2108 const param_type& __p)
2109 { this->__generate_impl(__f, __t, __urng, __p); }
2111 template<
typename _UniformRandomNumberGenerator>
2114 _UniformRandomNumberGenerator& __urng,
2115 const param_type& __p)
2116 { this->__generate_impl(__f, __t, __urng, __p); }
2123 template<
typename _RealType1>
2138 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2153 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2168 bool _M_saved_available =
false;
2174 template<
typename _RealType>
2190 template<
typename _RealType =
double>
2194 "result_type must be a floating point type");
2237 : _M_param(
__m,
__s), _M_nd()
2241 lognormal_distribution(
const param_type& __p)
2242 : _M_param(__p), _M_nd()
2257 {
return _M_param.m(); }
2261 {
return _M_param.s(); }
2268 {
return _M_param; }
2295 template<
typename _UniformRandomNumberGenerator>
2298 {
return this->
operator()(__urng, _M_param); }
2300 template<
typename _UniformRandomNumberGenerator>
2303 const param_type& __p)
2306 template<
typename _ForwardIterator,
2307 typename _UniformRandomNumberGenerator>
2309 __generate(_ForwardIterator __f, _ForwardIterator __t,
2310 _UniformRandomNumberGenerator& __urng)
2311 { this->__generate(__f, __t, __urng, _M_param); }
2313 template<
typename _ForwardIterator,
2314 typename _UniformRandomNumberGenerator>
2316 __generate(_ForwardIterator __f, _ForwardIterator __t,
2317 _UniformRandomNumberGenerator& __urng,
2318 const param_type& __p)
2319 { this->__generate_impl(__f, __t, __urng, __p); }
2321 template<
typename _UniformRandomNumberGenerator>
2324 _UniformRandomNumberGenerator& __urng,
2325 const param_type& __p)
2326 { this->__generate_impl(__f, __t, __urng, __p); }
2336 {
return (
__d1._M_param ==
__d2._M_param
2349 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2364 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2385 template<
typename _RealType>
2401 template<
typename _RealType =
double>
2405 "result_type must be a floating point type");
2423 __glibcxx_assert(_M_alpha > _RealType(0));
2429 {
return _M_alpha; }
2437 {
return (
__p1._M_alpha ==
__p2._M_alpha
2438 &&
__p1._M_beta ==
__p2._M_beta); }
2451 _RealType _M_malpha, _M_a2;
2472 : _M_param(__p), _M_nd()
2487 {
return _M_param.alpha(); }
2494 {
return _M_param.beta(); }
2501 {
return _M_param; }
2528 template<
typename _UniformRandomNumberGenerator>
2531 {
return this->
operator()(__urng, _M_param); }
2533 template<
typename _UniformRandomNumberGenerator>
2536 const param_type& __p);
2543 { this->__generate(__f, __t,
__urng, _M_param); }
2545 template<
typename _ForwardIterator,
2546 typename _UniformRandomNumberGenerator>
2548 __generate(_ForwardIterator __f, _ForwardIterator __t,
2549 _UniformRandomNumberGenerator& __urng,
2550 const param_type& __p)
2551 { this->__generate_impl(__f, __t, __urng, __p); }
2553 template<
typename _UniformRandomNumberGenerator>
2556 _UniformRandomNumberGenerator& __urng,
2557 const param_type& __p)
2558 { this->__generate_impl(__f, __t, __urng, __p); }
2568 {
return (
__d1._M_param ==
__d2._M_param
2581 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2595 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2616 template<
typename _RealType>
2629 template<
typename _RealType =
double>
2633 "result_type must be a floating point type");
2671 : _M_param(__n), _M_gd(__n / 2)
2675 chi_squared_distribution(
const param_type& __p)
2676 : _M_param(__p), _M_gd(__p.n() / 2)
2691 {
return _M_param.n(); }
2698 {
return _M_param; }
2730 template<
typename _UniformRandomNumberGenerator>
2733 {
return 2 * _M_gd(
__urng); }
2735 template<
typename _UniformRandomNumberGenerator>
2738 const param_type& __p)
2742 return 2 * _M_gd(
__urng, param_type(__p.n() / 2));
2745 template<
typename _ForwardIterator,
2746 typename _UniformRandomNumberGenerator>
2748 __generate(_ForwardIterator __f, _ForwardIterator __t,
2749 _UniformRandomNumberGenerator& __urng)
2750 { this->__generate_impl(__f, __t, __urng); }
2752 template<
typename _ForwardIterator,
2753 typename _UniformRandomNumberGenerator>
2755 __generate(_ForwardIterator __f, _ForwardIterator __t,
2756 _UniformRandomNumberGenerator& __urng,
2757 const param_type& __p)
2760 this->__generate_impl(__f, __t, __urng, __p2); }
2762 template<
typename _UniformRandomNumberGenerator>
2765 _UniformRandomNumberGenerator& __urng)
2766 { this->__generate_impl(__f, __t, __urng); }
2768 template<
typename _UniformRandomNumberGenerator>
2771 _UniformRandomNumberGenerator& __urng,
2772 const param_type& __p)
2775 this->__generate_impl(__f, __t, __urng, __p2); }
2797 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2812 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2840 template<
typename _RealType>
2853 template<
typename _RealType =
double>
2857 "result_type must be a floating point type");
2871 param_type(_RealType __a, _RealType __b = _RealType(1))
2872 : _M_a(__a), _M_b(__b)
2900 : _M_param(__a, __b)
2904 cauchy_distribution(
const param_type& __p)
2920 {
return _M_param.a(); }
2924 {
return _M_param.b(); }
2931 {
return _M_param; }
2958 template<
typename _UniformRandomNumberGenerator>
2961 {
return this->
operator()(__urng, _M_param); }
2963 template<
typename _UniformRandomNumberGenerator>
2966 const param_type& __p);
2973 { this->__generate(__f, __t,
__urng, _M_param); }
2975 template<
typename _ForwardIterator,
2976 typename _UniformRandomNumberGenerator>
2978 __generate(_ForwardIterator __f, _ForwardIterator __t,
2979 _UniformRandomNumberGenerator& __urng,
2980 const param_type& __p)
2981 { this->__generate_impl(__f, __t, __urng, __p); }
2983 template<
typename _UniformRandomNumberGenerator>
2986 _UniformRandomNumberGenerator& __urng,
2987 const param_type& __p)
2988 { this->__generate_impl(__f, __t, __urng, __p); }
2997 {
return __d1._M_param ==
__d2._M_param; }
3005 const param_type& __p);
3007 param_type _M_param;
3014 template<
typename _RealType>
3030 template<
typename _RealType,
typename _CharT,
typename _Traits>
3045 template<
typename _RealType,
typename _CharT,
typename _Traits>
3061 template<
typename _RealType =
double>
3065 "result_type must be a floating point type");
3080 : _M_m(
__m), _M_n(__n)
3108 _RealType __n = _RealType(1))
3109 : _M_param(
__m, __n), _M_gd_x(
__m / 2), _M_gd_y(__n / 2)
3113 fisher_f_distribution(
const param_type& __p)
3114 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3132 {
return _M_param.m(); }
3136 {
return _M_param.n(); }
3143 {
return _M_param; }
3170 template<
typename _UniformRandomNumberGenerator>
3173 {
return (_M_gd_x(
__urng) * n()) / (_M_gd_y(
__urng) * m()); }
3175 template<
typename _UniformRandomNumberGenerator>
3178 const param_type& __p)
3182 return ((_M_gd_x(
__urng, param_type(__p.m() / 2)) * n())
3183 / (_M_gd_y(
__urng, param_type(__p.n() / 2)) * m()));
3186 template<
typename _ForwardIterator,
3187 typename _UniformRandomNumberGenerator>
3189 __generate(_ForwardIterator __f, _ForwardIterator __t,
3190 _UniformRandomNumberGenerator& __urng)
3191 { this->__generate_impl(__f, __t, __urng); }
3193 template<
typename _ForwardIterator,
3194 typename _UniformRandomNumberGenerator>
3196 __generate(_ForwardIterator __f, _ForwardIterator __t,
3197 _UniformRandomNumberGenerator& __urng,
3198 const param_type& __p)
3199 { this->__generate_impl(__f, __t, __urng, __p); }
3201 template<
typename _UniformRandomNumberGenerator>
3204 _UniformRandomNumberGenerator& __urng)
3205 { this->__generate_impl(__f, __t, __urng); }
3207 template<
typename _UniformRandomNumberGenerator>
3210 _UniformRandomNumberGenerator& __urng,
3211 const param_type& __p)
3212 { this->__generate_impl(__f, __t, __urng, __p); }
3222 {
return (
__d1._M_param ==
__d2._M_param
3224 &&
__d1._M_gd_y ==
__d2._M_gd_y); }
3236 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3251 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3278 template<
typename _RealType>
3293 template<
typename _RealType =
double>
3297 "result_type must be a floating point type");
3335 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3339 student_t_distribution(
const param_type& __p)
3340 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3358 {
return _M_param.n(); }
3365 {
return _M_param; }
3392 template<
typename _UniformRandomNumberGenerator>
3397 template<
typename _UniformRandomNumberGenerator>
3400 const param_type& __p)
3409 template<
typename _ForwardIterator,
3410 typename _UniformRandomNumberGenerator>
3412 __generate(_ForwardIterator __f, _ForwardIterator __t,
3413 _UniformRandomNumberGenerator& __urng)
3414 { this->__generate_impl(__f, __t, __urng); }
3416 template<
typename _ForwardIterator,
3417 typename _UniformRandomNumberGenerator>
3419 __generate(_ForwardIterator __f, _ForwardIterator __t,
3420 _UniformRandomNumberGenerator& __urng,
3421 const param_type& __p)
3422 { this->__generate_impl(__f, __t, __urng, __p); }
3424 template<
typename _UniformRandomNumberGenerator>
3427 _UniformRandomNumberGenerator& __urng)
3428 { this->__generate_impl(__f, __t, __urng); }
3430 template<
typename _UniformRandomNumberGenerator>
3433 _UniformRandomNumberGenerator& __urng,
3434 const param_type& __p)
3435 { this->__generate_impl(__f, __t, __urng, __p); }
3445 {
return (
__d1._M_param ==
__d2._M_param
3458 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3473 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3500 template<
typename _RealType>
3538 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3592 {
return _M_param.p(); }
3599 {
return _M_param; }
3626 template<
typename _UniformRandomNumberGenerator>
3629 {
return this->
operator()(__urng, _M_param); }
3631 template<
typename _UniformRandomNumberGenerator>
3634 const param_type& __p)
3636 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3644 template<
typename _ForwardIterator,
3645 typename _UniformRandomNumberGenerator>
3647 __generate(_ForwardIterator __f, _ForwardIterator __t,
3648 _UniformRandomNumberGenerator& __urng)
3649 { this->__generate(__f, __t, __urng, _M_param); }
3651 template<
typename _ForwardIterator,
3652 typename _UniformRandomNumberGenerator>
3654 __generate(_ForwardIterator __f, _ForwardIterator __t,
3655 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3656 { this->__generate_impl(__f, __t, __urng, __p); }
3658 template<
typename _UniformRandomNumberGenerator>
3661 _UniformRandomNumberGenerator& __urng,
3662 const param_type& __p)
3663 { this->__generate_impl(__f, __t, __urng, __p); }
3672 {
return __d1._M_param ==
__d2._M_param; }
3680 const param_type& __p);
3682 param_type _M_param;
3704 template<
typename _CharT,
typename _Traits>
3718 template<
typename _CharT,
typename _Traits>
3737 template<
typename _IntType =
int>
3741 "result_type must be an integral type");
3757 : _M_t(__t), _M_p(__p)
3759 __glibcxx_assert((_M_t >= _IntType(0))
3789#if _GLIBCXX_USE_C99_MATH_TR1
3802 : _M_param(__t, __p), _M_nd()
3806 binomial_distribution(
const param_type& __p)
3807 : _M_param(__p), _M_nd()
3822 {
return _M_param.t(); }
3829 {
return _M_param.p(); }
3836 {
return _M_param; }
3858 {
return _M_param.t(); }
3863 template<
typename _UniformRandomNumberGenerator>
3866 {
return this->
operator()(__urng, _M_param); }
3868 template<
typename _UniformRandomNumberGenerator>
3871 const param_type& __p);
3878 { this->__generate(__f, __t,
__urng, _M_param); }
3880 template<
typename _ForwardIterator,
3881 typename _UniformRandomNumberGenerator>
3883 __generate(_ForwardIterator __f, _ForwardIterator __t,
3884 _UniformRandomNumberGenerator& __urng,
3885 const param_type& __p)
3886 { this->__generate_impl(__f, __t, __urng, __p); }
3888 template<
typename _UniformRandomNumberGenerator>
3891 _UniformRandomNumberGenerator& __urng,
3892 const param_type& __p)
3893 { this->__generate_impl(__f, __t, __urng, __p); }
3903#ifdef _GLIBCXX_USE_C99_MATH_TR1
3906 {
return __d1._M_param ==
__d2._M_param; }
3919 template<
typename _IntType1,
3920 typename _CharT,
typename _Traits>
3936 typename _CharT,
typename _Traits>
3949 template<
typename _UniformRandomNumberGenerator>
3952 _IntType __t,
double __q);
3963 template<
typename _IntType>
3977 template<
typename _IntType =
int>
3981 "result_type must be an integral type");
3999 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4018 { _M_log_1_p =
std::log(1.0 - _M_p); }
4035 geometric_distribution(
const param_type& __p)
4052 {
return _M_param.p(); }
4059 {
return _M_param; }
4086 template<
typename _UniformRandomNumberGenerator>
4089 {
return this->
operator()(__urng, _M_param); }
4091 template<
typename _UniformRandomNumberGenerator>
4094 const param_type& __p);
4101 { this->__generate(__f, __t,
__urng, _M_param); }
4103 template<
typename _ForwardIterator,
4104 typename _UniformRandomNumberGenerator>
4106 __generate(_ForwardIterator __f, _ForwardIterator __t,
4107 _UniformRandomNumberGenerator& __urng,
4108 const param_type& __p)
4109 { this->__generate_impl(__f, __t, __urng, __p); }
4111 template<
typename _UniformRandomNumberGenerator>
4114 _UniformRandomNumberGenerator& __urng,
4115 const param_type& __p)
4116 { this->__generate_impl(__f, __t, __urng, __p); }
4125 {
return __d1._M_param ==
__d2._M_param; }
4133 const param_type& __p);
4135 param_type _M_param;
4142 template<
typename _IntType>
4158 template<
typename _IntType,
4159 typename _CharT,
typename _Traits>
4173 template<
typename _IntType,
4174 typename _CharT,
typename _Traits>
4187 template<
typename _IntType =
int>
4191 "result_type must be an integral type");
4206 : _M_k(
__k), _M_p(__p)
4208 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4236 : _M_param(
__k, __p), _M_gd(
__k, (1.0 - __p) / __p)
4240 negative_binomial_distribution(
const param_type& __p)
4241 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4256 {
return _M_param.k(); }
4263 {
return _M_param.p(); }
4270 {
return _M_param; }
4297 template<
typename _UniformRandomNumberGenerator>
4301 template<
typename _UniformRandomNumberGenerator>
4304 const param_type& __p);
4311 { this->__generate_impl(__f, __t,
__urng); }
4313 template<
typename _ForwardIterator,
4314 typename _UniformRandomNumberGenerator>
4316 __generate(_ForwardIterator __f, _ForwardIterator __t,
4317 _UniformRandomNumberGenerator& __urng,
4318 const param_type& __p)
4319 { this->__generate_impl(__f, __t, __urng, __p); }
4321 template<
typename _UniformRandomNumberGenerator>
4324 _UniformRandomNumberGenerator& __urng)
4325 { this->__generate_impl(__f, __t, __urng); }
4327 template<
typename _UniformRandomNumberGenerator>
4330 _UniformRandomNumberGenerator& __urng,
4331 const param_type& __p)
4332 { this->__generate_impl(__f, __t, __urng, __p); }
4355 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4370 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4396 template<
typename _IntType>
4418 template<
typename _IntType =
int>
4422 "result_type must be an integral type");
4440 __glibcxx_assert(_M_mean > 0.0);
4450 {
return __p1._M_mean ==
__p2._M_mean; }
4464#if _GLIBCXX_USE_C99_MATH_TR1
4475 : _M_param(
__mean), _M_nd()
4479 poisson_distribution(
const param_type& __p)
4480 : _M_param(__p), _M_nd()
4495 {
return _M_param.mean(); }
4502 {
return _M_param; }
4529 template<
typename _UniformRandomNumberGenerator>
4532 {
return this->
operator()(__urng, _M_param); }
4534 template<
typename _UniformRandomNumberGenerator>
4537 const param_type& __p);
4544 { this->__generate(__f, __t,
__urng, _M_param); }
4546 template<
typename _ForwardIterator,
4547 typename _UniformRandomNumberGenerator>
4549 __generate(_ForwardIterator __f, _ForwardIterator __t,
4550 _UniformRandomNumberGenerator& __urng,
4551 const param_type& __p)
4552 { this->__generate_impl(__f, __t, __urng, __p); }
4554 template<
typename _UniformRandomNumberGenerator>
4557 _UniformRandomNumberGenerator& __urng,
4558 const param_type& __p)
4559 { this->__generate_impl(__f, __t, __urng, __p); }
4569#ifdef _GLIBCXX_USE_C99_MATH_TR1
4572 {
return __d1._M_param ==
__d2._M_param; }
4585 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4600 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4622 template<
typename _IntType>
4644 template<
typename _RealType =
double>
4648 "result_type must be a floating point type");
4665 __glibcxx_assert(_M_lambda > _RealType(0));
4670 {
return _M_lambda; }
4674 {
return __p1._M_lambda ==
__p2._M_lambda; }
4681 _RealType _M_lambda;
4718 {
return _M_param.lambda(); }
4725 {
return _M_param; }
4752 template<
typename _UniformRandomNumberGenerator>
4755 {
return this->
operator()(__urng, _M_param); }
4757 template<
typename _UniformRandomNumberGenerator>
4760 const param_type& __p)
4762 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4767 template<
typename _ForwardIterator,
4768 typename _UniformRandomNumberGenerator>
4770 __generate(_ForwardIterator __f, _ForwardIterator __t,
4771 _UniformRandomNumberGenerator& __urng)
4772 { this->__generate(__f, __t, __urng, _M_param); }
4774 template<
typename _ForwardIterator,
4775 typename _UniformRandomNumberGenerator>
4777 __generate(_ForwardIterator __f, _ForwardIterator __t,
4778 _UniformRandomNumberGenerator& __urng,
4779 const param_type& __p)
4780 { this->__generate_impl(__f, __t, __urng, __p); }
4782 template<
typename _UniformRandomNumberGenerator>
4785 _UniformRandomNumberGenerator& __urng,
4786 const param_type& __p)
4787 { this->__generate_impl(__f, __t, __urng, __p); }
4796 {
return __d1._M_param ==
__d2._M_param; }
4804 const param_type& __p);
4806 param_type _M_param;
4813 template<
typename _RealType>
4829 template<
typename _RealType,
typename _CharT,
typename _Traits>
4844 template<
typename _RealType,
typename _CharT,
typename _Traits>
4859 template<
typename _RealType =
double>
4863 "result_type must be a floating point type");
4877 param_type(_RealType __a, _RealType __b = _RealType(1.0))
4878 : _M_a(__a), _M_b(__b)
4906 : _M_param(__a, __b)
4910 weibull_distribution(
const param_type& __p)
4926 {
return _M_param.a(); }
4933 {
return _M_param.b(); }
4940 {
return _M_param; }
4967 template<
typename _UniformRandomNumberGenerator>
4970 {
return this->
operator()(__urng, _M_param); }
4972 template<
typename _UniformRandomNumberGenerator>
4975 const param_type& __p);
4982 { this->__generate(__f, __t,
__urng, _M_param); }
4984 template<
typename _ForwardIterator,
4985 typename _UniformRandomNumberGenerator>
4987 __generate(_ForwardIterator __f, _ForwardIterator __t,
4988 _UniformRandomNumberGenerator& __urng,
4989 const param_type& __p)
4990 { this->__generate_impl(__f, __t, __urng, __p); }
4992 template<
typename _UniformRandomNumberGenerator>
4995 _UniformRandomNumberGenerator& __urng,
4996 const param_type& __p)
4997 { this->__generate_impl(__f, __t, __urng, __p); }
5006 {
return __d1._M_param ==
__d2._M_param; }
5014 const param_type& __p);
5016 param_type _M_param;
5023 template<
typename _RealType>
5039 template<
typename _RealType,
typename _CharT,
typename _Traits>
5054 template<
typename _RealType,
typename _CharT,
typename _Traits>
5069 template<
typename _RealType =
double>
5073 "result_type must be a floating point type");
5087 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5088 : _M_a(__a), _M_b(__b)
5116 : _M_param(__a, __b)
5120 extreme_value_distribution(
const param_type& __p)
5136 {
return _M_param.a(); }
5143 {
return _M_param.b(); }
5150 {
return _M_param; }
5177 template<
typename _UniformRandomNumberGenerator>
5180 {
return this->
operator()(__urng, _M_param); }
5182 template<
typename _UniformRandomNumberGenerator>
5185 const param_type& __p);
5192 { this->__generate(__f, __t,
__urng, _M_param); }
5194 template<
typename _ForwardIterator,
5195 typename _UniformRandomNumberGenerator>
5197 __generate(_ForwardIterator __f, _ForwardIterator __t,
5198 _UniformRandomNumberGenerator& __urng,
5199 const param_type& __p)
5200 { this->__generate_impl(__f, __t, __urng, __p); }
5202 template<
typename _UniformRandomNumberGenerator>
5205 _UniformRandomNumberGenerator& __urng,
5206 const param_type& __p)
5207 { this->__generate_impl(__f, __t, __urng, __p); }
5216 {
return __d1._M_param ==
__d2._M_param; }
5224 const param_type& __p);
5226 param_type _M_param;
5233 template<
typename _RealType>
5249 template<
typename _RealType,
typename _CharT,
typename _Traits>
5264 template<
typename _RealType,
typename _CharT,
typename _Traits>
5276 template<
typename _IntType =
int>
5280 "result_type must be an integral type");
5293 : _M_prob(), _M_cp()
5296 template<
typename _InputIterator>
5300 { _M_initialize(); }
5303 : _M_prob(
__wil.begin(),
__wil.end()), _M_cp()
5304 { _M_initialize(); }
5306 template<
typename _Func>
5315 probabilities()
const
5320 {
return __p1._M_prob ==
__p2._M_prob; }
5338 template<
typename _InputIterator>
5344 discrete_distribution(initializer_list<double> __wl)
5348 template<
typename _Func>
5349 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5351 : _M_param(__nw, __xmin, __xmax, __fw)
5355 discrete_distribution(
const param_type& __p)
5372 return _M_param._M_prob.
empty()
5381 {
return _M_param; }
5404 return _M_param._M_prob.
empty()
5411 template<
typename _UniformRandomNumberGenerator>
5414 {
return this->
operator()(__urng, _M_param); }
5416 template<
typename _UniformRandomNumberGenerator>
5419 const param_type& __p);
5426 { this->__generate(__f, __t,
__urng, _M_param); }
5428 template<
typename _ForwardIterator,
5429 typename _UniformRandomNumberGenerator>
5431 __generate(_ForwardIterator __f, _ForwardIterator __t,
5432 _UniformRandomNumberGenerator& __urng,
5433 const param_type& __p)
5434 { this->__generate_impl(__f, __t, __urng, __p); }
5436 template<
typename _UniformRandomNumberGenerator>
5439 _UniformRandomNumberGenerator& __urng,
5440 const param_type& __p)
5441 { this->__generate_impl(__f, __t, __urng, __p); }
5450 {
return __d1._M_param ==
__d2._M_param; }
5462 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5478 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5498 template<
typename _IntType>
5511 template<
typename _RealType =
double>
5515 "result_type must be a floating point type");
5528 : _M_int(), _M_den(), _M_cp()
5531 template<
typename _InputIteratorB,
typename _InputIteratorW>
5536 template<
typename _Func>
5539 template<
typename _Func>
5553 __tmp[1] = _RealType(1);
5585 template<
typename _InputIteratorB,
typename _InputIteratorW>
5592 template<
typename _Func>
5593 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5595 : _M_param(__bl, __fw)
5598 template<
typename _Func>
5599 piecewise_constant_distribution(
size_t __nw,
5600 _RealType __xmin, _RealType __xmax,
5602 : _M_param(__nw, __xmin, __xmax, __fw)
5606 piecewise_constant_distribution(
const param_type& __p)
5623 if (_M_param._M_int.
empty())
5626 __tmp[1] = _RealType(1);
5630 return _M_param._M_int;
5639 return _M_param._M_den.
empty()
5648 {
return _M_param; }
5664 return _M_param._M_int.
empty()
5674 return _M_param._M_int.
empty()
5681 template<
typename _UniformRandomNumberGenerator>
5684 {
return this->
operator()(__urng, _M_param); }
5686 template<
typename _UniformRandomNumberGenerator>
5689 const param_type& __p);
5696 { this->__generate(__f, __t,
__urng, _M_param); }
5698 template<
typename _ForwardIterator,
5699 typename _UniformRandomNumberGenerator>
5701 __generate(_ForwardIterator __f, _ForwardIterator __t,
5702 _UniformRandomNumberGenerator& __urng,
5703 const param_type& __p)
5704 { this->__generate_impl(__f, __t, __urng, __p); }
5706 template<
typename _UniformRandomNumberGenerator>
5709 _UniformRandomNumberGenerator& __urng,
5710 const param_type& __p)
5711 { this->__generate_impl(__f, __t, __urng, __p); }
5720 {
return __d1._M_param ==
__d2._M_param; }
5733 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5749 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5769 template<
typename _RealType>
5782 template<
typename _RealType =
double>
5786 "result_type must be a floating point type");
5799 : _M_int(), _M_den(), _M_cp(), _M_m()
5802 template<
typename _InputIteratorB,
typename _InputIteratorW>
5807 template<
typename _Func>
5810 template<
typename _Func>
5824 __tmp[1] = _RealType(1);
5857 template<
typename _InputIteratorB,
typename _InputIteratorW>
5864 template<
typename _Func>
5865 piecewise_linear_distribution(initializer_list<_RealType> __bl,
5867 : _M_param(__bl, __fw)
5870 template<
typename _Func>
5871 piecewise_linear_distribution(
size_t __nw,
5872 _RealType __xmin, _RealType __xmax,
5874 : _M_param(__nw, __xmin, __xmax, __fw)
5878 piecewise_linear_distribution(
const param_type& __p)
5895 if (_M_param._M_int.
empty())
5898 __tmp[1] = _RealType(1);
5902 return _M_param._M_int;
5912 return _M_param._M_den.
empty()
5921 {
return _M_param; }
5937 return _M_param._M_int.
empty()
5947 return _M_param._M_int.
empty()
5954 template<
typename _UniformRandomNumberGenerator>
5957 {
return this->
operator()(__urng, _M_param); }
5959 template<
typename _UniformRandomNumberGenerator>
5962 const param_type& __p);
5969 { this->__generate(__f, __t,
__urng, _M_param); }
5971 template<
typename _ForwardIterator,
5972 typename _UniformRandomNumberGenerator>
5974 __generate(_ForwardIterator __f, _ForwardIterator __t,
5975 _UniformRandomNumberGenerator& __urng,
5976 const param_type& __p)
5977 { this->__generate_impl(__f, __t, __urng, __p); }
5979 template<
typename _UniformRandomNumberGenerator>
5982 _UniformRandomNumberGenerator& __urng,
5983 const param_type& __p)
5984 { this->__generate_impl(__f, __t, __urng, __p); }
5993 {
return __d1._M_param ==
__d2._M_param; }
6006 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6022 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6042 template<
typename _RealType>
6074 template<
typename _IntType,
typename = _Require<is_
integral<_IntType>>>
6077 template<
typename _InputIterator>
6081 template<
typename _RandomAccessIterator>
6087 {
return _M_v.
size(); }
6089 template<
typename _OutputIterator>
6091 param(_OutputIterator __dest)
const
6092 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
6106_GLIBCXX_END_NAMESPACE_VERSION
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
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 int __lg(int __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.
Properties of fundamental types.
static constexpr _Tp max() noexcept
static constexpr _Tp lowest() noexcept
static constexpr _Tp min() noexcept
Define a member typedef type only if a boolean constant is true.
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.
_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.
static constexpr result_type increment
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.
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...
void seed(result_type __sd=default_seed)
Seeds the initial state of the random number generator.
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 combining random numbers from some base engine to produce random numbers w...
_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.
bool empty() const noexcept
reference front() noexcept
iterator begin() noexcept
reference back() noexcept
size_type size() const noexcept