37namespace std _GLIBCXX_VISIBILITY(default)
39_GLIBCXX_BEGIN_NAMESPACE_VERSION
58 template<
typename _RealType,
size_t __bits,
59 typename _UniformRandomNumberGenerator>
67 template<
typename _UIntType,
size_t __w,
68 bool = __w < static_cast<size_t>
71 {
static const _UIntType __value = 0; };
73 template<
typename _UIntType,
size_t __w>
74 struct _Shift<_UIntType, __w, true>
75 {
static const _UIntType __value = _UIntType(1) << __w; };
78 int __which = ((__s <= __CHAR_BIT__ *
sizeof (int))
79 + (__s <= __CHAR_BIT__ *
sizeof (long))
80 + (__s <= __CHAR_BIT__ *
sizeof (
long long))
83 struct _Select_uint_least_t
85 static_assert(__which < 0,
86 "sorry, would be too much trouble for a slow result");
90 struct _Select_uint_least_t<__s, 4>
91 {
typedef unsigned int type; };
94 struct _Select_uint_least_t<__s, 3>
95 {
typedef unsigned long type; };
98 struct _Select_uint_least_t<__s, 2>
99 {
typedef unsigned long long type; };
101#ifdef _GLIBCXX_USE_INT128
103 struct _Select_uint_least_t<__s, 1>
104 {
typedef unsigned __int128 type; };
108 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
109 bool __big_enough = (!(__m & (__m - 1))
110 || (_Tp(-1) - __c) / __a >= __m - 1),
111 bool __schrage_ok = __m % __a < __m / __a>
114 typedef typename _Select_uint_least_t<
std::__lg(__a)
118 {
return static_cast<_Tp
>((_Tp2(__a) * __x + __c) % __m); }
122 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c>
123 struct _Mod<_Tp, __m, __a, __c, false, true>
132 template<
typename _Tp, _Tp __m, _Tp __a, _Tp __c,
bool __s>
133 struct _Mod<_Tp, __m, __a, __c, true, __s>
138 _Tp __res = __a * __x + __c;
145 template<
typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
149 if _GLIBCXX17_CONSTEXPR (__a == 0)
154 constexpr _Tp __a1 = __a ? __a : 1;
155 return _Mod<_Tp, __m, __a1, __c>::__calc(__x);
163 template<
typename _Engine,
typename _DInputType>
167 "template argument must be a floating point type");
170 _Adaptor(_Engine& __g)
175 {
return _DInputType(0); }
179 {
return _DInputType(1); }
198 template<
typename _Sseq>
199 using __seed_seq_generate_t =
decltype(
205 template<
typename _Sseq,
typename _Engine,
typename _Res,
206 typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
207 using __is_seed_seq = __and_<
208 __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
209 is_unsigned<typename _Sseq::result_type>,
210 __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)
1325 template<
typename _RandomNumberEngine,
size_t __k>
1328 static_assert(1u <=
__k,
"template argument substituting "
1329 "__k out of bound");
1335 template<
typename _Sseq>
1336 using _If_seed_seq =
typename enable_if<__detail::__is_seed_seq<
1339 static constexpr size_t table_size =
__k;
1348 { _M_initialize(); }
1359 { _M_initialize(); }
1370 { _M_initialize(); }
1381 { _M_initialize(); }
1388 template<
typename _Sseq,
typename = _If_seed_seq<_Sseq>>
1392 { _M_initialize(); }
1421 template<
typename _Sseq>
1432 const _RandomNumberEngine&
1441 {
return _RandomNumberEngine::min(); }
1448 {
return _RandomNumberEngine::max(); }
1496 typename _CharT,
typename _Traits>
1514 typename _CharT,
typename _Traits>
1520 void _M_initialize()
1522 for (
size_t __i = 0; __i <
__k; ++__i)
1527 _RandomNumberEngine _M_b;
1543 template<
typename _RandomNumberEngine,
size_t __k>
1555 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1586 0xb5026f5aa96619e9ULL, 29,
1587 0x5555555555555555ULL, 17,
1588 0x71d67fffeda60000ULL, 37,
1589 0xfff7eee000000000ULL, 43,
1623#if defined _GLIBCXX_USE_DEV_RANDOM
1637 entropy() const noexcept
1639#ifdef _GLIBCXX_USE_DEV_RANDOM
1640 return this->_M_getentropy();
1648 {
return this->_M_getval(); }
1651 random_device(
const random_device&) =
delete;
1652 void operator=(
const random_device&) =
delete;
1662 double _M_getentropy() const noexcept;
1664 void _M_init(const
char*,
size_t);
1698 template<
typename _IntType>
1714 template<
typename _IntType,
typename _CharT,
typename _Traits>
1728 template<
typename _IntType,
typename _CharT,
typename _Traits>
1741 template<
typename _RealType =
double>
1745 "result_type must be a floating point type");
1759 param_type(_RealType __a, _RealType __b = _RealType(1))
1760 : _M_a(__a), _M_b(__b)
1762 __glibcxx_assert(_M_a <= _M_b);
1802 : _M_param(__a, __b)
1820 {
return _M_param.a(); }
1824 {
return _M_param.b(); }
1831 {
return _M_param; }
1846 {
return this->a(); }
1853 {
return this->b(); }
1858 template<
typename _UniformRandomNumberGenerator>
1861 {
return this->
operator()(__urng, _M_param); }
1863 template<
typename _UniformRandomNumberGenerator>
1866 const param_type& __p)
1868 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1870 return (
__aurng() * (__p.b() - __p.a())) + __p.a();
1873 template<
typename _ForwardIterator,
1874 typename _UniformRandomNumberGenerator>
1876 __generate(_ForwardIterator __f, _ForwardIterator __t,
1877 _UniformRandomNumberGenerator& __urng)
1878 { this->__generate(__f, __t, __urng, _M_param); }
1880 template<
typename _ForwardIterator,
1881 typename _UniformRandomNumberGenerator>
1883 __generate(_ForwardIterator __f, _ForwardIterator __t,
1884 _UniformRandomNumberGenerator& __urng,
1885 const param_type& __p)
1886 { this->__generate_impl(__f, __t, __urng, __p); }
1888 template<
typename _UniformRandomNumberGenerator>
1891 _UniformRandomNumberGenerator& __urng,
1892 const param_type& __p)
1893 { this->__generate_impl(__f, __t, __urng, __p); }
1902 {
return __d1._M_param ==
__d2._M_param; }
1910 const param_type& __p);
1912 param_type _M_param;
1919 template<
typename _IntType>
1935 template<
typename _RealType,
typename _CharT,
typename _Traits>
1949 template<
typename _RealType,
typename _CharT,
typename _Traits>
1971 template<
typename _RealType =
double>
1975 "result_type must be a floating point type");
1992 __glibcxx_assert(_M_stddev > _RealType(0));
2001 {
return _M_stddev; }
2005 {
return (
__p1._M_mean ==
__p2._M_mean
2006 &&
__p1._M_stddev ==
__p2._M_stddev); }
2014 _RealType _M_stddev;
2040 { _M_saved_available =
false; }
2047 {
return _M_param.mean(); }
2054 {
return _M_param.stddev(); }
2061 {
return _M_param; }
2088 template<
typename _UniformRandomNumberGenerator>
2091 {
return this->
operator()(__urng, _M_param); }
2093 template<
typename _UniformRandomNumberGenerator>
2096 const param_type& __p);
2103 { this->__generate(__f, __t,
__urng, _M_param); }
2105 template<
typename _ForwardIterator,
2106 typename _UniformRandomNumberGenerator>
2108 __generate(_ForwardIterator __f, _ForwardIterator __t,
2109 _UniformRandomNumberGenerator& __urng,
2110 const param_type& __p)
2111 { this->__generate_impl(__f, __t, __urng, __p); }
2113 template<
typename _UniformRandomNumberGenerator>
2116 _UniformRandomNumberGenerator& __urng,
2117 const param_type& __p)
2118 { this->__generate_impl(__f, __t, __urng, __p); }
2125 template<
typename _RealType1>
2140 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2155 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2170 bool _M_saved_available =
false;
2176 template<
typename _RealType>
2192 template<
typename _RealType =
double>
2196 "result_type must be a floating point type");
2239 : _M_param(
__m,
__s), _M_nd()
2243 lognormal_distribution(
const param_type& __p)
2244 : _M_param(__p), _M_nd()
2259 {
return _M_param.m(); }
2263 {
return _M_param.s(); }
2270 {
return _M_param; }
2297 template<
typename _UniformRandomNumberGenerator>
2300 {
return this->
operator()(__urng, _M_param); }
2302 template<
typename _UniformRandomNumberGenerator>
2305 const param_type& __p)
2308 template<
typename _ForwardIterator,
2309 typename _UniformRandomNumberGenerator>
2311 __generate(_ForwardIterator __f, _ForwardIterator __t,
2312 _UniformRandomNumberGenerator& __urng)
2313 { this->__generate(__f, __t, __urng, _M_param); }
2315 template<
typename _ForwardIterator,
2316 typename _UniformRandomNumberGenerator>
2318 __generate(_ForwardIterator __f, _ForwardIterator __t,
2319 _UniformRandomNumberGenerator& __urng,
2320 const param_type& __p)
2321 { this->__generate_impl(__f, __t, __urng, __p); }
2323 template<
typename _UniformRandomNumberGenerator>
2326 _UniformRandomNumberGenerator& __urng,
2327 const param_type& __p)
2328 { this->__generate_impl(__f, __t, __urng, __p); }
2338 {
return (
__d1._M_param ==
__d2._M_param
2351 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2366 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2387 template<
typename _RealType>
2403 template<
typename _RealType =
double>
2407 "result_type must be a floating point type");
2425 __glibcxx_assert(_M_alpha > _RealType(0));
2431 {
return _M_alpha; }
2439 {
return (
__p1._M_alpha ==
__p2._M_alpha
2440 &&
__p1._M_beta ==
__p2._M_beta); }
2453 _RealType _M_malpha, _M_a2;
2474 : _M_param(__p), _M_nd()
2489 {
return _M_param.alpha(); }
2496 {
return _M_param.beta(); }
2503 {
return _M_param; }
2530 template<
typename _UniformRandomNumberGenerator>
2533 {
return this->
operator()(__urng, _M_param); }
2535 template<
typename _UniformRandomNumberGenerator>
2538 const param_type& __p);
2545 { this->__generate(__f, __t,
__urng, _M_param); }
2547 template<
typename _ForwardIterator,
2548 typename _UniformRandomNumberGenerator>
2550 __generate(_ForwardIterator __f, _ForwardIterator __t,
2551 _UniformRandomNumberGenerator& __urng,
2552 const param_type& __p)
2553 { this->__generate_impl(__f, __t, __urng, __p); }
2555 template<
typename _UniformRandomNumberGenerator>
2558 _UniformRandomNumberGenerator& __urng,
2559 const param_type& __p)
2560 { this->__generate_impl(__f, __t, __urng, __p); }
2570 {
return (
__d1._M_param ==
__d2._M_param
2583 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2597 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2618 template<
typename _RealType>
2631 template<
typename _RealType =
double>
2635 "result_type must be a floating point type");
2673 : _M_param(__n), _M_gd(__n / 2)
2677 chi_squared_distribution(
const param_type& __p)
2678 : _M_param(__p), _M_gd(__p.n() / 2)
2693 {
return _M_param.n(); }
2700 {
return _M_param; }
2732 template<
typename _UniformRandomNumberGenerator>
2735 {
return 2 * _M_gd(
__urng); }
2737 template<
typename _UniformRandomNumberGenerator>
2740 const param_type& __p)
2744 return 2 * _M_gd(
__urng, param_type(__p.n() / 2));
2747 template<
typename _ForwardIterator,
2748 typename _UniformRandomNumberGenerator>
2750 __generate(_ForwardIterator __f, _ForwardIterator __t,
2751 _UniformRandomNumberGenerator& __urng)
2752 { this->__generate_impl(__f, __t, __urng); }
2754 template<
typename _ForwardIterator,
2755 typename _UniformRandomNumberGenerator>
2757 __generate(_ForwardIterator __f, _ForwardIterator __t,
2758 _UniformRandomNumberGenerator& __urng,
2759 const param_type& __p)
2762 this->__generate_impl(__f, __t, __urng, __p2); }
2764 template<
typename _UniformRandomNumberGenerator>
2767 _UniformRandomNumberGenerator& __urng)
2768 { this->__generate_impl(__f, __t, __urng); }
2770 template<
typename _UniformRandomNumberGenerator>
2773 _UniformRandomNumberGenerator& __urng,
2774 const param_type& __p)
2777 this->__generate_impl(__f, __t, __urng, __p2); }
2799 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2814 template<
typename _RealType1,
typename _CharT,
typename _Traits>
2842 template<
typename _RealType>
2855 template<
typename _RealType =
double>
2859 "result_type must be a floating point type");
2873 param_type(_RealType __a, _RealType __b = _RealType(1))
2874 : _M_a(__a), _M_b(__b)
2902 : _M_param(__a, __b)
2906 cauchy_distribution(
const param_type& __p)
2922 {
return _M_param.a(); }
2926 {
return _M_param.b(); }
2933 {
return _M_param; }
2960 template<
typename _UniformRandomNumberGenerator>
2963 {
return this->
operator()(__urng, _M_param); }
2965 template<
typename _UniformRandomNumberGenerator>
2968 const param_type& __p);
2975 { this->__generate(__f, __t,
__urng, _M_param); }
2977 template<
typename _ForwardIterator,
2978 typename _UniformRandomNumberGenerator>
2980 __generate(_ForwardIterator __f, _ForwardIterator __t,
2981 _UniformRandomNumberGenerator& __urng,
2982 const param_type& __p)
2983 { this->__generate_impl(__f, __t, __urng, __p); }
2985 template<
typename _UniformRandomNumberGenerator>
2988 _UniformRandomNumberGenerator& __urng,
2989 const param_type& __p)
2990 { this->__generate_impl(__f, __t, __urng, __p); }
2999 {
return __d1._M_param ==
__d2._M_param; }
3007 const param_type& __p);
3009 param_type _M_param;
3016 template<
typename _RealType>
3032 template<
typename _RealType,
typename _CharT,
typename _Traits>
3047 template<
typename _RealType,
typename _CharT,
typename _Traits>
3063 template<
typename _RealType =
double>
3067 "result_type must be a floating point type");
3082 : _M_m(
__m), _M_n(__n)
3110 _RealType __n = _RealType(1))
3111 : _M_param(
__m, __n), _M_gd_x(
__m / 2), _M_gd_y(__n / 2)
3115 fisher_f_distribution(
const param_type& __p)
3116 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3134 {
return _M_param.m(); }
3138 {
return _M_param.n(); }
3145 {
return _M_param; }
3172 template<
typename _UniformRandomNumberGenerator>
3175 {
return (_M_gd_x(
__urng) * n()) / (_M_gd_y(
__urng) * m()); }
3177 template<
typename _UniformRandomNumberGenerator>
3180 const param_type& __p)
3184 return ((_M_gd_x(
__urng, param_type(__p.m() / 2)) * n())
3185 / (_M_gd_y(
__urng, param_type(__p.n() / 2)) * m()));
3188 template<
typename _ForwardIterator,
3189 typename _UniformRandomNumberGenerator>
3191 __generate(_ForwardIterator __f, _ForwardIterator __t,
3192 _UniformRandomNumberGenerator& __urng)
3193 { this->__generate_impl(__f, __t, __urng); }
3195 template<
typename _ForwardIterator,
3196 typename _UniformRandomNumberGenerator>
3198 __generate(_ForwardIterator __f, _ForwardIterator __t,
3199 _UniformRandomNumberGenerator& __urng,
3200 const param_type& __p)
3201 { this->__generate_impl(__f, __t, __urng, __p); }
3203 template<
typename _UniformRandomNumberGenerator>
3206 _UniformRandomNumberGenerator& __urng)
3207 { this->__generate_impl(__f, __t, __urng); }
3209 template<
typename _UniformRandomNumberGenerator>
3212 _UniformRandomNumberGenerator& __urng,
3213 const param_type& __p)
3214 { this->__generate_impl(__f, __t, __urng, __p); }
3224 {
return (
__d1._M_param ==
__d2._M_param
3226 &&
__d1._M_gd_y ==
__d2._M_gd_y); }
3238 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3253 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3280 template<
typename _RealType>
3295 template<
typename _RealType =
double>
3299 "result_type must be a floating point type");
3337 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3341 student_t_distribution(
const param_type& __p)
3342 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3360 {
return _M_param.n(); }
3367 {
return _M_param; }
3394 template<
typename _UniformRandomNumberGenerator>
3399 template<
typename _UniformRandomNumberGenerator>
3402 const param_type& __p)
3411 template<
typename _ForwardIterator,
3412 typename _UniformRandomNumberGenerator>
3414 __generate(_ForwardIterator __f, _ForwardIterator __t,
3415 _UniformRandomNumberGenerator& __urng)
3416 { this->__generate_impl(__f, __t, __urng); }
3418 template<
typename _ForwardIterator,
3419 typename _UniformRandomNumberGenerator>
3421 __generate(_ForwardIterator __f, _ForwardIterator __t,
3422 _UniformRandomNumberGenerator& __urng,
3423 const param_type& __p)
3424 { this->__generate_impl(__f, __t, __urng, __p); }
3426 template<
typename _UniformRandomNumberGenerator>
3429 _UniformRandomNumberGenerator& __urng)
3430 { this->__generate_impl(__f, __t, __urng); }
3432 template<
typename _UniformRandomNumberGenerator>
3435 _UniformRandomNumberGenerator& __urng,
3436 const param_type& __p)
3437 { this->__generate_impl(__f, __t, __urng, __p); }
3447 {
return (
__d1._M_param ==
__d2._M_param
3460 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3475 template<
typename _RealType1,
typename _CharT,
typename _Traits>
3502 template<
typename _RealType>
3540 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3594 {
return _M_param.p(); }
3601 {
return _M_param; }
3628 template<
typename _UniformRandomNumberGenerator>
3631 {
return this->
operator()(__urng, _M_param); }
3633 template<
typename _UniformRandomNumberGenerator>
3636 const param_type& __p)
3638 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3646 template<
typename _ForwardIterator,
3647 typename _UniformRandomNumberGenerator>
3649 __generate(_ForwardIterator __f, _ForwardIterator __t,
3650 _UniformRandomNumberGenerator& __urng)
3651 { this->__generate(__f, __t, __urng, _M_param); }
3653 template<
typename _ForwardIterator,
3654 typename _UniformRandomNumberGenerator>
3656 __generate(_ForwardIterator __f, _ForwardIterator __t,
3657 _UniformRandomNumberGenerator& __urng,
const param_type& __p)
3658 { this->__generate_impl(__f, __t, __urng, __p); }
3660 template<
typename _UniformRandomNumberGenerator>
3663 _UniformRandomNumberGenerator& __urng,
3664 const param_type& __p)
3665 { this->__generate_impl(__f, __t, __urng, __p); }
3674 {
return __d1._M_param ==
__d2._M_param; }
3682 const param_type& __p);
3684 param_type _M_param;
3706 template<
typename _CharT,
typename _Traits>
3720 template<
typename _CharT,
typename _Traits>
3739 template<
typename _IntType =
int>
3743 "result_type must be an integral type");
3759 : _M_t(__t), _M_p(__p)
3761 __glibcxx_assert((_M_t >= _IntType(0))
3791#if _GLIBCXX_USE_C99_MATH_TR1
3804 : _M_param(__t, __p), _M_nd()
3808 binomial_distribution(
const param_type& __p)
3809 : _M_param(__p), _M_nd()
3824 {
return _M_param.t(); }
3831 {
return _M_param.p(); }
3838 {
return _M_param; }
3860 {
return _M_param.t(); }
3865 template<
typename _UniformRandomNumberGenerator>
3868 {
return this->
operator()(__urng, _M_param); }
3870 template<
typename _UniformRandomNumberGenerator>
3873 const param_type& __p);
3880 { this->__generate(__f, __t,
__urng, _M_param); }
3882 template<
typename _ForwardIterator,
3883 typename _UniformRandomNumberGenerator>
3885 __generate(_ForwardIterator __f, _ForwardIterator __t,
3886 _UniformRandomNumberGenerator& __urng,
3887 const param_type& __p)
3888 { this->__generate_impl(__f, __t, __urng, __p); }
3890 template<
typename _UniformRandomNumberGenerator>
3893 _UniformRandomNumberGenerator& __urng,
3894 const param_type& __p)
3895 { this->__generate_impl(__f, __t, __urng, __p); }
3905#ifdef _GLIBCXX_USE_C99_MATH_TR1
3908 {
return __d1._M_param ==
__d2._M_param; }
3921 template<
typename _IntType1,
3922 typename _CharT,
typename _Traits>
3938 typename _CharT,
typename _Traits>
3951 template<
typename _UniformRandomNumberGenerator>
3954 _IntType __t,
double __q);
3965 template<
typename _IntType>
3979 template<
typename _IntType =
int>
3983 "result_type must be an integral type");
4001 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4020 { _M_log_1_p =
std::log(1.0 - _M_p); }
4037 geometric_distribution(
const param_type& __p)
4054 {
return _M_param.p(); }
4061 {
return _M_param; }
4088 template<
typename _UniformRandomNumberGenerator>
4091 {
return this->
operator()(__urng, _M_param); }
4093 template<
typename _UniformRandomNumberGenerator>
4096 const param_type& __p);
4103 { this->__generate(__f, __t,
__urng, _M_param); }
4105 template<
typename _ForwardIterator,
4106 typename _UniformRandomNumberGenerator>
4108 __generate(_ForwardIterator __f, _ForwardIterator __t,
4109 _UniformRandomNumberGenerator& __urng,
4110 const param_type& __p)
4111 { this->__generate_impl(__f, __t, __urng, __p); }
4113 template<
typename _UniformRandomNumberGenerator>
4116 _UniformRandomNumberGenerator& __urng,
4117 const param_type& __p)
4118 { this->__generate_impl(__f, __t, __urng, __p); }
4127 {
return __d1._M_param ==
__d2._M_param; }
4135 const param_type& __p);
4137 param_type _M_param;
4144 template<
typename _IntType>
4160 template<
typename _IntType,
4161 typename _CharT,
typename _Traits>
4175 template<
typename _IntType,
4176 typename _CharT,
typename _Traits>
4189 template<
typename _IntType =
int>
4193 "result_type must be an integral type");
4208 : _M_k(
__k), _M_p(__p)
4210 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4238 : _M_param(
__k, __p), _M_gd(
__k, (1.0 - __p) / __p)
4242 negative_binomial_distribution(
const param_type& __p)
4243 : _M_param(__p), _M_gd(__p.
k(), (1.0 - __p.
p()) / __p.
p())
4258 {
return _M_param.k(); }
4265 {
return _M_param.p(); }
4272 {
return _M_param; }
4299 template<
typename _UniformRandomNumberGenerator>
4303 template<
typename _UniformRandomNumberGenerator>
4306 const param_type& __p);
4313 { this->__generate_impl(__f, __t,
__urng); }
4315 template<
typename _ForwardIterator,
4316 typename _UniformRandomNumberGenerator>
4318 __generate(_ForwardIterator __f, _ForwardIterator __t,
4319 _UniformRandomNumberGenerator& __urng,
4320 const param_type& __p)
4321 { this->__generate_impl(__f, __t, __urng, __p); }
4323 template<
typename _UniformRandomNumberGenerator>
4326 _UniformRandomNumberGenerator& __urng)
4327 { this->__generate_impl(__f, __t, __urng); }
4329 template<
typename _UniformRandomNumberGenerator>
4332 _UniformRandomNumberGenerator& __urng,
4333 const param_type& __p)
4334 { this->__generate_impl(__f, __t, __urng, __p); }
4357 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4372 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4398 template<
typename _IntType>
4420 template<
typename _IntType =
int>
4424 "result_type must be an integral type");
4442 __glibcxx_assert(_M_mean > 0.0);
4452 {
return __p1._M_mean ==
__p2._M_mean; }
4466#if _GLIBCXX_USE_C99_MATH_TR1
4477 : _M_param(
__mean), _M_nd()
4481 poisson_distribution(
const param_type& __p)
4482 : _M_param(__p), _M_nd()
4497 {
return _M_param.mean(); }
4504 {
return _M_param; }
4531 template<
typename _UniformRandomNumberGenerator>
4534 {
return this->
operator()(__urng, _M_param); }
4536 template<
typename _UniformRandomNumberGenerator>
4539 const param_type& __p);
4546 { this->__generate(__f, __t,
__urng, _M_param); }
4548 template<
typename _ForwardIterator,
4549 typename _UniformRandomNumberGenerator>
4551 __generate(_ForwardIterator __f, _ForwardIterator __t,
4552 _UniformRandomNumberGenerator& __urng,
4553 const param_type& __p)
4554 { this->__generate_impl(__f, __t, __urng, __p); }
4556 template<
typename _UniformRandomNumberGenerator>
4559 _UniformRandomNumberGenerator& __urng,
4560 const param_type& __p)
4561 { this->__generate_impl(__f, __t, __urng, __p); }
4571#ifdef _GLIBCXX_USE_C99_MATH_TR1
4574 {
return __d1._M_param ==
__d2._M_param; }
4587 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4602 template<
typename _IntType1,
typename _CharT,
typename _Traits>
4624 template<
typename _IntType>
4646 template<
typename _RealType =
double>
4650 "result_type must be a floating point type");
4667 __glibcxx_assert(_M_lambda > _RealType(0));
4672 {
return _M_lambda; }
4676 {
return __p1._M_lambda ==
__p2._M_lambda; }
4683 _RealType _M_lambda;
4720 {
return _M_param.lambda(); }
4727 {
return _M_param; }
4754 template<
typename _UniformRandomNumberGenerator>
4757 {
return this->
operator()(__urng, _M_param); }
4759 template<
typename _UniformRandomNumberGenerator>
4762 const param_type& __p)
4764 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4769 template<
typename _ForwardIterator,
4770 typename _UniformRandomNumberGenerator>
4772 __generate(_ForwardIterator __f, _ForwardIterator __t,
4773 _UniformRandomNumberGenerator& __urng)
4774 { this->__generate(__f, __t, __urng, _M_param); }
4776 template<
typename _ForwardIterator,
4777 typename _UniformRandomNumberGenerator>
4779 __generate(_ForwardIterator __f, _ForwardIterator __t,
4780 _UniformRandomNumberGenerator& __urng,
4781 const param_type& __p)
4782 { this->__generate_impl(__f, __t, __urng, __p); }
4784 template<
typename _UniformRandomNumberGenerator>
4787 _UniformRandomNumberGenerator& __urng,
4788 const param_type& __p)
4789 { this->__generate_impl(__f, __t, __urng, __p); }
4798 {
return __d1._M_param ==
__d2._M_param; }
4806 const param_type& __p);
4808 param_type _M_param;
4815 template<
typename _RealType>
4831 template<
typename _RealType,
typename _CharT,
typename _Traits>
4846 template<
typename _RealType,
typename _CharT,
typename _Traits>
4861 template<
typename _RealType =
double>
4865 "result_type must be a floating point type");
4879 param_type(_RealType __a, _RealType __b = _RealType(1.0))
4880 : _M_a(__a), _M_b(__b)
4908 : _M_param(__a, __b)
4912 weibull_distribution(
const param_type& __p)
4928 {
return _M_param.a(); }
4935 {
return _M_param.b(); }
4942 {
return _M_param; }
4969 template<
typename _UniformRandomNumberGenerator>
4972 {
return this->
operator()(__urng, _M_param); }
4974 template<
typename _UniformRandomNumberGenerator>
4977 const param_type& __p);
4984 { this->__generate(__f, __t,
__urng, _M_param); }
4986 template<
typename _ForwardIterator,
4987 typename _UniformRandomNumberGenerator>
4989 __generate(_ForwardIterator __f, _ForwardIterator __t,
4990 _UniformRandomNumberGenerator& __urng,
4991 const param_type& __p)
4992 { this->__generate_impl(__f, __t, __urng, __p); }
4994 template<
typename _UniformRandomNumberGenerator>
4997 _UniformRandomNumberGenerator& __urng,
4998 const param_type& __p)
4999 { this->__generate_impl(__f, __t, __urng, __p); }
5008 {
return __d1._M_param ==
__d2._M_param; }
5016 const param_type& __p);
5018 param_type _M_param;
5025 template<
typename _RealType>
5041 template<
typename _RealType,
typename _CharT,
typename _Traits>
5056 template<
typename _RealType,
typename _CharT,
typename _Traits>
5071 template<
typename _RealType =
double>
5075 "result_type must be a floating point type");
5089 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5090 : _M_a(__a), _M_b(__b)
5118 : _M_param(__a, __b)
5122 extreme_value_distribution(
const param_type& __p)
5138 {
return _M_param.a(); }
5145 {
return _M_param.b(); }
5152 {
return _M_param; }
5179 template<
typename _UniformRandomNumberGenerator>
5182 {
return this->
operator()(__urng, _M_param); }
5184 template<
typename _UniformRandomNumberGenerator>
5187 const param_type& __p);
5194 { this->__generate(__f, __t,
__urng, _M_param); }
5196 template<
typename _ForwardIterator,
5197 typename _UniformRandomNumberGenerator>
5199 __generate(_ForwardIterator __f, _ForwardIterator __t,
5200 _UniformRandomNumberGenerator& __urng,
5201 const param_type& __p)
5202 { this->__generate_impl(__f, __t, __urng, __p); }
5204 template<
typename _UniformRandomNumberGenerator>
5207 _UniformRandomNumberGenerator& __urng,
5208 const param_type& __p)
5209 { this->__generate_impl(__f, __t, __urng, __p); }
5218 {
return __d1._M_param ==
__d2._M_param; }
5226 const param_type& __p);
5228 param_type _M_param;
5235 template<
typename _RealType>
5251 template<
typename _RealType,
typename _CharT,
typename _Traits>
5266 template<
typename _RealType,
typename _CharT,
typename _Traits>
5278 template<
typename _IntType =
int>
5282 "result_type must be an integral type");
5295 : _M_prob(), _M_cp()
5298 template<
typename _InputIterator>
5302 { _M_initialize(); }
5305 : _M_prob(
__wil.begin(),
__wil.end()), _M_cp()
5306 { _M_initialize(); }
5308 template<
typename _Func>
5317 probabilities()
const
5322 {
return __p1._M_prob ==
__p2._M_prob; }
5340 template<
typename _InputIterator>
5346 discrete_distribution(initializer_list<double> __wl)
5350 template<
typename _Func>
5351 discrete_distribution(
size_t __nw,
double __xmin,
double __xmax,
5353 : _M_param(__nw, __xmin, __xmax, __fw)
5357 discrete_distribution(
const param_type& __p)
5374 return _M_param._M_prob.
empty()
5383 {
return _M_param; }
5406 return _M_param._M_prob.
empty()
5413 template<
typename _UniformRandomNumberGenerator>
5416 {
return this->
operator()(__urng, _M_param); }
5418 template<
typename _UniformRandomNumberGenerator>
5421 const param_type& __p);
5428 { this->__generate(__f, __t,
__urng, _M_param); }
5430 template<
typename _ForwardIterator,
5431 typename _UniformRandomNumberGenerator>
5433 __generate(_ForwardIterator __f, _ForwardIterator __t,
5434 _UniformRandomNumberGenerator& __urng,
5435 const param_type& __p)
5436 { this->__generate_impl(__f, __t, __urng, __p); }
5438 template<
typename _UniformRandomNumberGenerator>
5441 _UniformRandomNumberGenerator& __urng,
5442 const param_type& __p)
5443 { this->__generate_impl(__f, __t, __urng, __p); }
5452 {
return __d1._M_param ==
__d2._M_param; }
5464 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5480 template<
typename _IntType1,
typename _CharT,
typename _Traits>
5500 template<
typename _IntType>
5513 template<
typename _RealType =
double>
5517 "result_type must be a floating point type");
5530 : _M_int(), _M_den(), _M_cp()
5533 template<
typename _InputIteratorB,
typename _InputIteratorW>
5538 template<
typename _Func>
5541 template<
typename _Func>
5555 __tmp[1] = _RealType(1);
5587 template<
typename _InputIteratorB,
typename _InputIteratorW>
5594 template<
typename _Func>
5595 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5597 : _M_param(__bl, __fw)
5600 template<
typename _Func>
5601 piecewise_constant_distribution(
size_t __nw,
5602 _RealType __xmin, _RealType __xmax,
5604 : _M_param(__nw, __xmin, __xmax, __fw)
5608 piecewise_constant_distribution(
const param_type& __p)
5625 if (_M_param._M_int.
empty())
5628 __tmp[1] = _RealType(1);
5632 return _M_param._M_int;
5641 return _M_param._M_den.
empty()
5650 {
return _M_param; }
5666 return _M_param._M_int.
empty()
5676 return _M_param._M_int.
empty()
5683 template<
typename _UniformRandomNumberGenerator>
5686 {
return this->
operator()(__urng, _M_param); }
5688 template<
typename _UniformRandomNumberGenerator>
5691 const param_type& __p);
5698 { this->__generate(__f, __t,
__urng, _M_param); }
5700 template<
typename _ForwardIterator,
5701 typename _UniformRandomNumberGenerator>
5703 __generate(_ForwardIterator __f, _ForwardIterator __t,
5704 _UniformRandomNumberGenerator& __urng,
5705 const param_type& __p)
5706 { this->__generate_impl(__f, __t, __urng, __p); }
5708 template<
typename _UniformRandomNumberGenerator>
5711 _UniformRandomNumberGenerator& __urng,
5712 const param_type& __p)
5713 { this->__generate_impl(__f, __t, __urng, __p); }
5722 {
return __d1._M_param ==
__d2._M_param; }
5735 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5751 template<
typename _RealType1,
typename _CharT,
typename _Traits>
5771 template<
typename _RealType>
5784 template<
typename _RealType =
double>
5788 "result_type must be a floating point type");
5801 : _M_int(), _M_den(), _M_cp(), _M_m()
5804 template<
typename _InputIteratorB,
typename _InputIteratorW>
5809 template<
typename _Func>
5812 template<
typename _Func>
5826 __tmp[1] = _RealType(1);
5859 template<
typename _InputIteratorB,
typename _InputIteratorW>
5866 template<
typename _Func>
5867 piecewise_linear_distribution(initializer_list<_RealType> __bl,
5869 : _M_param(__bl, __fw)
5872 template<
typename _Func>
5873 piecewise_linear_distribution(
size_t __nw,
5874 _RealType __xmin, _RealType __xmax,
5876 : _M_param(__nw, __xmin, __xmax, __fw)
5880 piecewise_linear_distribution(
const param_type& __p)
5897 if (_M_param._M_int.
empty())
5900 __tmp[1] = _RealType(1);
5904 return _M_param._M_int;
5914 return _M_param._M_den.
empty()
5923 {
return _M_param; }
5939 return _M_param._M_int.
empty()
5949 return _M_param._M_int.
empty()
5956 template<
typename _UniformRandomNumberGenerator>
5959 {
return this->
operator()(__urng, _M_param); }
5961 template<
typename _UniformRandomNumberGenerator>
5964 const param_type& __p);
5971 { this->__generate(__f, __t,
__urng, _M_param); }
5973 template<
typename _ForwardIterator,
5974 typename _UniformRandomNumberGenerator>
5976 __generate(_ForwardIterator __f, _ForwardIterator __t,
5977 _UniformRandomNumberGenerator& __urng,
5978 const param_type& __p)
5979 { this->__generate_impl(__f, __t, __urng, __p); }
5981 template<
typename _UniformRandomNumberGenerator>
5984 _UniformRandomNumberGenerator& __urng,
5985 const param_type& __p)
5986 { this->__generate_impl(__f, __t, __urng, __p); }
5995 {
return __d1._M_param ==
__d2._M_param; }
6008 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6024 template<
typename _RealType1,
typename _CharT,
typename _Traits>
6044 template<
typename _RealType>
6076 template<
typename _IntType,
typename = _Require<is_
integral<_IntType>>>
6079 template<
typename _InputIterator>
6083 template<
typename _RandomAccessIterator>
6089 {
return _M_v.
size(); }
6091 template<
typename _OutputIterator>
6093 param(_OutputIterator __dest)
const
6094 { std::copy(_M_v.
begin(), _M_v.
end(), __dest); }
6108_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 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.
bool empty() const noexcept
reference front() noexcept
iterator begin() noexcept
reference back() noexcept
size_type size() const noexcept