c++/coroutines: correct passing *this to promise type [PR104981]
[official-gcc.git] / libstdc++-v3 / include / bits / random.h
blob5fda21af882c9c9993168b40842bd87ebaf7ea17
1 // random number generation -*- C++ -*-
3 // Copyright (C) 2009-2024 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
25 /**
26 * @file bits/random.h
27 * This is an internal header file, included by other library headers.
28 * Do not attempt to use it directly. @headername{random}
31 #ifndef _RANDOM_H
32 #define _RANDOM_H 1
34 #include <vector>
35 #include <bits/uniform_int_dist.h>
37 namespace std _GLIBCXX_VISIBILITY(default)
39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
41 // [26.4] Random number generation
43 /**
44 * @defgroup random Random Number Generation
45 * @ingroup numerics
47 * A facility for generating random numbers on selected distributions.
48 * @{
51 // std::uniform_random_bit_generator is defined in <bits/uniform_int_dist.h>
53 /**
54 * @brief A function template for converting the output of a (integral)
55 * uniform random number generator to a floatng point result in the range
56 * [0-1).
58 template<typename _RealType, size_t __bits,
59 typename _UniformRandomNumberGenerator>
60 _RealType
61 generate_canonical(_UniformRandomNumberGenerator& __g);
63 /// @cond undocumented
64 // Implementation-space details.
65 namespace __detail
67 #pragma GCC diagnostic push
68 #pragma GCC diagnostic ignored "-Wc++17-extensions"
70 template<typename _UIntType, size_t __w,
71 bool = __w < static_cast<size_t>
72 (std::numeric_limits<_UIntType>::digits)>
73 struct _Shift
74 { static constexpr _UIntType __value = 0; };
76 template<typename _UIntType, size_t __w>
77 struct _Shift<_UIntType, __w, true>
78 { static constexpr _UIntType __value = _UIntType(1) << __w; };
80 template<int __s,
81 int __which = ((__s <= __CHAR_BIT__ * sizeof (int))
82 + (__s <= __CHAR_BIT__ * sizeof (long))
83 + (__s <= __CHAR_BIT__ * sizeof (long long))
84 /* assume long long no bigger than __int128 */
85 + (__s <= 128))>
86 struct _Select_uint_least_t
88 static_assert(__which < 0, /* needs to be dependent */
89 "sorry, would be too much trouble for a slow result");
92 template<int __s>
93 struct _Select_uint_least_t<__s, 4>
94 { using type = unsigned int; };
96 template<int __s>
97 struct _Select_uint_least_t<__s, 3>
98 { using type = unsigned long; };
100 template<int __s>
101 struct _Select_uint_least_t<__s, 2>
102 { using type = unsigned long long; };
104 #if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
105 template<int __s>
106 struct _Select_uint_least_t<__s, 1>
107 { __extension__ using type = unsigned __int128; };
108 #elif __has_builtin(__builtin_add_overflow) \
109 && __has_builtin(__builtin_sub_overflow) \
110 && defined __UINT64_TYPE__
111 template<int __s>
112 struct _Select_uint_least_t<__s, 1>
114 // This is NOT a general-purpose 128-bit integer type.
115 // It only supports (type(a) * x + c) % m as needed by __mod.
116 struct type
118 explicit
119 type(uint64_t __a) noexcept : _M_lo(__a), _M_hi(0) { }
121 // pre: __l._M_hi == 0
122 friend type
123 operator*(type __l, uint64_t __x) noexcept
125 // Split 64-bit values __l._M_lo and __x into high and low 32-bit
126 // limbs and multiply those individually.
127 // l * x = (l0 + l1) * (x0 + x1) = l0x0 + l0x1 + l1x0 + l1x1
129 constexpr uint64_t __mask = 0xffffffff;
130 uint64_t __ll[2] = { __l._M_lo >> 32, __l._M_lo & __mask };
131 uint64_t __xx[2] = { __x >> 32, __x & __mask };
132 uint64_t __l0x0 = __ll[0] * __xx[0];
133 uint64_t __l0x1 = __ll[0] * __xx[1];
134 uint64_t __l1x0 = __ll[1] * __xx[0];
135 uint64_t __l1x1 = __ll[1] * __xx[1];
136 // These bits are the low half of __l._M_hi
137 // and the high half of __l._M_lo.
138 uint64_t __mid
139 = (__l0x1 & __mask) + (__l1x0 & __mask) + (__l1x1 >> 32);
140 __l._M_hi = __l0x0 + (__l0x1 >> 32) + (__l1x0 >> 32) + (__mid >> 32);
141 __l._M_lo = (__mid << 32) + (__l1x1 & __mask);
142 return __l;
145 friend type
146 operator+(type __l, uint64_t __c) noexcept
148 __l._M_hi += __builtin_add_overflow(__l._M_lo, __c, &__l._M_lo);
149 return __l;
152 friend type
153 operator%(type __l, uint64_t __m) noexcept
155 if (__builtin_expect(__l._M_hi == 0, 0))
157 __l._M_lo %= __m;
158 return __l;
161 int __shift = __builtin_clzll(__m) + 64
162 - __builtin_clzll(__l._M_hi);
163 type __x(0);
164 if (__shift >= 64)
166 __x._M_hi = __m << (__shift - 64);
167 __x._M_lo = 0;
169 else
171 __x._M_hi = __m >> (64 - __shift);
172 __x._M_lo = __m << __shift;
175 while (__l._M_hi != 0 || __l._M_lo >= __m)
177 if (__x <= __l)
179 __l._M_hi -= __x._M_hi;
180 __l._M_hi -= __builtin_sub_overflow(__l._M_lo, __x._M_lo,
181 &__l._M_lo);
183 __x._M_lo = (__x._M_lo >> 1) | (__x._M_hi << 63);
184 __x._M_hi >>= 1;
186 return __l;
189 // pre: __l._M_hi == 0
190 explicit operator uint64_t() const noexcept
191 { return _M_lo; }
193 friend bool operator<(const type& __l, const type& __r) noexcept
195 if (__l._M_hi < __r._M_hi)
196 return true;
197 else if (__l._M_hi == __r._M_hi)
198 return __l._M_lo < __r._M_lo;
199 else
200 return false;
203 friend bool operator<=(const type& __l, const type& __r) noexcept
204 { return !(__r < __l); }
206 uint64_t _M_lo;
207 uint64_t _M_hi;
210 #endif
212 // Assume a != 0, a < m, c < m, x < m.
213 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
214 bool __big_enough = (!(__m & (__m - 1))
215 || (_Tp(-1) - __c) / __a >= __m - 1),
216 bool __schrage_ok = __m % __a < __m / __a>
217 struct _Mod
219 static _Tp
220 __calc(_Tp __x)
222 using _Tp2
223 = typename _Select_uint_least_t<std::__lg(__a)
224 + std::__lg(__m) + 2>::type;
225 return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m);
229 // Schrage.
230 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
231 struct _Mod<_Tp, __m, __a, __c, false, true>
233 static _Tp
234 __calc(_Tp __x);
237 // Special cases:
238 // - for m == 2^n or m == 0, unsigned integer overflow is safe.
239 // - a * (m - 1) + c fits in _Tp, there is no overflow.
240 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
241 struct _Mod<_Tp, __m, __a, __c, true, __s>
243 static _Tp
244 __calc(_Tp __x)
246 _Tp __res = __a * __x + __c;
247 if (__m)
248 __res %= __m;
249 return __res;
253 template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
254 inline _Tp
255 __mod(_Tp __x)
257 if constexpr (__a == 0)
258 return __c;
259 else // N.B. _Mod must not be instantiated with a == 0
260 return _Mod<_Tp, __m, __a, __c>::__calc(__x);
264 * An adaptor class for converting the output of any Generator into
265 * the input for a specific Distribution.
267 template<typename _Engine, typename _DInputType>
268 struct _Adaptor
270 static_assert(std::is_floating_point<_DInputType>::value,
271 "template argument must be a floating point type");
273 public:
274 _Adaptor(_Engine& __g)
275 : _M_g(__g) { }
277 _DInputType
278 min() const
279 { return _DInputType(0); }
281 _DInputType
282 max() const
283 { return _DInputType(1); }
286 * Converts a value generated by the adapted random number generator
287 * into a value in the input domain for the dependent random number
288 * distribution.
290 _DInputType
291 operator()()
293 return std::generate_canonical<_DInputType,
294 std::numeric_limits<_DInputType>::digits,
295 _Engine>(_M_g);
298 private:
299 _Engine& _M_g;
302 // Detect whether a template argument _Sseq is a valid seed sequence for
303 // a random number engine _Engine with result type _Res.
304 // Used to constrain _Engine::_Engine(_Sseq&) and _Engine::seed(_Sseq&)
305 // as required by [rand.eng.general].
307 template<typename _Sseq>
308 using __seed_seq_generate_t = decltype(
309 std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
310 std::declval<uint_least32_t*>()));
312 template<typename _Sseq, typename _Engine, typename _Res,
313 typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
314 using _If_seed_seq_for = _Require<
315 __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
316 is_unsigned<typename _Sseq::result_type>,
317 __not_<is_convertible<_Sseq, _Res>>
320 #pragma GCC diagnostic pop
321 } // namespace __detail
322 /// @endcond
325 * @addtogroup random_generators Random Number Generators
326 * @ingroup random
328 * These classes define objects which provide random or pseudorandom
329 * numbers, either from a discrete or a continuous interval. The
330 * random number generator supplied as a part of this library are
331 * all uniform random number generators which provide a sequence of
332 * random number uniformly distributed over their range.
334 * A number generator is a function object with an operator() that
335 * takes zero arguments and returns a number.
337 * A compliant random number generator must satisfy the following
338 * requirements. <table border=1 cellpadding=10 cellspacing=0>
339 * <caption align=top>Random Number Generator Requirements</caption>
340 * <tr><td>To be documented.</td></tr> </table>
342 * @{
346 * @brief A model of a linear congruential random number generator.
348 * A random number generator that produces pseudorandom numbers via
349 * linear function:
350 * @f[
351 * x_{i+1}\leftarrow(ax_{i} + c) \bmod m
352 * @f]
354 * The template parameter @p _UIntType must be an unsigned integral type
355 * large enough to store values up to (__m-1). If the template parameter
356 * @p __m is 0, the modulus @p __m used is
357 * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
358 * parameters @p __a and @p __c must be less than @p __m.
360 * The size of the state is @f$1@f$.
362 * @headerfile random
363 * @since C++11
365 template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
366 class linear_congruential_engine
368 static_assert(std::is_unsigned<_UIntType>::value,
369 "result_type must be an unsigned integral type");
370 static_assert(__m == 0u || (__a < __m && __c < __m),
371 "template argument substituting __m out of bounds");
373 template<typename _Sseq>
374 using _If_seed_seq
375 = __detail::_If_seed_seq_for<_Sseq, linear_congruential_engine,
376 _UIntType>;
378 public:
379 /** The type of the generated random value. */
380 typedef _UIntType result_type;
382 /** The multiplier. */
383 static constexpr result_type multiplier = __a;
384 /** An increment. */
385 static constexpr result_type increment = __c;
386 /** The modulus. */
387 static constexpr result_type modulus = __m;
388 static constexpr result_type default_seed = 1u;
391 * @brief Constructs a %linear_congruential_engine random number
392 * generator engine with seed 1.
394 linear_congruential_engine() : linear_congruential_engine(default_seed)
398 * @brief Constructs a %linear_congruential_engine random number
399 * generator engine with seed @p __s. The default seed value
400 * is 1.
402 * @param __s The initial seed value.
404 explicit
405 linear_congruential_engine(result_type __s)
406 { seed(__s); }
409 * @brief Constructs a %linear_congruential_engine random number
410 * generator engine seeded from the seed sequence @p __q.
412 * @param __q the seed sequence.
414 template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
415 explicit
416 linear_congruential_engine(_Sseq& __q)
417 { seed(__q); }
420 * @brief Reseeds the %linear_congruential_engine random number generator
421 * engine sequence to the seed @p __s.
423 * @param __s The new seed.
425 void
426 seed(result_type __s = default_seed);
429 * @brief Reseeds the %linear_congruential_engine random number generator
430 * engine
431 * sequence using values from the seed sequence @p __q.
433 * @param __q the seed sequence.
435 template<typename _Sseq>
436 _If_seed_seq<_Sseq>
437 seed(_Sseq& __q);
440 * @brief Gets the smallest possible value in the output range.
442 * The minimum depends on the @p __c parameter: if it is zero, the
443 * minimum generated must be > 0, otherwise 0 is allowed.
445 static constexpr result_type
446 min()
447 { return __c == 0u ? 1u : 0u; }
450 * @brief Gets the largest possible value in the output range.
452 static constexpr result_type
453 max()
454 { return __m - 1u; }
457 * @brief Discard a sequence of random numbers.
459 void
460 discard(unsigned long long __z)
462 for (; __z != 0ULL; --__z)
463 (*this)();
467 * @brief Gets the next random number in the sequence.
469 result_type
470 operator()()
472 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
473 return _M_x;
477 * @brief Compares two linear congruential random number generator
478 * objects of the same type for equality.
480 * @param __lhs A linear congruential random number generator object.
481 * @param __rhs Another linear congruential random number generator
482 * object.
484 * @returns true if the infinite sequences of generated values
485 * would be equal, false otherwise.
487 friend bool
488 operator==(const linear_congruential_engine& __lhs,
489 const linear_congruential_engine& __rhs)
490 { return __lhs._M_x == __rhs._M_x; }
493 * @brief Writes the textual representation of the state x(i) of x to
494 * @p __os.
496 * @param __os The output stream.
497 * @param __lcr A % linear_congruential_engine random number generator.
498 * @returns __os.
500 template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
501 _UIntType1 __m1, typename _CharT, typename _Traits>
502 friend std::basic_ostream<_CharT, _Traits>&
503 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
504 const std::linear_congruential_engine<_UIntType1,
505 __a1, __c1, __m1>& __lcr);
508 * @brief Sets the state of the engine by reading its textual
509 * representation from @p __is.
511 * The textual representation must have been previously written using
512 * an output stream whose imbued locale and whose type's template
513 * specialization arguments _CharT and _Traits were the same as those
514 * of @p __is.
516 * @param __is The input stream.
517 * @param __lcr A % linear_congruential_engine random number generator.
518 * @returns __is.
520 template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
521 _UIntType1 __m1, typename _CharT, typename _Traits>
522 friend std::basic_istream<_CharT, _Traits>&
523 operator>>(std::basic_istream<_CharT, _Traits>& __is,
524 std::linear_congruential_engine<_UIntType1, __a1,
525 __c1, __m1>& __lcr);
527 private:
528 _UIntType _M_x;
531 #if __cpp_impl_three_way_comparison < 201907L
533 * @brief Compares two linear congruential random number generator
534 * objects of the same type for inequality.
536 * @param __lhs A linear congruential random number generator object.
537 * @param __rhs Another linear congruential random number generator
538 * object.
540 * @returns true if the infinite sequences of generated values
541 * would be different, false otherwise.
543 template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
544 inline bool
545 operator!=(const std::linear_congruential_engine<_UIntType, __a,
546 __c, __m>& __lhs,
547 const std::linear_congruential_engine<_UIntType, __a,
548 __c, __m>& __rhs)
549 { return !(__lhs == __rhs); }
550 #endif
553 * A generalized feedback shift register discrete random number generator.
555 * This algorithm avoids multiplication and division and is designed to be
556 * friendly to a pipelined architecture. If the parameters are chosen
557 * correctly, this generator will produce numbers with a very long period and
558 * fairly good apparent entropy, although still not cryptographically strong.
560 * The best way to use this generator is with the predefined mt19937 class.
562 * This algorithm was originally invented by Makoto Matsumoto and
563 * Takuji Nishimura.
565 * @tparam __w Word size, the number of bits in each element of
566 * the state vector.
567 * @tparam __n The degree of recursion.
568 * @tparam __m The period parameter.
569 * @tparam __r The separation point bit index.
570 * @tparam __a The last row of the twist matrix.
571 * @tparam __u The first right-shift tempering matrix parameter.
572 * @tparam __d The first right-shift tempering matrix mask.
573 * @tparam __s The first left-shift tempering matrix parameter.
574 * @tparam __b The first left-shift tempering matrix mask.
575 * @tparam __t The second left-shift tempering matrix parameter.
576 * @tparam __c The second left-shift tempering matrix mask.
577 * @tparam __l The second right-shift tempering matrix parameter.
578 * @tparam __f Initialization multiplier.
580 * @headerfile random
581 * @since C++11
583 template<typename _UIntType, size_t __w,
584 size_t __n, size_t __m, size_t __r,
585 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
586 _UIntType __b, size_t __t,
587 _UIntType __c, size_t __l, _UIntType __f>
588 class mersenne_twister_engine
590 static_assert(std::is_unsigned<_UIntType>::value,
591 "result_type must be an unsigned integral type");
592 static_assert(1u <= __m && __m <= __n,
593 "template argument substituting __m out of bounds");
594 static_assert(__r <= __w, "template argument substituting "
595 "__r out of bound");
596 static_assert(__u <= __w, "template argument substituting "
597 "__u out of bound");
598 static_assert(__s <= __w, "template argument substituting "
599 "__s out of bound");
600 static_assert(__t <= __w, "template argument substituting "
601 "__t out of bound");
602 static_assert(__l <= __w, "template argument substituting "
603 "__l out of bound");
604 static_assert(__w <= std::numeric_limits<_UIntType>::digits,
605 "template argument substituting __w out of bound");
606 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
607 "template argument substituting __a out of bound");
608 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
609 "template argument substituting __b out of bound");
610 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
611 "template argument substituting __c out of bound");
612 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
613 "template argument substituting __d out of bound");
614 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
615 "template argument substituting __f out of bound");
617 template<typename _Sseq>
618 using _If_seed_seq
619 = __detail::_If_seed_seq_for<_Sseq, mersenne_twister_engine,
620 _UIntType>;
622 public:
623 /** The type of the generated random value. */
624 typedef _UIntType result_type;
626 // parameter values
627 static constexpr size_t word_size = __w;
628 static constexpr size_t state_size = __n;
629 static constexpr size_t shift_size = __m;
630 static constexpr size_t mask_bits = __r;
631 static constexpr result_type xor_mask = __a;
632 static constexpr size_t tempering_u = __u;
633 static constexpr result_type tempering_d = __d;
634 static constexpr size_t tempering_s = __s;
635 static constexpr result_type tempering_b = __b;
636 static constexpr size_t tempering_t = __t;
637 static constexpr result_type tempering_c = __c;
638 static constexpr size_t tempering_l = __l;
639 static constexpr result_type initialization_multiplier = __f;
640 static constexpr result_type default_seed = 5489u;
642 // constructors and member functions
644 mersenne_twister_engine() : mersenne_twister_engine(default_seed) { }
646 explicit
647 mersenne_twister_engine(result_type __sd)
648 { seed(__sd); }
651 * @brief Constructs a %mersenne_twister_engine random number generator
652 * engine seeded from the seed sequence @p __q.
654 * @param __q the seed sequence.
656 template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
657 explicit
658 mersenne_twister_engine(_Sseq& __q)
659 { seed(__q); }
661 void
662 seed(result_type __sd = default_seed);
664 template<typename _Sseq>
665 _If_seed_seq<_Sseq>
666 seed(_Sseq& __q);
669 * @brief Gets the smallest possible value in the output range.
671 static constexpr result_type
672 min()
673 { return 0; }
676 * @brief Gets the largest possible value in the output range.
678 static constexpr result_type
679 max()
680 { return __detail::_Shift<_UIntType, __w>::__value - 1; }
683 * @brief Discard a sequence of random numbers.
685 void
686 discard(unsigned long long __z);
688 result_type
689 operator()();
692 * @brief Compares two % mersenne_twister_engine random number generator
693 * objects of the same type for equality.
695 * @param __lhs A % mersenne_twister_engine random number generator
696 * object.
697 * @param __rhs Another % mersenne_twister_engine random number
698 * generator object.
700 * @returns true if the infinite sequences of generated values
701 * would be equal, false otherwise.
703 friend bool
704 operator==(const mersenne_twister_engine& __lhs,
705 const mersenne_twister_engine& __rhs)
706 { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
707 && __lhs._M_p == __rhs._M_p); }
710 * @brief Inserts the current state of a % mersenne_twister_engine
711 * random number generator engine @p __x into the output stream
712 * @p __os.
714 * @param __os An output stream.
715 * @param __x A % mersenne_twister_engine random number generator
716 * engine.
718 * @returns The output stream with the state of @p __x inserted or in
719 * an error state.
721 template<typename _UIntType1,
722 size_t __w1, size_t __n1,
723 size_t __m1, size_t __r1,
724 _UIntType1 __a1, size_t __u1,
725 _UIntType1 __d1, size_t __s1,
726 _UIntType1 __b1, size_t __t1,
727 _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
728 typename _CharT, typename _Traits>
729 friend std::basic_ostream<_CharT, _Traits>&
730 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
731 const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
732 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
733 __l1, __f1>& __x);
736 * @brief Extracts the current state of a % mersenne_twister_engine
737 * random number generator engine @p __x from the input stream
738 * @p __is.
740 * @param __is An input stream.
741 * @param __x A % mersenne_twister_engine random number generator
742 * engine.
744 * @returns The input stream with the state of @p __x extracted or in
745 * an error state.
747 template<typename _UIntType1,
748 size_t __w1, size_t __n1,
749 size_t __m1, size_t __r1,
750 _UIntType1 __a1, size_t __u1,
751 _UIntType1 __d1, size_t __s1,
752 _UIntType1 __b1, size_t __t1,
753 _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
754 typename _CharT, typename _Traits>
755 friend std::basic_istream<_CharT, _Traits>&
756 operator>>(std::basic_istream<_CharT, _Traits>& __is,
757 std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
758 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
759 __l1, __f1>& __x);
761 private:
762 void _M_gen_rand();
764 _UIntType _M_x[state_size];
765 size_t _M_p;
768 #if __cpp_impl_three_way_comparison < 201907L
770 * @brief Compares two % mersenne_twister_engine random number generator
771 * objects of the same type for inequality.
773 * @param __lhs A % mersenne_twister_engine random number generator
774 * object.
775 * @param __rhs Another % mersenne_twister_engine random number
776 * generator object.
778 * @returns true if the infinite sequences of generated values
779 * would be different, false otherwise.
781 template<typename _UIntType, size_t __w,
782 size_t __n, size_t __m, size_t __r,
783 _UIntType __a, size_t __u, _UIntType __d, size_t __s,
784 _UIntType __b, size_t __t,
785 _UIntType __c, size_t __l, _UIntType __f>
786 inline bool
787 operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
788 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
789 const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
790 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
791 { return !(__lhs == __rhs); }
792 #endif
795 * @brief The Marsaglia-Zaman generator.
797 * This is a model of a Generalized Fibonacci discrete random number
798 * generator, sometimes referred to as the SWC generator.
800 * A discrete random number generator that produces pseudorandom
801 * numbers using:
802 * @f[
803 * x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m
804 * @f]
806 * The size of the state is @f$r@f$
807 * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
809 * @headerfile random
810 * @since C++11
812 template<typename _UIntType, size_t __w, size_t __s, size_t __r>
813 class subtract_with_carry_engine
815 static_assert(std::is_unsigned<_UIntType>::value,
816 "result_type must be an unsigned integral type");
817 static_assert(0u < __s && __s < __r,
818 "0 < s < r");
819 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
820 "template argument substituting __w out of bounds");
822 template<typename _Sseq>
823 using _If_seed_seq
824 = __detail::_If_seed_seq_for<_Sseq, subtract_with_carry_engine,
825 _UIntType>;
827 public:
828 /** The type of the generated random value. */
829 typedef _UIntType result_type;
831 // parameter values
832 static constexpr size_t word_size = __w;
833 static constexpr size_t short_lag = __s;
834 static constexpr size_t long_lag = __r;
835 static constexpr uint_least32_t default_seed = 19780503u;
837 subtract_with_carry_engine() : subtract_with_carry_engine(0u)
841 * @brief Constructs an explicitly seeded %subtract_with_carry_engine
842 * random number generator.
844 explicit
845 subtract_with_carry_engine(result_type __sd)
846 { seed(__sd); }
849 * @brief Constructs a %subtract_with_carry_engine random number engine
850 * seeded from the seed sequence @p __q.
852 * @param __q the seed sequence.
854 template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
855 explicit
856 subtract_with_carry_engine(_Sseq& __q)
857 { seed(__q); }
860 * @brief Seeds the initial state @f$x_0@f$ of the random number
861 * generator.
863 * N1688[4.19] modifies this as follows. If @p __value == 0,
864 * sets value to 19780503. In any case, with a linear
865 * congruential generator lcg(i) having parameters @f$ m_{lcg} =
866 * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
867 * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
868 * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$
869 * set carry to 1, otherwise sets carry to 0.
871 void
872 seed(result_type __sd = 0u);
875 * @brief Seeds the initial state @f$x_0@f$ of the
876 * % subtract_with_carry_engine random number generator.
878 template<typename _Sseq>
879 _If_seed_seq<_Sseq>
880 seed(_Sseq& __q);
883 * @brief Gets the inclusive minimum value of the range of random
884 * integers returned by this generator.
886 static constexpr result_type
887 min()
888 { return 0; }
891 * @brief Gets the inclusive maximum value of the range of random
892 * integers returned by this generator.
894 static constexpr result_type
895 max()
896 { return __detail::_Shift<_UIntType, __w>::__value - 1; }
899 * @brief Discard a sequence of random numbers.
901 void
902 discard(unsigned long long __z)
904 for (; __z != 0ULL; --__z)
905 (*this)();
909 * @brief Gets the next random number in the sequence.
911 result_type
912 operator()();
915 * @brief Compares two % subtract_with_carry_engine random number
916 * generator objects of the same type for equality.
918 * @param __lhs A % subtract_with_carry_engine random number generator
919 * object.
920 * @param __rhs Another % subtract_with_carry_engine random number
921 * generator object.
923 * @returns true if the infinite sequences of generated values
924 * would be equal, false otherwise.
926 friend bool
927 operator==(const subtract_with_carry_engine& __lhs,
928 const subtract_with_carry_engine& __rhs)
929 { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
930 && __lhs._M_carry == __rhs._M_carry
931 && __lhs._M_p == __rhs._M_p); }
934 * @brief Inserts the current state of a % subtract_with_carry_engine
935 * random number generator engine @p __x into the output stream
936 * @p __os.
938 * @param __os An output stream.
939 * @param __x A % subtract_with_carry_engine random number generator
940 * engine.
942 * @returns The output stream with the state of @p __x inserted or in
943 * an error state.
945 template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
946 typename _CharT, typename _Traits>
947 friend std::basic_ostream<_CharT, _Traits>&
948 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
949 const std::subtract_with_carry_engine<_UIntType1, __w1,
950 __s1, __r1>& __x);
953 * @brief Extracts the current state of a % subtract_with_carry_engine
954 * random number generator engine @p __x from the input stream
955 * @p __is.
957 * @param __is An input stream.
958 * @param __x A % subtract_with_carry_engine random number generator
959 * engine.
961 * @returns The input stream with the state of @p __x extracted or in
962 * an error state.
964 template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
965 typename _CharT, typename _Traits>
966 friend std::basic_istream<_CharT, _Traits>&
967 operator>>(std::basic_istream<_CharT, _Traits>& __is,
968 std::subtract_with_carry_engine<_UIntType1, __w1,
969 __s1, __r1>& __x);
971 private:
972 /// The state of the generator. This is a ring buffer.
973 _UIntType _M_x[long_lag];
974 _UIntType _M_carry; ///< The carry
975 size_t _M_p; ///< Current index of x(i - r).
978 #if __cpp_impl_three_way_comparison < 201907L
980 * @brief Compares two % subtract_with_carry_engine random number
981 * generator objects of the same type for inequality.
983 * @param __lhs A % subtract_with_carry_engine random number generator
984 * object.
985 * @param __rhs Another % subtract_with_carry_engine random number
986 * generator object.
988 * @returns true if the infinite sequences of generated values
989 * would be different, false otherwise.
991 template<typename _UIntType, size_t __w, size_t __s, size_t __r>
992 inline bool
993 operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
994 __s, __r>& __lhs,
995 const std::subtract_with_carry_engine<_UIntType, __w,
996 __s, __r>& __rhs)
997 { return !(__lhs == __rhs); }
998 #endif
1001 * Produces random numbers from some base engine by discarding blocks of
1002 * data.
1004 * @pre @f$ 0 \leq r \leq p @f$
1006 * @headerfile random
1007 * @since C++11
1009 template<typename _RandomNumberEngine, size_t __p, size_t __r>
1010 class discard_block_engine
1012 static_assert(1 <= __r && __r <= __p,
1013 "template argument substituting __r out of bounds");
1015 public:
1016 /** The type of the generated random value. */
1017 typedef typename _RandomNumberEngine::result_type result_type;
1019 template<typename _Sseq>
1020 using _If_seed_seq
1021 = __detail::_If_seed_seq_for<_Sseq, discard_block_engine,
1022 result_type>;
1024 // parameter values
1025 static constexpr size_t block_size = __p;
1026 static constexpr size_t used_block = __r;
1029 * @brief Constructs a default %discard_block_engine engine.
1031 * The underlying engine is default constructed as well.
1033 discard_block_engine()
1034 : _M_b(), _M_n(0) { }
1037 * @brief Copy constructs a %discard_block_engine engine.
1039 * Copies an existing base class random number generator.
1040 * @param __rng An existing (base class) engine object.
1042 explicit
1043 discard_block_engine(const _RandomNumberEngine& __rng)
1044 : _M_b(__rng), _M_n(0) { }
1047 * @brief Move constructs a %discard_block_engine engine.
1049 * Copies an existing base class random number generator.
1050 * @param __rng An existing (base class) engine object.
1052 explicit
1053 discard_block_engine(_RandomNumberEngine&& __rng)
1054 : _M_b(std::move(__rng)), _M_n(0) { }
1057 * @brief Seed constructs a %discard_block_engine engine.
1059 * Constructs the underlying generator engine seeded with @p __s.
1060 * @param __s A seed value for the base class engine.
1062 explicit
1063 discard_block_engine(result_type __s)
1064 : _M_b(__s), _M_n(0) { }
1067 * @brief Generator construct a %discard_block_engine engine.
1069 * @param __q A seed sequence.
1071 template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
1072 explicit
1073 discard_block_engine(_Sseq& __q)
1074 : _M_b(__q), _M_n(0)
1078 * @brief Reseeds the %discard_block_engine object with the default
1079 * seed for the underlying base class generator engine.
1081 void
1082 seed()
1084 _M_b.seed();
1085 _M_n = 0;
1089 * @brief Reseeds the %discard_block_engine object with the default
1090 * seed for the underlying base class generator engine.
1092 void
1093 seed(result_type __s)
1095 _M_b.seed(__s);
1096 _M_n = 0;
1100 * @brief Reseeds the %discard_block_engine object with the given seed
1101 * sequence.
1102 * @param __q A seed generator function.
1104 template<typename _Sseq>
1105 _If_seed_seq<_Sseq>
1106 seed(_Sseq& __q)
1108 _M_b.seed(__q);
1109 _M_n = 0;
1113 * @brief Gets a const reference to the underlying generator engine
1114 * object.
1116 const _RandomNumberEngine&
1117 base() const noexcept
1118 { return _M_b; }
1121 * @brief Gets the minimum value in the generated random number range.
1123 static constexpr result_type
1124 min()
1125 { return _RandomNumberEngine::min(); }
1128 * @brief Gets the maximum value in the generated random number range.
1130 static constexpr result_type
1131 max()
1132 { return _RandomNumberEngine::max(); }
1135 * @brief Discard a sequence of random numbers.
1137 void
1138 discard(unsigned long long __z)
1140 for (; __z != 0ULL; --__z)
1141 (*this)();
1145 * @brief Gets the next value in the generated random number sequence.
1147 result_type
1148 operator()();
1151 * @brief Compares two %discard_block_engine random number generator
1152 * objects of the same type for equality.
1154 * @param __lhs A %discard_block_engine random number generator object.
1155 * @param __rhs Another %discard_block_engine random number generator
1156 * object.
1158 * @returns true if the infinite sequences of generated values
1159 * would be equal, false otherwise.
1161 friend bool
1162 operator==(const discard_block_engine& __lhs,
1163 const discard_block_engine& __rhs)
1164 { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1167 * @brief Inserts the current state of a %discard_block_engine random
1168 * number generator engine @p __x into the output stream
1169 * @p __os.
1171 * @param __os An output stream.
1172 * @param __x A %discard_block_engine random number generator engine.
1174 * @returns The output stream with the state of @p __x inserted or in
1175 * an error state.
1177 template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
1178 typename _CharT, typename _Traits>
1179 friend std::basic_ostream<_CharT, _Traits>&
1180 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1181 const std::discard_block_engine<_RandomNumberEngine1,
1182 __p1, __r1>& __x);
1185 * @brief Extracts the current state of a % subtract_with_carry_engine
1186 * random number generator engine @p __x from the input stream
1187 * @p __is.
1189 * @param __is An input stream.
1190 * @param __x A %discard_block_engine random number generator engine.
1192 * @returns The input stream with the state of @p __x extracted or in
1193 * an error state.
1195 template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
1196 typename _CharT, typename _Traits>
1197 friend std::basic_istream<_CharT, _Traits>&
1198 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1199 std::discard_block_engine<_RandomNumberEngine1,
1200 __p1, __r1>& __x);
1202 private:
1203 _RandomNumberEngine _M_b;
1204 size_t _M_n;
1207 #if __cpp_impl_three_way_comparison < 201907L
1209 * @brief Compares two %discard_block_engine random number generator
1210 * objects of the same type for inequality.
1212 * @param __lhs A %discard_block_engine random number generator object.
1213 * @param __rhs Another %discard_block_engine random number generator
1214 * object.
1216 * @returns true if the infinite sequences of generated values
1217 * would be different, false otherwise.
1219 template<typename _RandomNumberEngine, size_t __p, size_t __r>
1220 inline bool
1221 operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
1222 __r>& __lhs,
1223 const std::discard_block_engine<_RandomNumberEngine, __p,
1224 __r>& __rhs)
1225 { return !(__lhs == __rhs); }
1226 #endif
1229 * Produces random numbers by combining random numbers from some base
1230 * engine to produce random numbers with a specified number of bits @p __w.
1232 * @headerfile random
1233 * @since C++11
1235 template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
1236 class independent_bits_engine
1238 static_assert(std::is_unsigned<_UIntType>::value,
1239 "result_type must be an unsigned integral type");
1240 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
1241 "template argument substituting __w out of bounds");
1243 template<typename _Sseq>
1244 using _If_seed_seq
1245 = __detail::_If_seed_seq_for<_Sseq, independent_bits_engine,
1246 _UIntType>;
1248 public:
1249 /** The type of the generated random value. */
1250 typedef _UIntType result_type;
1253 * @brief Constructs a default %independent_bits_engine engine.
1255 * The underlying engine is default constructed as well.
1257 independent_bits_engine()
1258 : _M_b() { }
1261 * @brief Copy constructs a %independent_bits_engine engine.
1263 * Copies an existing base class random number generator.
1264 * @param __rng An existing (base class) engine object.
1266 explicit
1267 independent_bits_engine(const _RandomNumberEngine& __rng)
1268 : _M_b(__rng) { }
1271 * @brief Move constructs a %independent_bits_engine engine.
1273 * Copies an existing base class random number generator.
1274 * @param __rng An existing (base class) engine object.
1276 explicit
1277 independent_bits_engine(_RandomNumberEngine&& __rng)
1278 : _M_b(std::move(__rng)) { }
1281 * @brief Seed constructs a %independent_bits_engine engine.
1283 * Constructs the underlying generator engine seeded with @p __s.
1284 * @param __s A seed value for the base class engine.
1286 explicit
1287 independent_bits_engine(result_type __s)
1288 : _M_b(__s) { }
1291 * @brief Generator construct a %independent_bits_engine engine.
1293 * @param __q A seed sequence.
1295 template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
1296 explicit
1297 independent_bits_engine(_Sseq& __q)
1298 : _M_b(__q)
1302 * @brief Reseeds the %independent_bits_engine object with the default
1303 * seed for the underlying base class generator engine.
1305 void
1306 seed()
1307 { _M_b.seed(); }
1310 * @brief Reseeds the %independent_bits_engine object with the default
1311 * seed for the underlying base class generator engine.
1313 void
1314 seed(result_type __s)
1315 { _M_b.seed(__s); }
1318 * @brief Reseeds the %independent_bits_engine object with the given
1319 * seed sequence.
1320 * @param __q A seed generator function.
1322 template<typename _Sseq>
1323 _If_seed_seq<_Sseq>
1324 seed(_Sseq& __q)
1325 { _M_b.seed(__q); }
1328 * @brief Gets a const reference to the underlying generator engine
1329 * object.
1331 const _RandomNumberEngine&
1332 base() const noexcept
1333 { return _M_b; }
1336 * @brief Gets the minimum value in the generated random number range.
1338 static constexpr result_type
1339 min()
1340 { return 0U; }
1343 * @brief Gets the maximum value in the generated random number range.
1345 static constexpr result_type
1346 max()
1347 { return __detail::_Shift<_UIntType, __w>::__value - 1; }
1350 * @brief Discard a sequence of random numbers.
1352 void
1353 discard(unsigned long long __z)
1355 for (; __z != 0ULL; --__z)
1356 (*this)();
1360 * @brief Gets the next value in the generated random number sequence.
1362 result_type
1363 operator()();
1366 * @brief Compares two %independent_bits_engine random number generator
1367 * objects of the same type for equality.
1369 * @param __lhs A %independent_bits_engine random number generator
1370 * object.
1371 * @param __rhs Another %independent_bits_engine random number generator
1372 * object.
1374 * @returns true if the infinite sequences of generated values
1375 * would be equal, false otherwise.
1377 friend bool
1378 operator==(const independent_bits_engine& __lhs,
1379 const independent_bits_engine& __rhs)
1380 { return __lhs._M_b == __rhs._M_b; }
1383 * @brief Extracts the current state of a % subtract_with_carry_engine
1384 * random number generator engine @p __x from the input stream
1385 * @p __is.
1387 * @param __is An input stream.
1388 * @param __x A %independent_bits_engine random number generator
1389 * engine.
1391 * @returns The input stream with the state of @p __x extracted or in
1392 * an error state.
1394 template<typename _CharT, typename _Traits>
1395 friend std::basic_istream<_CharT, _Traits>&
1396 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1397 std::independent_bits_engine<_RandomNumberEngine,
1398 __w, _UIntType>& __x)
1400 __is >> __x._M_b;
1401 return __is;
1404 private:
1405 _RandomNumberEngine _M_b;
1408 #if __cpp_impl_three_way_comparison < 201907L
1410 * @brief Compares two %independent_bits_engine random number generator
1411 * objects of the same type for inequality.
1413 * @param __lhs A %independent_bits_engine random number generator
1414 * object.
1415 * @param __rhs Another %independent_bits_engine random number generator
1416 * object.
1418 * @returns true if the infinite sequences of generated values
1419 * would be different, false otherwise.
1421 template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
1422 inline bool
1423 operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
1424 _UIntType>& __lhs,
1425 const std::independent_bits_engine<_RandomNumberEngine, __w,
1426 _UIntType>& __rhs)
1427 { return !(__lhs == __rhs); }
1428 #endif
1431 * @brief Inserts the current state of a %independent_bits_engine random
1432 * number generator engine @p __x into the output stream @p __os.
1434 * @param __os An output stream.
1435 * @param __x A %independent_bits_engine random number generator engine.
1437 * @returns The output stream with the state of @p __x inserted or in
1438 * an error state.
1440 template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
1441 typename _CharT, typename _Traits>
1442 std::basic_ostream<_CharT, _Traits>&
1443 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1444 const std::independent_bits_engine<_RandomNumberEngine,
1445 __w, _UIntType>& __x)
1447 __os << __x.base();
1448 return __os;
1453 * @brief Produces random numbers by reordering random numbers from some
1454 * base engine.
1456 * The values from the base engine are stored in a sequence of size @p __k
1457 * and shuffled by an algorithm that depends on those values.
1459 * @headerfile random
1460 * @since C++11
1462 template<typename _RandomNumberEngine, size_t __k>
1463 class shuffle_order_engine
1465 static_assert(1u <= __k, "template argument substituting "
1466 "__k out of bound");
1468 public:
1469 /** The type of the generated random value. */
1470 typedef typename _RandomNumberEngine::result_type result_type;
1472 template<typename _Sseq>
1473 using _If_seed_seq
1474 = __detail::_If_seed_seq_for<_Sseq, shuffle_order_engine,
1475 result_type>;
1477 static constexpr size_t table_size = __k;
1480 * @brief Constructs a default %shuffle_order_engine engine.
1482 * The underlying engine is default constructed as well.
1484 shuffle_order_engine()
1485 : _M_b()
1486 { _M_initialize(); }
1489 * @brief Copy constructs a %shuffle_order_engine engine.
1491 * Copies an existing base class random number generator.
1492 * @param __rng An existing (base class) engine object.
1494 explicit
1495 shuffle_order_engine(const _RandomNumberEngine& __rng)
1496 : _M_b(__rng)
1497 { _M_initialize(); }
1500 * @brief Move constructs a %shuffle_order_engine engine.
1502 * Copies an existing base class random number generator.
1503 * @param __rng An existing (base class) engine object.
1505 explicit
1506 shuffle_order_engine(_RandomNumberEngine&& __rng)
1507 : _M_b(std::move(__rng))
1508 { _M_initialize(); }
1511 * @brief Seed constructs a %shuffle_order_engine engine.
1513 * Constructs the underlying generator engine seeded with @p __s.
1514 * @param __s A seed value for the base class engine.
1516 explicit
1517 shuffle_order_engine(result_type __s)
1518 : _M_b(__s)
1519 { _M_initialize(); }
1522 * @brief Generator construct a %shuffle_order_engine engine.
1524 * @param __q A seed sequence.
1526 template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
1527 explicit
1528 shuffle_order_engine(_Sseq& __q)
1529 : _M_b(__q)
1530 { _M_initialize(); }
1533 * @brief Reseeds the %shuffle_order_engine object with the default seed
1534 for the underlying base class generator engine.
1536 void
1537 seed()
1539 _M_b.seed();
1540 _M_initialize();
1544 * @brief Reseeds the %shuffle_order_engine object with the default seed
1545 * for the underlying base class generator engine.
1547 void
1548 seed(result_type __s)
1550 _M_b.seed(__s);
1551 _M_initialize();
1555 * @brief Reseeds the %shuffle_order_engine object with the given seed
1556 * sequence.
1557 * @param __q A seed generator function.
1559 template<typename _Sseq>
1560 _If_seed_seq<_Sseq>
1561 seed(_Sseq& __q)
1563 _M_b.seed(__q);
1564 _M_initialize();
1568 * Gets a const reference to the underlying generator engine object.
1570 const _RandomNumberEngine&
1571 base() const noexcept
1572 { return _M_b; }
1575 * Gets the minimum value in the generated random number range.
1577 static constexpr result_type
1578 min()
1579 { return _RandomNumberEngine::min(); }
1582 * Gets the maximum value in the generated random number range.
1584 static constexpr result_type
1585 max()
1586 { return _RandomNumberEngine::max(); }
1589 * Discard a sequence of random numbers.
1591 void
1592 discard(unsigned long long __z)
1594 for (; __z != 0ULL; --__z)
1595 (*this)();
1599 * Gets the next value in the generated random number sequence.
1601 result_type
1602 operator()();
1605 * Compares two %shuffle_order_engine random number generator objects
1606 * of the same type for equality.
1608 * @param __lhs A %shuffle_order_engine random number generator object.
1609 * @param __rhs Another %shuffle_order_engine random number generator
1610 * object.
1612 * @returns true if the infinite sequences of generated values
1613 * would be equal, false otherwise.
1615 friend bool
1616 operator==(const shuffle_order_engine& __lhs,
1617 const shuffle_order_engine& __rhs)
1618 { return (__lhs._M_b == __rhs._M_b
1619 && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1620 && __lhs._M_y == __rhs._M_y); }
1623 * @brief Inserts the current state of a %shuffle_order_engine random
1624 * number generator engine @p __x into the output stream
1625 @p __os.
1627 * @param __os An output stream.
1628 * @param __x A %shuffle_order_engine random number generator engine.
1630 * @returns The output stream with the state of @p __x inserted or in
1631 * an error state.
1633 template<typename _RandomNumberEngine1, size_t __k1,
1634 typename _CharT, typename _Traits>
1635 friend std::basic_ostream<_CharT, _Traits>&
1636 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1637 const std::shuffle_order_engine<_RandomNumberEngine1,
1638 __k1>& __x);
1641 * @brief Extracts the current state of a % subtract_with_carry_engine
1642 * random number generator engine @p __x from the input stream
1643 * @p __is.
1645 * @param __is An input stream.
1646 * @param __x A %shuffle_order_engine random number generator engine.
1648 * @returns The input stream with the state of @p __x extracted or in
1649 * an error state.
1651 template<typename _RandomNumberEngine1, size_t __k1,
1652 typename _CharT, typename _Traits>
1653 friend std::basic_istream<_CharT, _Traits>&
1654 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1655 std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
1657 private:
1658 void _M_initialize()
1660 for (size_t __i = 0; __i < __k; ++__i)
1661 _M_v[__i] = _M_b();
1662 _M_y = _M_b();
1665 _RandomNumberEngine _M_b;
1666 result_type _M_v[__k];
1667 result_type _M_y;
1670 #if __cpp_impl_three_way_comparison < 201907L
1672 * Compares two %shuffle_order_engine random number generator objects
1673 * of the same type for inequality.
1675 * @param __lhs A %shuffle_order_engine random number generator object.
1676 * @param __rhs Another %shuffle_order_engine random number generator
1677 * object.
1679 * @returns true if the infinite sequences of generated values
1680 * would be different, false otherwise.
1682 template<typename _RandomNumberEngine, size_t __k>
1683 inline bool
1684 operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
1685 __k>& __lhs,
1686 const std::shuffle_order_engine<_RandomNumberEngine,
1687 __k>& __rhs)
1688 { return !(__lhs == __rhs); }
1689 #endif
1692 * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
1694 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1695 minstd_rand0;
1698 * An alternative LCR (Lehmer Generator function).
1700 typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
1701 minstd_rand;
1704 * The classic Mersenne Twister.
1706 * Reference:
1707 * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
1708 * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
1709 * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
1711 typedef mersenne_twister_engine<
1712 uint_fast32_t,
1713 32, 624, 397, 31,
1714 0x9908b0dfUL, 11,
1715 0xffffffffUL, 7,
1716 0x9d2c5680UL, 15,
1717 0xefc60000UL, 18, 1812433253UL> mt19937;
1720 * An alternative Mersenne Twister.
1722 typedef mersenne_twister_engine<
1723 uint_fast64_t,
1724 64, 312, 156, 31,
1725 0xb5026f5aa96619e9ULL, 29,
1726 0x5555555555555555ULL, 17,
1727 0x71d67fffeda60000ULL, 37,
1728 0xfff7eee000000000ULL, 43,
1729 6364136223846793005ULL> mt19937_64;
1731 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
1732 ranlux24_base;
1734 typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
1735 ranlux48_base;
1737 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
1739 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
1741 typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
1743 typedef minstd_rand0 default_random_engine;
1746 * A standard interface to a platform-specific non-deterministic
1747 * random number generator (if any are available).
1749 * @headerfile random
1750 * @since C++11
1752 class random_device
1754 public:
1755 /** The type of the generated random value. */
1756 typedef unsigned int result_type;
1758 // constructors, destructors and member functions
1760 random_device() { _M_init("default"); }
1762 explicit
1763 random_device(const std::string& __token) { _M_init(__token); }
1765 ~random_device()
1766 { _M_fini(); }
1768 static constexpr result_type
1769 min()
1770 { return std::numeric_limits<result_type>::min(); }
1772 static constexpr result_type
1773 max()
1774 { return std::numeric_limits<result_type>::max(); }
1776 double
1777 entropy() const noexcept
1778 { return this->_M_getentropy(); }
1780 result_type
1781 operator()()
1782 { return this->_M_getval(); }
1784 // No copy functions.
1785 random_device(const random_device&) = delete;
1786 void operator=(const random_device&) = delete;
1788 private:
1790 void _M_init(const std::string& __token);
1791 void _M_init_pretr1(const std::string& __token);
1792 void _M_fini();
1794 result_type _M_getval();
1795 result_type _M_getval_pretr1();
1796 double _M_getentropy() const noexcept;
1798 void _M_init(const char*, size_t); // not exported from the shared library
1800 __extension__ union
1802 struct
1804 void* _M_file;
1805 result_type (*_M_func)(void*);
1806 int _M_fd;
1808 mt19937 _M_mt;
1812 /// @} group random_generators
1815 * @addtogroup random_distributions Random Number Distributions
1816 * @ingroup random
1817 * @{
1821 * @addtogroup random_distributions_uniform Uniform Distributions
1822 * @ingroup random_distributions
1823 * @{
1826 // std::uniform_int_distribution is defined in <bits/uniform_int_dist.h>
1828 #if __cpp_impl_three_way_comparison < 201907L
1830 * @brief Return true if two uniform integer distributions have
1831 * different parameters.
1833 template<typename _IntType>
1834 inline bool
1835 operator!=(const std::uniform_int_distribution<_IntType>& __d1,
1836 const std::uniform_int_distribution<_IntType>& __d2)
1837 { return !(__d1 == __d2); }
1838 #endif
1841 * @brief Inserts a %uniform_int_distribution random number
1842 * distribution @p __x into the output stream @p os.
1844 * @param __os An output stream.
1845 * @param __x A %uniform_int_distribution random number distribution.
1847 * @returns The output stream with the state of @p __x inserted or in
1848 * an error state.
1850 template<typename _IntType, typename _CharT, typename _Traits>
1851 std::basic_ostream<_CharT, _Traits>&
1852 operator<<(std::basic_ostream<_CharT, _Traits>&,
1853 const std::uniform_int_distribution<_IntType>&);
1856 * @brief Extracts a %uniform_int_distribution random number distribution
1857 * @p __x from the input stream @p __is.
1859 * @param __is An input stream.
1860 * @param __x A %uniform_int_distribution random number generator engine.
1862 * @returns The input stream with @p __x extracted or in an error state.
1864 template<typename _IntType, typename _CharT, typename _Traits>
1865 std::basic_istream<_CharT, _Traits>&
1866 operator>>(std::basic_istream<_CharT, _Traits>&,
1867 std::uniform_int_distribution<_IntType>&);
1871 * @brief Uniform continuous distribution for random numbers.
1873 * A continuous random distribution on the range [min, max) with equal
1874 * probability throughout the range. The URNG should be real-valued and
1875 * deliver number in the range [0, 1).
1877 * @headerfile random
1878 * @since C++11
1880 template<typename _RealType = double>
1881 class uniform_real_distribution
1883 static_assert(std::is_floating_point<_RealType>::value,
1884 "result_type must be a floating point type");
1886 public:
1887 /** The type of the range of the distribution. */
1888 typedef _RealType result_type;
1890 /** Parameter type. */
1891 struct param_type
1893 typedef uniform_real_distribution<_RealType> distribution_type;
1895 param_type() : param_type(0) { }
1897 explicit
1898 param_type(_RealType __a, _RealType __b = _RealType(1))
1899 : _M_a(__a), _M_b(__b)
1901 __glibcxx_assert(_M_a <= _M_b);
1904 result_type
1905 a() const
1906 { return _M_a; }
1908 result_type
1909 b() const
1910 { return _M_b; }
1912 friend bool
1913 operator==(const param_type& __p1, const param_type& __p2)
1914 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1916 #if __cpp_impl_three_way_comparison < 201907L
1917 friend bool
1918 operator!=(const param_type& __p1, const param_type& __p2)
1919 { return !(__p1 == __p2); }
1920 #endif
1922 private:
1923 _RealType _M_a;
1924 _RealType _M_b;
1927 public:
1929 * @brief Constructs a uniform_real_distribution object.
1931 * The lower bound is set to 0.0 and the upper bound to 1.0
1933 uniform_real_distribution() : uniform_real_distribution(0.0) { }
1936 * @brief Constructs a uniform_real_distribution object.
1938 * @param __a [IN] The lower bound of the distribution.
1939 * @param __b [IN] The upper bound of the distribution.
1941 explicit
1942 uniform_real_distribution(_RealType __a, _RealType __b = _RealType(1))
1943 : _M_param(__a, __b)
1946 explicit
1947 uniform_real_distribution(const param_type& __p)
1948 : _M_param(__p)
1952 * @brief Resets the distribution state.
1954 * Does nothing for the uniform real distribution.
1956 void
1957 reset() { }
1959 result_type
1960 a() const
1961 { return _M_param.a(); }
1963 result_type
1964 b() const
1965 { return _M_param.b(); }
1968 * @brief Returns the parameter set of the distribution.
1970 param_type
1971 param() const
1972 { return _M_param; }
1975 * @brief Sets the parameter set of the distribution.
1976 * @param __param The new parameter set of the distribution.
1978 void
1979 param(const param_type& __param)
1980 { _M_param = __param; }
1983 * @brief Returns the inclusive lower bound of the distribution range.
1985 result_type
1986 min() const
1987 { return this->a(); }
1990 * @brief Returns the inclusive upper bound of the distribution range.
1992 result_type
1993 max() const
1994 { return this->b(); }
1997 * @brief Generating functions.
1999 template<typename _UniformRandomNumberGenerator>
2000 result_type
2001 operator()(_UniformRandomNumberGenerator& __urng)
2002 { return this->operator()(__urng, _M_param); }
2004 template<typename _UniformRandomNumberGenerator>
2005 result_type
2006 operator()(_UniformRandomNumberGenerator& __urng,
2007 const param_type& __p)
2009 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2010 __aurng(__urng);
2011 return (__aurng() * (__p.b() - __p.a())) + __p.a();
2014 template<typename _ForwardIterator,
2015 typename _UniformRandomNumberGenerator>
2016 void
2017 __generate(_ForwardIterator __f, _ForwardIterator __t,
2018 _UniformRandomNumberGenerator& __urng)
2019 { this->__generate(__f, __t, __urng, _M_param); }
2021 template<typename _ForwardIterator,
2022 typename _UniformRandomNumberGenerator>
2023 void
2024 __generate(_ForwardIterator __f, _ForwardIterator __t,
2025 _UniformRandomNumberGenerator& __urng,
2026 const param_type& __p)
2027 { this->__generate_impl(__f, __t, __urng, __p); }
2029 template<typename _UniformRandomNumberGenerator>
2030 void
2031 __generate(result_type* __f, result_type* __t,
2032 _UniformRandomNumberGenerator& __urng,
2033 const param_type& __p)
2034 { this->__generate_impl(__f, __t, __urng, __p); }
2037 * @brief Return true if two uniform real distributions have
2038 * the same parameters.
2040 friend bool
2041 operator==(const uniform_real_distribution& __d1,
2042 const uniform_real_distribution& __d2)
2043 { return __d1._M_param == __d2._M_param; }
2045 private:
2046 template<typename _ForwardIterator,
2047 typename _UniformRandomNumberGenerator>
2048 void
2049 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2050 _UniformRandomNumberGenerator& __urng,
2051 const param_type& __p);
2053 param_type _M_param;
2056 #if __cpp_impl_three_way_comparison < 201907L
2058 * @brief Return true if two uniform real distributions have
2059 * different parameters.
2061 template<typename _IntType>
2062 inline bool
2063 operator!=(const std::uniform_real_distribution<_IntType>& __d1,
2064 const std::uniform_real_distribution<_IntType>& __d2)
2065 { return !(__d1 == __d2); }
2066 #endif
2069 * @brief Inserts a %uniform_real_distribution random number
2070 * distribution @p __x into the output stream @p __os.
2072 * @param __os An output stream.
2073 * @param __x A %uniform_real_distribution random number distribution.
2075 * @returns The output stream with the state of @p __x inserted or in
2076 * an error state.
2078 template<typename _RealType, typename _CharT, typename _Traits>
2079 std::basic_ostream<_CharT, _Traits>&
2080 operator<<(std::basic_ostream<_CharT, _Traits>&,
2081 const std::uniform_real_distribution<_RealType>&);
2084 * @brief Extracts a %uniform_real_distribution random number distribution
2085 * @p __x from the input stream @p __is.
2087 * @param __is An input stream.
2088 * @param __x A %uniform_real_distribution random number generator engine.
2090 * @returns The input stream with @p __x extracted or in an error state.
2092 template<typename _RealType, typename _CharT, typename _Traits>
2093 std::basic_istream<_CharT, _Traits>&
2094 operator>>(std::basic_istream<_CharT, _Traits>&,
2095 std::uniform_real_distribution<_RealType>&);
2097 /// @} group random_distributions_uniform
2100 * @addtogroup random_distributions_normal Normal Distributions
2101 * @ingroup random_distributions
2102 * @{
2106 * @brief A normal continuous distribution for random numbers.
2108 * The formula for the normal probability density function is
2109 * @f[
2110 * p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
2111 * e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} }
2112 * @f]
2114 * @headerfile random
2115 * @since C++11
2117 template<typename _RealType = double>
2118 class normal_distribution
2120 static_assert(std::is_floating_point<_RealType>::value,
2121 "result_type must be a floating point type");
2123 public:
2124 /** The type of the range of the distribution. */
2125 typedef _RealType result_type;
2127 /** Parameter type. */
2128 struct param_type
2130 typedef normal_distribution<_RealType> distribution_type;
2132 param_type() : param_type(0.0) { }
2134 explicit
2135 param_type(_RealType __mean, _RealType __stddev = _RealType(1))
2136 : _M_mean(__mean), _M_stddev(__stddev)
2138 __glibcxx_assert(_M_stddev > _RealType(0));
2141 _RealType
2142 mean() const
2143 { return _M_mean; }
2145 _RealType
2146 stddev() const
2147 { return _M_stddev; }
2149 friend bool
2150 operator==(const param_type& __p1, const param_type& __p2)
2151 { return (__p1._M_mean == __p2._M_mean
2152 && __p1._M_stddev == __p2._M_stddev); }
2154 #if __cpp_impl_three_way_comparison < 201907L
2155 friend bool
2156 operator!=(const param_type& __p1, const param_type& __p2)
2157 { return !(__p1 == __p2); }
2158 #endif
2160 private:
2161 _RealType _M_mean;
2162 _RealType _M_stddev;
2165 public:
2166 normal_distribution() : normal_distribution(0.0) { }
2169 * Constructs a normal distribution with parameters @f$mean@f$ and
2170 * standard deviation.
2172 explicit
2173 normal_distribution(result_type __mean,
2174 result_type __stddev = result_type(1))
2175 : _M_param(__mean, __stddev)
2178 explicit
2179 normal_distribution(const param_type& __p)
2180 : _M_param(__p)
2184 * @brief Resets the distribution state.
2186 void
2187 reset()
2188 { _M_saved_available = false; }
2191 * @brief Returns the mean of the distribution.
2193 _RealType
2194 mean() const
2195 { return _M_param.mean(); }
2198 * @brief Returns the standard deviation of the distribution.
2200 _RealType
2201 stddev() const
2202 { return _M_param.stddev(); }
2205 * @brief Returns the parameter set of the distribution.
2207 param_type
2208 param() const
2209 { return _M_param; }
2212 * @brief Sets the parameter set of the distribution.
2213 * @param __param The new parameter set of the distribution.
2215 void
2216 param(const param_type& __param)
2217 { _M_param = __param; }
2220 * @brief Returns the greatest lower bound value of the distribution.
2222 result_type
2223 min() const
2224 { return std::numeric_limits<result_type>::lowest(); }
2227 * @brief Returns the least upper bound value of the distribution.
2229 result_type
2230 max() const
2231 { return std::numeric_limits<result_type>::max(); }
2234 * @brief Generating functions.
2236 template<typename _UniformRandomNumberGenerator>
2237 result_type
2238 operator()(_UniformRandomNumberGenerator& __urng)
2239 { return this->operator()(__urng, _M_param); }
2241 template<typename _UniformRandomNumberGenerator>
2242 result_type
2243 operator()(_UniformRandomNumberGenerator& __urng,
2244 const param_type& __p);
2246 template<typename _ForwardIterator,
2247 typename _UniformRandomNumberGenerator>
2248 void
2249 __generate(_ForwardIterator __f, _ForwardIterator __t,
2250 _UniformRandomNumberGenerator& __urng)
2251 { this->__generate(__f, __t, __urng, _M_param); }
2253 template<typename _ForwardIterator,
2254 typename _UniformRandomNumberGenerator>
2255 void
2256 __generate(_ForwardIterator __f, _ForwardIterator __t,
2257 _UniformRandomNumberGenerator& __urng,
2258 const param_type& __p)
2259 { this->__generate_impl(__f, __t, __urng, __p); }
2261 template<typename _UniformRandomNumberGenerator>
2262 void
2263 __generate(result_type* __f, result_type* __t,
2264 _UniformRandomNumberGenerator& __urng,
2265 const param_type& __p)
2266 { this->__generate_impl(__f, __t, __urng, __p); }
2269 * @brief Return true if two normal distributions have
2270 * the same parameters and the sequences that would
2271 * be generated are equal.
2273 template<typename _RealType1>
2274 friend bool
2275 operator==(const std::normal_distribution<_RealType1>& __d1,
2276 const std::normal_distribution<_RealType1>& __d2);
2279 * @brief Inserts a %normal_distribution random number distribution
2280 * @p __x into the output stream @p __os.
2282 * @param __os An output stream.
2283 * @param __x A %normal_distribution random number distribution.
2285 * @returns The output stream with the state of @p __x inserted or in
2286 * an error state.
2288 template<typename _RealType1, typename _CharT, typename _Traits>
2289 friend std::basic_ostream<_CharT, _Traits>&
2290 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2291 const std::normal_distribution<_RealType1>& __x);
2294 * @brief Extracts a %normal_distribution random number distribution
2295 * @p __x from the input stream @p __is.
2297 * @param __is An input stream.
2298 * @param __x A %normal_distribution random number generator engine.
2300 * @returns The input stream with @p __x extracted or in an error
2301 * state.
2303 template<typename _RealType1, typename _CharT, typename _Traits>
2304 friend std::basic_istream<_CharT, _Traits>&
2305 operator>>(std::basic_istream<_CharT, _Traits>& __is,
2306 std::normal_distribution<_RealType1>& __x);
2308 private:
2309 template<typename _ForwardIterator,
2310 typename _UniformRandomNumberGenerator>
2311 void
2312 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2313 _UniformRandomNumberGenerator& __urng,
2314 const param_type& __p);
2316 param_type _M_param;
2317 result_type _M_saved = 0;
2318 bool _M_saved_available = false;
2321 #if __cpp_impl_three_way_comparison < 201907L
2323 * @brief Return true if two normal distributions are different.
2325 template<typename _RealType>
2326 inline bool
2327 operator!=(const std::normal_distribution<_RealType>& __d1,
2328 const std::normal_distribution<_RealType>& __d2)
2329 { return !(__d1 == __d2); }
2330 #endif
2333 * @brief A lognormal_distribution random number distribution.
2335 * The formula for the normal probability mass function is
2336 * @f[
2337 * p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
2338 * \exp{-\frac{(\ln{x} - m)^2}{2s^2}}
2339 * @f]
2341 * @headerfile random
2342 * @since C++11
2344 template<typename _RealType = double>
2345 class lognormal_distribution
2347 static_assert(std::is_floating_point<_RealType>::value,
2348 "result_type must be a floating point type");
2350 public:
2351 /** The type of the range of the distribution. */
2352 typedef _RealType result_type;
2354 /** Parameter type. */
2355 struct param_type
2357 typedef lognormal_distribution<_RealType> distribution_type;
2359 param_type() : param_type(0.0) { }
2361 explicit
2362 param_type(_RealType __m, _RealType __s = _RealType(1))
2363 : _M_m(__m), _M_s(__s)
2366 _RealType
2367 m() const
2368 { return _M_m; }
2370 _RealType
2371 s() const
2372 { return _M_s; }
2374 friend bool
2375 operator==(const param_type& __p1, const param_type& __p2)
2376 { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2378 #if __cpp_impl_three_way_comparison < 201907L
2379 friend bool
2380 operator!=(const param_type& __p1, const param_type& __p2)
2381 { return !(__p1 == __p2); }
2382 #endif
2384 private:
2385 _RealType _M_m;
2386 _RealType _M_s;
2389 lognormal_distribution() : lognormal_distribution(0.0) { }
2391 explicit
2392 lognormal_distribution(_RealType __m, _RealType __s = _RealType(1))
2393 : _M_param(__m, __s), _M_nd()
2396 explicit
2397 lognormal_distribution(const param_type& __p)
2398 : _M_param(__p), _M_nd()
2402 * Resets the distribution state.
2404 void
2405 reset()
2406 { _M_nd.reset(); }
2411 _RealType
2412 m() const
2413 { return _M_param.m(); }
2415 _RealType
2416 s() const
2417 { return _M_param.s(); }
2420 * @brief Returns the parameter set of the distribution.
2422 param_type
2423 param() const
2424 { return _M_param; }
2427 * @brief Sets the parameter set of the distribution.
2428 * @param __param The new parameter set of the distribution.
2430 void
2431 param(const param_type& __param)
2432 { _M_param = __param; }
2435 * @brief Returns the greatest lower bound value of the distribution.
2437 result_type
2438 min() const
2439 { return result_type(0); }
2442 * @brief Returns the least upper bound value of the distribution.
2444 result_type
2445 max() const
2446 { return std::numeric_limits<result_type>::max(); }
2449 * @brief Generating functions.
2451 template<typename _UniformRandomNumberGenerator>
2452 result_type
2453 operator()(_UniformRandomNumberGenerator& __urng)
2454 { return this->operator()(__urng, _M_param); }
2456 template<typename _UniformRandomNumberGenerator>
2457 result_type
2458 operator()(_UniformRandomNumberGenerator& __urng,
2459 const param_type& __p)
2460 { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2462 template<typename _ForwardIterator,
2463 typename _UniformRandomNumberGenerator>
2464 void
2465 __generate(_ForwardIterator __f, _ForwardIterator __t,
2466 _UniformRandomNumberGenerator& __urng)
2467 { this->__generate(__f, __t, __urng, _M_param); }
2469 template<typename _ForwardIterator,
2470 typename _UniformRandomNumberGenerator>
2471 void
2472 __generate(_ForwardIterator __f, _ForwardIterator __t,
2473 _UniformRandomNumberGenerator& __urng,
2474 const param_type& __p)
2475 { this->__generate_impl(__f, __t, __urng, __p); }
2477 template<typename _UniformRandomNumberGenerator>
2478 void
2479 __generate(result_type* __f, result_type* __t,
2480 _UniformRandomNumberGenerator& __urng,
2481 const param_type& __p)
2482 { this->__generate_impl(__f, __t, __urng, __p); }
2485 * @brief Return true if two lognormal distributions have
2486 * the same parameters and the sequences that would
2487 * be generated are equal.
2489 friend bool
2490 operator==(const lognormal_distribution& __d1,
2491 const lognormal_distribution& __d2)
2492 { return (__d1._M_param == __d2._M_param
2493 && __d1._M_nd == __d2._M_nd); }
2496 * @brief Inserts a %lognormal_distribution random number distribution
2497 * @p __x into the output stream @p __os.
2499 * @param __os An output stream.
2500 * @param __x A %lognormal_distribution random number distribution.
2502 * @returns The output stream with the state of @p __x inserted or in
2503 * an error state.
2505 template<typename _RealType1, typename _CharT, typename _Traits>
2506 friend std::basic_ostream<_CharT, _Traits>&
2507 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2508 const std::lognormal_distribution<_RealType1>& __x);
2511 * @brief Extracts a %lognormal_distribution random number distribution
2512 * @p __x from the input stream @p __is.
2514 * @param __is An input stream.
2515 * @param __x A %lognormal_distribution random number
2516 * generator engine.
2518 * @returns The input stream with @p __x extracted or in an error state.
2520 template<typename _RealType1, typename _CharT, typename _Traits>
2521 friend std::basic_istream<_CharT, _Traits>&
2522 operator>>(std::basic_istream<_CharT, _Traits>& __is,
2523 std::lognormal_distribution<_RealType1>& __x);
2525 private:
2526 template<typename _ForwardIterator,
2527 typename _UniformRandomNumberGenerator>
2528 void
2529 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2530 _UniformRandomNumberGenerator& __urng,
2531 const param_type& __p);
2533 param_type _M_param;
2535 std::normal_distribution<result_type> _M_nd;
2538 #if __cpp_impl_three_way_comparison < 201907L
2540 * @brief Return true if two lognormal distributions are different.
2542 template<typename _RealType>
2543 inline bool
2544 operator!=(const std::lognormal_distribution<_RealType>& __d1,
2545 const std::lognormal_distribution<_RealType>& __d2)
2546 { return !(__d1 == __d2); }
2547 #endif
2549 /// @} group random_distributions_normal
2552 * @addtogroup random_distributions_poisson Poisson Distributions
2553 * @ingroup random_distributions
2554 * @{
2558 * @brief A gamma continuous distribution for random numbers.
2560 * The formula for the gamma probability density function is:
2561 * @f[
2562 * p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
2563 * (x/\beta)^{\alpha - 1} e^{-x/\beta}
2564 * @f]
2566 * @headerfile random
2567 * @since C++11
2569 template<typename _RealType = double>
2570 class gamma_distribution
2572 static_assert(std::is_floating_point<_RealType>::value,
2573 "result_type must be a floating point type");
2575 public:
2576 /** The type of the range of the distribution. */
2577 typedef _RealType result_type;
2579 /** Parameter type. */
2580 struct param_type
2582 typedef gamma_distribution<_RealType> distribution_type;
2583 friend class gamma_distribution<_RealType>;
2585 param_type() : param_type(1.0) { }
2587 explicit
2588 param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1))
2589 : _M_alpha(__alpha_val), _M_beta(__beta_val)
2591 __glibcxx_assert(_M_alpha > _RealType(0));
2592 _M_initialize();
2595 _RealType
2596 alpha() const
2597 { return _M_alpha; }
2599 _RealType
2600 beta() const
2601 { return _M_beta; }
2603 friend bool
2604 operator==(const param_type& __p1, const param_type& __p2)
2605 { return (__p1._M_alpha == __p2._M_alpha
2606 && __p1._M_beta == __p2._M_beta); }
2608 #if __cpp_impl_three_way_comparison < 201907L
2609 friend bool
2610 operator!=(const param_type& __p1, const param_type& __p2)
2611 { return !(__p1 == __p2); }
2612 #endif
2614 private:
2615 void
2616 _M_initialize();
2618 _RealType _M_alpha;
2619 _RealType _M_beta;
2621 _RealType _M_malpha, _M_a2;
2624 public:
2626 * @brief Constructs a gamma distribution with parameters 1 and 1.
2628 gamma_distribution() : gamma_distribution(1.0) { }
2631 * @brief Constructs a gamma distribution with parameters
2632 * @f$\alpha@f$ and @f$\beta@f$.
2634 explicit
2635 gamma_distribution(_RealType __alpha_val,
2636 _RealType __beta_val = _RealType(1))
2637 : _M_param(__alpha_val, __beta_val), _M_nd()
2640 explicit
2641 gamma_distribution(const param_type& __p)
2642 : _M_param(__p), _M_nd()
2646 * @brief Resets the distribution state.
2648 void
2649 reset()
2650 { _M_nd.reset(); }
2653 * @brief Returns the @f$\alpha@f$ of the distribution.
2655 _RealType
2656 alpha() const
2657 { return _M_param.alpha(); }
2660 * @brief Returns the @f$\beta@f$ of the distribution.
2662 _RealType
2663 beta() const
2664 { return _M_param.beta(); }
2667 * @brief Returns the parameter set of the distribution.
2669 param_type
2670 param() const
2671 { return _M_param; }
2674 * @brief Sets the parameter set of the distribution.
2675 * @param __param The new parameter set of the distribution.
2677 void
2678 param(const param_type& __param)
2679 { _M_param = __param; }
2682 * @brief Returns the greatest lower bound value of the distribution.
2684 result_type
2685 min() const
2686 { return result_type(0); }
2689 * @brief Returns the least upper bound value of the distribution.
2691 result_type
2692 max() const
2693 { return std::numeric_limits<result_type>::max(); }
2696 * @brief Generating functions.
2698 template<typename _UniformRandomNumberGenerator>
2699 result_type
2700 operator()(_UniformRandomNumberGenerator& __urng)
2701 { return this->operator()(__urng, _M_param); }
2703 template<typename _UniformRandomNumberGenerator>
2704 result_type
2705 operator()(_UniformRandomNumberGenerator& __urng,
2706 const param_type& __p);
2708 template<typename _ForwardIterator,
2709 typename _UniformRandomNumberGenerator>
2710 void
2711 __generate(_ForwardIterator __f, _ForwardIterator __t,
2712 _UniformRandomNumberGenerator& __urng)
2713 { this->__generate(__f, __t, __urng, _M_param); }
2715 template<typename _ForwardIterator,
2716 typename _UniformRandomNumberGenerator>
2717 void
2718 __generate(_ForwardIterator __f, _ForwardIterator __t,
2719 _UniformRandomNumberGenerator& __urng,
2720 const param_type& __p)
2721 { this->__generate_impl(__f, __t, __urng, __p); }
2723 template<typename _UniformRandomNumberGenerator>
2724 void
2725 __generate(result_type* __f, result_type* __t,
2726 _UniformRandomNumberGenerator& __urng,
2727 const param_type& __p)
2728 { this->__generate_impl(__f, __t, __urng, __p); }
2731 * @brief Return true if two gamma distributions have the same
2732 * parameters and the sequences that would be generated
2733 * are equal.
2735 friend bool
2736 operator==(const gamma_distribution& __d1,
2737 const gamma_distribution& __d2)
2738 { return (__d1._M_param == __d2._M_param
2739 && __d1._M_nd == __d2._M_nd); }
2742 * @brief Inserts a %gamma_distribution random number distribution
2743 * @p __x into the output stream @p __os.
2745 * @param __os An output stream.
2746 * @param __x A %gamma_distribution random number distribution.
2748 * @returns The output stream with the state of @p __x inserted or in
2749 * an error state.
2751 template<typename _RealType1, typename _CharT, typename _Traits>
2752 friend std::basic_ostream<_CharT, _Traits>&
2753 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2754 const std::gamma_distribution<_RealType1>& __x);
2757 * @brief Extracts a %gamma_distribution random number distribution
2758 * @p __x from the input stream @p __is.
2760 * @param __is An input stream.
2761 * @param __x A %gamma_distribution random number generator engine.
2763 * @returns The input stream with @p __x extracted or in an error state.
2765 template<typename _RealType1, typename _CharT, typename _Traits>
2766 friend std::basic_istream<_CharT, _Traits>&
2767 operator>>(std::basic_istream<_CharT, _Traits>& __is,
2768 std::gamma_distribution<_RealType1>& __x);
2770 private:
2771 template<typename _ForwardIterator,
2772 typename _UniformRandomNumberGenerator>
2773 void
2774 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2775 _UniformRandomNumberGenerator& __urng,
2776 const param_type& __p);
2778 param_type _M_param;
2780 std::normal_distribution<result_type> _M_nd;
2783 #if __cpp_impl_three_way_comparison < 201907L
2785 * @brief Return true if two gamma distributions are different.
2787 template<typename _RealType>
2788 inline bool
2789 operator!=(const std::gamma_distribution<_RealType>& __d1,
2790 const std::gamma_distribution<_RealType>& __d2)
2791 { return !(__d1 == __d2); }
2792 #endif
2794 /// @} group random_distributions_poisson
2797 * @addtogroup random_distributions_normal Normal Distributions
2798 * @ingroup random_distributions
2799 * @{
2803 * @brief A chi_squared_distribution random number distribution.
2805 * The formula for the normal probability mass function is
2806 * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$
2808 * @headerfile random
2809 * @since C++11
2811 template<typename _RealType = double>
2812 class chi_squared_distribution
2814 static_assert(std::is_floating_point<_RealType>::value,
2815 "result_type must be a floating point type");
2817 public:
2818 /** The type of the range of the distribution. */
2819 typedef _RealType result_type;
2821 /** Parameter type. */
2822 struct param_type
2824 typedef chi_squared_distribution<_RealType> distribution_type;
2826 param_type() : param_type(1) { }
2828 explicit
2829 param_type(_RealType __n)
2830 : _M_n(__n)
2833 _RealType
2834 n() const
2835 { return _M_n; }
2837 friend bool
2838 operator==(const param_type& __p1, const param_type& __p2)
2839 { return __p1._M_n == __p2._M_n; }
2841 #if __cpp_impl_three_way_comparison < 201907L
2842 friend bool
2843 operator!=(const param_type& __p1, const param_type& __p2)
2844 { return !(__p1 == __p2); }
2845 #endif
2847 private:
2848 _RealType _M_n;
2851 chi_squared_distribution() : chi_squared_distribution(1) { }
2853 explicit
2854 chi_squared_distribution(_RealType __n)
2855 : _M_param(__n), _M_gd(__n / 2)
2858 explicit
2859 chi_squared_distribution(const param_type& __p)
2860 : _M_param(__p), _M_gd(__p.n() / 2)
2864 * @brief Resets the distribution state.
2866 void
2867 reset()
2868 { _M_gd.reset(); }
2873 _RealType
2874 n() const
2875 { return _M_param.n(); }
2878 * @brief Returns the parameter set of the distribution.
2880 param_type
2881 param() const
2882 { return _M_param; }
2885 * @brief Sets the parameter set of the distribution.
2886 * @param __param The new parameter set of the distribution.
2888 void
2889 param(const param_type& __param)
2891 _M_param = __param;
2892 typedef typename std::gamma_distribution<result_type>::param_type
2893 param_type;
2894 _M_gd.param(param_type{__param.n() / 2});
2898 * @brief Returns the greatest lower bound value of the distribution.
2900 result_type
2901 min() const
2902 { return result_type(0); }
2905 * @brief Returns the least upper bound value of the distribution.
2907 result_type
2908 max() const
2909 { return std::numeric_limits<result_type>::max(); }
2912 * @brief Generating functions.
2914 template<typename _UniformRandomNumberGenerator>
2915 result_type
2916 operator()(_UniformRandomNumberGenerator& __urng)
2917 { return 2 * _M_gd(__urng); }
2919 template<typename _UniformRandomNumberGenerator>
2920 result_type
2921 operator()(_UniformRandomNumberGenerator& __urng,
2922 const param_type& __p)
2924 typedef typename std::gamma_distribution<result_type>::param_type
2925 param_type;
2926 return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2929 template<typename _ForwardIterator,
2930 typename _UniformRandomNumberGenerator>
2931 void
2932 __generate(_ForwardIterator __f, _ForwardIterator __t,
2933 _UniformRandomNumberGenerator& __urng)
2934 { this->__generate_impl(__f, __t, __urng); }
2936 template<typename _ForwardIterator,
2937 typename _UniformRandomNumberGenerator>
2938 void
2939 __generate(_ForwardIterator __f, _ForwardIterator __t,
2940 _UniformRandomNumberGenerator& __urng,
2941 const param_type& __p)
2942 { typename std::gamma_distribution<result_type>::param_type
2943 __p2(__p.n() / 2);
2944 this->__generate_impl(__f, __t, __urng, __p2); }
2946 template<typename _UniformRandomNumberGenerator>
2947 void
2948 __generate(result_type* __f, result_type* __t,
2949 _UniformRandomNumberGenerator& __urng)
2950 { this->__generate_impl(__f, __t, __urng); }
2952 template<typename _UniformRandomNumberGenerator>
2953 void
2954 __generate(result_type* __f, result_type* __t,
2955 _UniformRandomNumberGenerator& __urng,
2956 const param_type& __p)
2957 { typename std::gamma_distribution<result_type>::param_type
2958 __p2(__p.n() / 2);
2959 this->__generate_impl(__f, __t, __urng, __p2); }
2962 * @brief Return true if two Chi-squared distributions have
2963 * the same parameters and the sequences that would be
2964 * generated are equal.
2966 friend bool
2967 operator==(const chi_squared_distribution& __d1,
2968 const chi_squared_distribution& __d2)
2969 { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2972 * @brief Inserts a %chi_squared_distribution random number distribution
2973 * @p __x into the output stream @p __os.
2975 * @param __os An output stream.
2976 * @param __x A %chi_squared_distribution random number distribution.
2978 * @returns The output stream with the state of @p __x inserted or in
2979 * an error state.
2981 template<typename _RealType1, typename _CharT, typename _Traits>
2982 friend std::basic_ostream<_CharT, _Traits>&
2983 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2984 const std::chi_squared_distribution<_RealType1>& __x);
2987 * @brief Extracts a %chi_squared_distribution random number distribution
2988 * @p __x from the input stream @p __is.
2990 * @param __is An input stream.
2991 * @param __x A %chi_squared_distribution random number
2992 * generator engine.
2994 * @returns The input stream with @p __x extracted or in an error state.
2996 template<typename _RealType1, typename _CharT, typename _Traits>
2997 friend std::basic_istream<_CharT, _Traits>&
2998 operator>>(std::basic_istream<_CharT, _Traits>& __is,
2999 std::chi_squared_distribution<_RealType1>& __x);
3001 private:
3002 template<typename _ForwardIterator,
3003 typename _UniformRandomNumberGenerator>
3004 void
3005 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3006 _UniformRandomNumberGenerator& __urng);
3008 template<typename _ForwardIterator,
3009 typename _UniformRandomNumberGenerator>
3010 void
3011 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3012 _UniformRandomNumberGenerator& __urng,
3013 const typename
3014 std::gamma_distribution<result_type>::param_type& __p);
3016 param_type _M_param;
3018 std::gamma_distribution<result_type> _M_gd;
3021 #if __cpp_impl_three_way_comparison < 201907L
3023 * @brief Return true if two Chi-squared distributions are different.
3025 template<typename _RealType>
3026 inline bool
3027 operator!=(const std::chi_squared_distribution<_RealType>& __d1,
3028 const std::chi_squared_distribution<_RealType>& __d2)
3029 { return !(__d1 == __d2); }
3030 #endif
3033 * @brief A cauchy_distribution random number distribution.
3035 * The formula for the normal probability mass function is
3036 * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$
3038 * @headerfile random
3039 * @since C++11
3041 template<typename _RealType = double>
3042 class cauchy_distribution
3044 static_assert(std::is_floating_point<_RealType>::value,
3045 "result_type must be a floating point type");
3047 public:
3048 /** The type of the range of the distribution. */
3049 typedef _RealType result_type;
3051 /** Parameter type. */
3052 struct param_type
3054 typedef cauchy_distribution<_RealType> distribution_type;
3056 param_type() : param_type(0) { }
3058 explicit
3059 param_type(_RealType __a, _RealType __b = _RealType(1))
3060 : _M_a(__a), _M_b(__b)
3063 _RealType
3064 a() const
3065 { return _M_a; }
3067 _RealType
3068 b() const
3069 { return _M_b; }
3071 friend bool
3072 operator==(const param_type& __p1, const param_type& __p2)
3073 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
3075 #if __cpp_impl_three_way_comparison < 201907L
3076 friend bool
3077 operator!=(const param_type& __p1, const param_type& __p2)
3078 { return !(__p1 == __p2); }
3079 #endif
3081 private:
3082 _RealType _M_a;
3083 _RealType _M_b;
3086 cauchy_distribution() : cauchy_distribution(0.0) { }
3088 explicit
3089 cauchy_distribution(_RealType __a, _RealType __b = 1.0)
3090 : _M_param(__a, __b)
3093 explicit
3094 cauchy_distribution(const param_type& __p)
3095 : _M_param(__p)
3099 * @brief Resets the distribution state.
3101 void
3102 reset()
3108 _RealType
3109 a() const
3110 { return _M_param.a(); }
3112 _RealType
3113 b() const
3114 { return _M_param.b(); }
3117 * @brief Returns the parameter set of the distribution.
3119 param_type
3120 param() const
3121 { return _M_param; }
3124 * @brief Sets the parameter set of the distribution.
3125 * @param __param The new parameter set of the distribution.
3127 void
3128 param(const param_type& __param)
3129 { _M_param = __param; }
3132 * @brief Returns the greatest lower bound value of the distribution.
3134 result_type
3135 min() const
3136 { return std::numeric_limits<result_type>::lowest(); }
3139 * @brief Returns the least upper bound value of the distribution.
3141 result_type
3142 max() const
3143 { return std::numeric_limits<result_type>::max(); }
3146 * @brief Generating functions.
3148 template<typename _UniformRandomNumberGenerator>
3149 result_type
3150 operator()(_UniformRandomNumberGenerator& __urng)
3151 { return this->operator()(__urng, _M_param); }
3153 template<typename _UniformRandomNumberGenerator>
3154 result_type
3155 operator()(_UniformRandomNumberGenerator& __urng,
3156 const param_type& __p);
3158 template<typename _ForwardIterator,
3159 typename _UniformRandomNumberGenerator>
3160 void
3161 __generate(_ForwardIterator __f, _ForwardIterator __t,
3162 _UniformRandomNumberGenerator& __urng)
3163 { this->__generate(__f, __t, __urng, _M_param); }
3165 template<typename _ForwardIterator,
3166 typename _UniformRandomNumberGenerator>
3167 void
3168 __generate(_ForwardIterator __f, _ForwardIterator __t,
3169 _UniformRandomNumberGenerator& __urng,
3170 const param_type& __p)
3171 { this->__generate_impl(__f, __t, __urng, __p); }
3173 template<typename _UniformRandomNumberGenerator>
3174 void
3175 __generate(result_type* __f, result_type* __t,
3176 _UniformRandomNumberGenerator& __urng,
3177 const param_type& __p)
3178 { this->__generate_impl(__f, __t, __urng, __p); }
3181 * @brief Return true if two Cauchy distributions have
3182 * the same parameters.
3184 friend bool
3185 operator==(const cauchy_distribution& __d1,
3186 const cauchy_distribution& __d2)
3187 { return __d1._M_param == __d2._M_param; }
3189 private:
3190 template<typename _ForwardIterator,
3191 typename _UniformRandomNumberGenerator>
3192 void
3193 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3194 _UniformRandomNumberGenerator& __urng,
3195 const param_type& __p);
3197 param_type _M_param;
3200 #if __cpp_impl_three_way_comparison < 201907L
3202 * @brief Return true if two Cauchy distributions have
3203 * different parameters.
3205 template<typename _RealType>
3206 inline bool
3207 operator!=(const std::cauchy_distribution<_RealType>& __d1,
3208 const std::cauchy_distribution<_RealType>& __d2)
3209 { return !(__d1 == __d2); }
3210 #endif
3213 * @brief Inserts a %cauchy_distribution random number distribution
3214 * @p __x into the output stream @p __os.
3216 * @param __os An output stream.
3217 * @param __x A %cauchy_distribution random number distribution.
3219 * @returns The output stream with the state of @p __x inserted or in
3220 * an error state.
3222 template<typename _RealType, typename _CharT, typename _Traits>
3223 std::basic_ostream<_CharT, _Traits>&
3224 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3225 const std::cauchy_distribution<_RealType>& __x);
3228 * @brief Extracts a %cauchy_distribution random number distribution
3229 * @p __x from the input stream @p __is.
3231 * @param __is An input stream.
3232 * @param __x A %cauchy_distribution random number
3233 * generator engine.
3235 * @returns The input stream with @p __x extracted or in an error state.
3237 template<typename _RealType, typename _CharT, typename _Traits>
3238 std::basic_istream<_CharT, _Traits>&
3239 operator>>(std::basic_istream<_CharT, _Traits>& __is,
3240 std::cauchy_distribution<_RealType>& __x);
3244 * @brief A fisher_f_distribution random number distribution.
3246 * The formula for the normal probability mass function is
3247 * @f[
3248 * p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
3249 * (\frac{m}{n})^{m/2} x^{(m/2)-1}
3250 * (1 + \frac{mx}{n})^{-(m+n)/2}
3251 * @f]
3253 * @headerfile random
3254 * @since C++11
3256 template<typename _RealType = double>
3257 class fisher_f_distribution
3259 static_assert(std::is_floating_point<_RealType>::value,
3260 "result_type must be a floating point type");
3262 public:
3263 /** The type of the range of the distribution. */
3264 typedef _RealType result_type;
3266 /** Parameter type. */
3267 struct param_type
3269 typedef fisher_f_distribution<_RealType> distribution_type;
3271 param_type() : param_type(1) { }
3273 explicit
3274 param_type(_RealType __m, _RealType __n = _RealType(1))
3275 : _M_m(__m), _M_n(__n)
3278 _RealType
3279 m() const
3280 { return _M_m; }
3282 _RealType
3283 n() const
3284 { return _M_n; }
3286 friend bool
3287 operator==(const param_type& __p1, const param_type& __p2)
3288 { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3290 #if __cpp_impl_three_way_comparison < 201907L
3291 friend bool
3292 operator!=(const param_type& __p1, const param_type& __p2)
3293 { return !(__p1 == __p2); }
3294 #endif
3296 private:
3297 _RealType _M_m;
3298 _RealType _M_n;
3301 fisher_f_distribution() : fisher_f_distribution(1.0) { }
3303 explicit
3304 fisher_f_distribution(_RealType __m,
3305 _RealType __n = _RealType(1))
3306 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3309 explicit
3310 fisher_f_distribution(const param_type& __p)
3311 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3315 * @brief Resets the distribution state.
3317 void
3318 reset()
3320 _M_gd_x.reset();
3321 _M_gd_y.reset();
3327 _RealType
3328 m() const
3329 { return _M_param.m(); }
3331 _RealType
3332 n() const
3333 { return _M_param.n(); }
3336 * @brief Returns the parameter set of the distribution.
3338 param_type
3339 param() const
3340 { return _M_param; }
3343 * @brief Sets the parameter set of the distribution.
3344 * @param __param The new parameter set of the distribution.
3346 void
3347 param(const param_type& __param)
3348 { _M_param = __param; }
3351 * @brief Returns the greatest lower bound value of the distribution.
3353 result_type
3354 min() const
3355 { return result_type(0); }
3358 * @brief Returns the least upper bound value of the distribution.
3360 result_type
3361 max() const
3362 { return std::numeric_limits<result_type>::max(); }
3365 * @brief Generating functions.
3367 template<typename _UniformRandomNumberGenerator>
3368 result_type
3369 operator()(_UniformRandomNumberGenerator& __urng)
3370 { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3372 template<typename _UniformRandomNumberGenerator>
3373 result_type
3374 operator()(_UniformRandomNumberGenerator& __urng,
3375 const param_type& __p)
3377 typedef typename std::gamma_distribution<result_type>::param_type
3378 param_type;
3379 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3380 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3383 template<typename _ForwardIterator,
3384 typename _UniformRandomNumberGenerator>
3385 void
3386 __generate(_ForwardIterator __f, _ForwardIterator __t,
3387 _UniformRandomNumberGenerator& __urng)
3388 { this->__generate_impl(__f, __t, __urng); }
3390 template<typename _ForwardIterator,
3391 typename _UniformRandomNumberGenerator>
3392 void
3393 __generate(_ForwardIterator __f, _ForwardIterator __t,
3394 _UniformRandomNumberGenerator& __urng,
3395 const param_type& __p)
3396 { this->__generate_impl(__f, __t, __urng, __p); }
3398 template<typename _UniformRandomNumberGenerator>
3399 void
3400 __generate(result_type* __f, result_type* __t,
3401 _UniformRandomNumberGenerator& __urng)
3402 { this->__generate_impl(__f, __t, __urng); }
3404 template<typename _UniformRandomNumberGenerator>
3405 void
3406 __generate(result_type* __f, result_type* __t,
3407 _UniformRandomNumberGenerator& __urng,
3408 const param_type& __p)
3409 { this->__generate_impl(__f, __t, __urng, __p); }
3412 * @brief Return true if two Fisher f distributions have
3413 * the same parameters and the sequences that would
3414 * be generated are equal.
3416 friend bool
3417 operator==(const fisher_f_distribution& __d1,
3418 const fisher_f_distribution& __d2)
3419 { return (__d1._M_param == __d2._M_param
3420 && __d1._M_gd_x == __d2._M_gd_x
3421 && __d1._M_gd_y == __d2._M_gd_y); }
3424 * @brief Inserts a %fisher_f_distribution random number distribution
3425 * @p __x into the output stream @p __os.
3427 * @param __os An output stream.
3428 * @param __x A %fisher_f_distribution random number distribution.
3430 * @returns The output stream with the state of @p __x inserted or in
3431 * an error state.
3433 template<typename _RealType1, typename _CharT, typename _Traits>
3434 friend std::basic_ostream<_CharT, _Traits>&
3435 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3436 const std::fisher_f_distribution<_RealType1>& __x);
3439 * @brief Extracts a %fisher_f_distribution random number distribution
3440 * @p __x from the input stream @p __is.
3442 * @param __is An input stream.
3443 * @param __x A %fisher_f_distribution random number
3444 * generator engine.
3446 * @returns The input stream with @p __x extracted or in an error state.
3448 template<typename _RealType1, typename _CharT, typename _Traits>
3449 friend std::basic_istream<_CharT, _Traits>&
3450 operator>>(std::basic_istream<_CharT, _Traits>& __is,
3451 std::fisher_f_distribution<_RealType1>& __x);
3453 private:
3454 template<typename _ForwardIterator,
3455 typename _UniformRandomNumberGenerator>
3456 void
3457 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3458 _UniformRandomNumberGenerator& __urng);
3460 template<typename _ForwardIterator,
3461 typename _UniformRandomNumberGenerator>
3462 void
3463 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3464 _UniformRandomNumberGenerator& __urng,
3465 const param_type& __p);
3467 param_type _M_param;
3469 std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
3472 #if __cpp_impl_three_way_comparison < 201907L
3474 * @brief Return true if two Fisher f distributions are different.
3476 template<typename _RealType>
3477 inline bool
3478 operator!=(const std::fisher_f_distribution<_RealType>& __d1,
3479 const std::fisher_f_distribution<_RealType>& __d2)
3480 { return !(__d1 == __d2); }
3481 #endif
3484 * @brief A student_t_distribution random number distribution.
3486 * The formula for the normal probability mass function is:
3487 * @f[
3488 * p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
3489 * (1 + \frac{x^2}{n}) ^{-(n+1)/2}
3490 * @f]
3492 * @headerfile random
3493 * @since C++11
3495 template<typename _RealType = double>
3496 class student_t_distribution
3498 static_assert(std::is_floating_point<_RealType>::value,
3499 "result_type must be a floating point type");
3501 public:
3502 /** The type of the range of the distribution. */
3503 typedef _RealType result_type;
3505 /** Parameter type. */
3506 struct param_type
3508 typedef student_t_distribution<_RealType> distribution_type;
3510 param_type() : param_type(1) { }
3512 explicit
3513 param_type(_RealType __n)
3514 : _M_n(__n)
3517 _RealType
3518 n() const
3519 { return _M_n; }
3521 friend bool
3522 operator==(const param_type& __p1, const param_type& __p2)
3523 { return __p1._M_n == __p2._M_n; }
3525 #if __cpp_impl_three_way_comparison < 201907L
3526 friend bool
3527 operator!=(const param_type& __p1, const param_type& __p2)
3528 { return !(__p1 == __p2); }
3529 #endif
3531 private:
3532 _RealType _M_n;
3535 student_t_distribution() : student_t_distribution(1.0) { }
3537 explicit
3538 student_t_distribution(_RealType __n)
3539 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3542 explicit
3543 student_t_distribution(const param_type& __p)
3544 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3548 * @brief Resets the distribution state.
3550 void
3551 reset()
3553 _M_nd.reset();
3554 _M_gd.reset();
3560 _RealType
3561 n() const
3562 { return _M_param.n(); }
3565 * @brief Returns the parameter set of the distribution.
3567 param_type
3568 param() const
3569 { return _M_param; }
3572 * @brief Sets the parameter set of the distribution.
3573 * @param __param The new parameter set of the distribution.
3575 void
3576 param(const param_type& __param)
3577 { _M_param = __param; }
3580 * @brief Returns the greatest lower bound value of the distribution.
3582 result_type
3583 min() const
3584 { return std::numeric_limits<result_type>::lowest(); }
3587 * @brief Returns the least upper bound value of the distribution.
3589 result_type
3590 max() const
3591 { return std::numeric_limits<result_type>::max(); }
3594 * @brief Generating functions.
3596 template<typename _UniformRandomNumberGenerator>
3597 result_type
3598 operator()(_UniformRandomNumberGenerator& __urng)
3599 { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
3601 template<typename _UniformRandomNumberGenerator>
3602 result_type
3603 operator()(_UniformRandomNumberGenerator& __urng,
3604 const param_type& __p)
3606 typedef typename std::gamma_distribution<result_type>::param_type
3607 param_type;
3609 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3610 return _M_nd(__urng) * std::sqrt(__p.n() / __g);
3613 template<typename _ForwardIterator,
3614 typename _UniformRandomNumberGenerator>
3615 void
3616 __generate(_ForwardIterator __f, _ForwardIterator __t,
3617 _UniformRandomNumberGenerator& __urng)
3618 { this->__generate_impl(__f, __t, __urng); }
3620 template<typename _ForwardIterator,
3621 typename _UniformRandomNumberGenerator>
3622 void
3623 __generate(_ForwardIterator __f, _ForwardIterator __t,
3624 _UniformRandomNumberGenerator& __urng,
3625 const param_type& __p)
3626 { this->__generate_impl(__f, __t, __urng, __p); }
3628 template<typename _UniformRandomNumberGenerator>
3629 void
3630 __generate(result_type* __f, result_type* __t,
3631 _UniformRandomNumberGenerator& __urng)
3632 { this->__generate_impl(__f, __t, __urng); }
3634 template<typename _UniformRandomNumberGenerator>
3635 void
3636 __generate(result_type* __f, result_type* __t,
3637 _UniformRandomNumberGenerator& __urng,
3638 const param_type& __p)
3639 { this->__generate_impl(__f, __t, __urng, __p); }
3642 * @brief Return true if two Student t distributions have
3643 * the same parameters and the sequences that would
3644 * be generated are equal.
3646 friend bool
3647 operator==(const student_t_distribution& __d1,
3648 const student_t_distribution& __d2)
3649 { return (__d1._M_param == __d2._M_param
3650 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3653 * @brief Inserts a %student_t_distribution random number distribution
3654 * @p __x into the output stream @p __os.
3656 * @param __os An output stream.
3657 * @param __x A %student_t_distribution random number distribution.
3659 * @returns The output stream with the state of @p __x inserted or in
3660 * an error state.
3662 template<typename _RealType1, typename _CharT, typename _Traits>
3663 friend std::basic_ostream<_CharT, _Traits>&
3664 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3665 const std::student_t_distribution<_RealType1>& __x);
3668 * @brief Extracts a %student_t_distribution random number distribution
3669 * @p __x from the input stream @p __is.
3671 * @param __is An input stream.
3672 * @param __x A %student_t_distribution random number
3673 * generator engine.
3675 * @returns The input stream with @p __x extracted or in an error state.
3677 template<typename _RealType1, typename _CharT, typename _Traits>
3678 friend std::basic_istream<_CharT, _Traits>&
3679 operator>>(std::basic_istream<_CharT, _Traits>& __is,
3680 std::student_t_distribution<_RealType1>& __x);
3682 private:
3683 template<typename _ForwardIterator,
3684 typename _UniformRandomNumberGenerator>
3685 void
3686 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3687 _UniformRandomNumberGenerator& __urng);
3688 template<typename _ForwardIterator,
3689 typename _UniformRandomNumberGenerator>
3690 void
3691 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3692 _UniformRandomNumberGenerator& __urng,
3693 const param_type& __p);
3695 param_type _M_param;
3697 std::normal_distribution<result_type> _M_nd;
3698 std::gamma_distribution<result_type> _M_gd;
3701 #if __cpp_impl_three_way_comparison < 201907L
3703 * @brief Return true if two Student t distributions are different.
3705 template<typename _RealType>
3706 inline bool
3707 operator!=(const std::student_t_distribution<_RealType>& __d1,
3708 const std::student_t_distribution<_RealType>& __d2)
3709 { return !(__d1 == __d2); }
3710 #endif
3712 /// @} group random_distributions_normal
3715 * @addtogroup random_distributions_bernoulli Bernoulli Distributions
3716 * @ingroup random_distributions
3717 * @{
3721 * @brief A Bernoulli random number distribution.
3723 * Generates a sequence of true and false values with likelihood @f$p@f$
3724 * that true will come up and @f$(1 - p)@f$ that false will appear.
3726 * @headerfile random
3727 * @since C++11
3729 class bernoulli_distribution
3731 public:
3732 /** The type of the range of the distribution. */
3733 typedef bool result_type;
3735 /** Parameter type. */
3736 struct param_type
3738 typedef bernoulli_distribution distribution_type;
3740 param_type() : param_type(0.5) { }
3742 explicit
3743 param_type(double __p)
3744 : _M_p(__p)
3746 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3749 double
3750 p() const
3751 { return _M_p; }
3753 friend bool
3754 operator==(const param_type& __p1, const param_type& __p2)
3755 { return __p1._M_p == __p2._M_p; }
3757 #if __cpp_impl_three_way_comparison < 201907L
3758 friend bool
3759 operator!=(const param_type& __p1, const param_type& __p2)
3760 { return !(__p1 == __p2); }
3761 #endif
3763 private:
3764 double _M_p;
3767 public:
3769 * @brief Constructs a Bernoulli distribution with likelihood 0.5.
3771 bernoulli_distribution() : bernoulli_distribution(0.5) { }
3774 * @brief Constructs a Bernoulli distribution with likelihood @p p.
3776 * @param __p [IN] The likelihood of a true result being returned.
3777 * Must be in the interval @f$[0, 1]@f$.
3779 explicit
3780 bernoulli_distribution(double __p)
3781 : _M_param(__p)
3784 explicit
3785 bernoulli_distribution(const param_type& __p)
3786 : _M_param(__p)
3790 * @brief Resets the distribution state.
3792 * Does nothing for a Bernoulli distribution.
3794 void
3795 reset() { }
3798 * @brief Returns the @p p parameter of the distribution.
3800 double
3801 p() const
3802 { return _M_param.p(); }
3805 * @brief Returns the parameter set of the distribution.
3807 param_type
3808 param() const
3809 { return _M_param; }
3812 * @brief Sets the parameter set of the distribution.
3813 * @param __param The new parameter set of the distribution.
3815 void
3816 param(const param_type& __param)
3817 { _M_param = __param; }
3820 * @brief Returns the greatest lower bound value of the distribution.
3822 result_type
3823 min() const
3824 { return std::numeric_limits<result_type>::min(); }
3827 * @brief Returns the least upper bound value of the distribution.
3829 result_type
3830 max() const
3831 { return std::numeric_limits<result_type>::max(); }
3834 * @brief Generating functions.
3836 template<typename _UniformRandomNumberGenerator>
3837 result_type
3838 operator()(_UniformRandomNumberGenerator& __urng)
3839 { return this->operator()(__urng, _M_param); }
3841 template<typename _UniformRandomNumberGenerator>
3842 result_type
3843 operator()(_UniformRandomNumberGenerator& __urng,
3844 const param_type& __p)
3846 __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3847 __aurng(__urng);
3848 if ((__aurng() - __aurng.min())
3849 < __p.p() * (__aurng.max() - __aurng.min()))
3850 return true;
3851 return false;
3854 template<typename _ForwardIterator,
3855 typename _UniformRandomNumberGenerator>
3856 void
3857 __generate(_ForwardIterator __f, _ForwardIterator __t,
3858 _UniformRandomNumberGenerator& __urng)
3859 { this->__generate(__f, __t, __urng, _M_param); }
3861 template<typename _ForwardIterator,
3862 typename _UniformRandomNumberGenerator>
3863 void
3864 __generate(_ForwardIterator __f, _ForwardIterator __t,
3865 _UniformRandomNumberGenerator& __urng, const param_type& __p)
3866 { this->__generate_impl(__f, __t, __urng, __p); }
3868 template<typename _UniformRandomNumberGenerator>
3869 void
3870 __generate(result_type* __f, result_type* __t,
3871 _UniformRandomNumberGenerator& __urng,
3872 const param_type& __p)
3873 { this->__generate_impl(__f, __t, __urng, __p); }
3876 * @brief Return true if two Bernoulli distributions have
3877 * the same parameters.
3879 friend bool
3880 operator==(const bernoulli_distribution& __d1,
3881 const bernoulli_distribution& __d2)
3882 { return __d1._M_param == __d2._M_param; }
3884 private:
3885 template<typename _ForwardIterator,
3886 typename _UniformRandomNumberGenerator>
3887 void
3888 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3889 _UniformRandomNumberGenerator& __urng,
3890 const param_type& __p);
3892 param_type _M_param;
3895 #if __cpp_impl_three_way_comparison < 201907L
3897 * @brief Return true if two Bernoulli distributions have
3898 * different parameters.
3900 inline bool
3901 operator!=(const std::bernoulli_distribution& __d1,
3902 const std::bernoulli_distribution& __d2)
3903 { return !(__d1 == __d2); }
3904 #endif
3907 * @brief Inserts a %bernoulli_distribution random number distribution
3908 * @p __x into the output stream @p __os.
3910 * @param __os An output stream.
3911 * @param __x A %bernoulli_distribution random number distribution.
3913 * @returns The output stream with the state of @p __x inserted or in
3914 * an error state.
3916 template<typename _CharT, typename _Traits>
3917 std::basic_ostream<_CharT, _Traits>&
3918 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3919 const std::bernoulli_distribution& __x);
3922 * @brief Extracts a %bernoulli_distribution random number distribution
3923 * @p __x from the input stream @p __is.
3925 * @param __is An input stream.
3926 * @param __x A %bernoulli_distribution random number generator engine.
3928 * @returns The input stream with @p __x extracted or in an error state.
3930 template<typename _CharT, typename _Traits>
3931 inline std::basic_istream<_CharT, _Traits>&
3932 operator>>(std::basic_istream<_CharT, _Traits>& __is,
3933 std::bernoulli_distribution& __x)
3935 double __p;
3936 if (__is >> __p)
3937 __x.param(bernoulli_distribution::param_type(__p));
3938 return __is;
3943 * @brief A discrete binomial random number distribution.
3945 * The formula for the binomial probability density function is
3946 * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
3947 * and @f$p@f$ are the parameters of the distribution.
3949 * @headerfile random
3950 * @since C++11
3952 template<typename _IntType = int>
3953 class binomial_distribution
3955 static_assert(std::is_integral<_IntType>::value,
3956 "result_type must be an integral type");
3958 public:
3959 /** The type of the range of the distribution. */
3960 typedef _IntType result_type;
3962 /** Parameter type. */
3963 struct param_type
3965 typedef binomial_distribution<_IntType> distribution_type;
3966 friend class binomial_distribution<_IntType>;
3968 param_type() : param_type(1) { }
3970 explicit
3971 param_type(_IntType __t, double __p = 0.5)
3972 : _M_t(__t), _M_p(__p)
3974 __glibcxx_assert((_M_t >= _IntType(0))
3975 && (_M_p >= 0.0)
3976 && (_M_p <= 1.0));
3977 _M_initialize();
3980 _IntType
3981 t() const
3982 { return _M_t; }
3984 double
3985 p() const
3986 { return _M_p; }
3988 friend bool
3989 operator==(const param_type& __p1, const param_type& __p2)
3990 { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3992 #if __cpp_impl_three_way_comparison < 201907L
3993 friend bool
3994 operator!=(const param_type& __p1, const param_type& __p2)
3995 { return !(__p1 == __p2); }
3996 #endif
3998 private:
3999 void
4000 _M_initialize();
4002 _IntType _M_t;
4003 double _M_p;
4005 double _M_q;
4006 #if _GLIBCXX_USE_C99_MATH_FUNCS
4007 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
4008 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
4009 #endif
4010 bool _M_easy;
4013 // constructors and member functions
4015 binomial_distribution() : binomial_distribution(1) { }
4017 explicit
4018 binomial_distribution(_IntType __t, double __p = 0.5)
4019 : _M_param(__t, __p), _M_nd()
4022 explicit
4023 binomial_distribution(const param_type& __p)
4024 : _M_param(__p), _M_nd()
4028 * @brief Resets the distribution state.
4030 void
4031 reset()
4032 { _M_nd.reset(); }
4035 * @brief Returns the distribution @p t parameter.
4037 _IntType
4038 t() const
4039 { return _M_param.t(); }
4042 * @brief Returns the distribution @p p parameter.
4044 double
4045 p() const
4046 { return _M_param.p(); }
4049 * @brief Returns the parameter set of the distribution.
4051 param_type
4052 param() const
4053 { return _M_param; }
4056 * @brief Sets the parameter set of the distribution.
4057 * @param __param The new parameter set of the distribution.
4059 void
4060 param(const param_type& __param)
4061 { _M_param = __param; }
4064 * @brief Returns the greatest lower bound value of the distribution.
4066 result_type
4067 min() const
4068 { return 0; }
4071 * @brief Returns the least upper bound value of the distribution.
4073 result_type
4074 max() const
4075 { return _M_param.t(); }
4078 * @brief Generating functions.
4080 template<typename _UniformRandomNumberGenerator>
4081 result_type
4082 operator()(_UniformRandomNumberGenerator& __urng)
4083 { return this->operator()(__urng, _M_param); }
4085 template<typename _UniformRandomNumberGenerator>
4086 result_type
4087 operator()(_UniformRandomNumberGenerator& __urng,
4088 const param_type& __p);
4090 template<typename _ForwardIterator,
4091 typename _UniformRandomNumberGenerator>
4092 void
4093 __generate(_ForwardIterator __f, _ForwardIterator __t,
4094 _UniformRandomNumberGenerator& __urng)
4095 { this->__generate(__f, __t, __urng, _M_param); }
4097 template<typename _ForwardIterator,
4098 typename _UniformRandomNumberGenerator>
4099 void
4100 __generate(_ForwardIterator __f, _ForwardIterator __t,
4101 _UniformRandomNumberGenerator& __urng,
4102 const param_type& __p)
4103 { this->__generate_impl(__f, __t, __urng, __p); }
4105 template<typename _UniformRandomNumberGenerator>
4106 void
4107 __generate(result_type* __f, result_type* __t,
4108 _UniformRandomNumberGenerator& __urng,
4109 const param_type& __p)
4110 { this->__generate_impl(__f, __t, __urng, __p); }
4113 * @brief Return true if two binomial distributions have
4114 * the same parameters and the sequences that would
4115 * be generated are equal.
4117 friend bool
4118 operator==(const binomial_distribution& __d1,
4119 const binomial_distribution& __d2)
4120 #ifdef _GLIBCXX_USE_C99_MATH_FUNCS
4121 { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4122 #else
4123 { return __d1._M_param == __d2._M_param; }
4124 #endif
4127 * @brief Inserts a %binomial_distribution random number distribution
4128 * @p __x into the output stream @p __os.
4130 * @param __os An output stream.
4131 * @param __x A %binomial_distribution random number distribution.
4133 * @returns The output stream with the state of @p __x inserted or in
4134 * an error state.
4136 template<typename _IntType1,
4137 typename _CharT, typename _Traits>
4138 friend std::basic_ostream<_CharT, _Traits>&
4139 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4140 const std::binomial_distribution<_IntType1>& __x);
4143 * @brief Extracts a %binomial_distribution random number distribution
4144 * @p __x from the input stream @p __is.
4146 * @param __is An input stream.
4147 * @param __x A %binomial_distribution random number generator engine.
4149 * @returns The input stream with @p __x extracted or in an error
4150 * state.
4152 template<typename _IntType1,
4153 typename _CharT, typename _Traits>
4154 friend std::basic_istream<_CharT, _Traits>&
4155 operator>>(std::basic_istream<_CharT, _Traits>& __is,
4156 std::binomial_distribution<_IntType1>& __x);
4158 private:
4159 template<typename _ForwardIterator,
4160 typename _UniformRandomNumberGenerator>
4161 void
4162 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4163 _UniformRandomNumberGenerator& __urng,
4164 const param_type& __p);
4166 template<typename _UniformRandomNumberGenerator>
4167 result_type
4168 _M_waiting(_UniformRandomNumberGenerator& __urng,
4169 _IntType __t, double __q);
4171 param_type _M_param;
4173 // NB: Unused when _GLIBCXX_USE_C99_MATH_FUNCS is undefined.
4174 std::normal_distribution<double> _M_nd;
4177 #if __cpp_impl_three_way_comparison < 201907L
4179 * @brief Return true if two binomial distributions are different.
4181 template<typename _IntType>
4182 inline bool
4183 operator!=(const std::binomial_distribution<_IntType>& __d1,
4184 const std::binomial_distribution<_IntType>& __d2)
4185 { return !(__d1 == __d2); }
4186 #endif
4189 * @brief A discrete geometric random number distribution.
4191 * The formula for the geometric probability density function is
4192 * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
4193 * distribution.
4195 * @headerfile random
4196 * @since C++11
4198 template<typename _IntType = int>
4199 class geometric_distribution
4201 static_assert(std::is_integral<_IntType>::value,
4202 "result_type must be an integral type");
4204 public:
4205 /** The type of the range of the distribution. */
4206 typedef _IntType result_type;
4208 /** Parameter type. */
4209 struct param_type
4211 typedef geometric_distribution<_IntType> distribution_type;
4212 friend class geometric_distribution<_IntType>;
4214 param_type() : param_type(0.5) { }
4216 explicit
4217 param_type(double __p)
4218 : _M_p(__p)
4220 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4221 _M_initialize();
4224 double
4225 p() const
4226 { return _M_p; }
4228 friend bool
4229 operator==(const param_type& __p1, const param_type& __p2)
4230 { return __p1._M_p == __p2._M_p; }
4232 #if __cpp_impl_three_way_comparison < 201907L
4233 friend bool
4234 operator!=(const param_type& __p1, const param_type& __p2)
4235 { return !(__p1 == __p2); }
4236 #endif
4238 private:
4239 void
4240 _M_initialize()
4241 { _M_log_1_p = std::log(1.0 - _M_p); }
4243 double _M_p;
4245 double _M_log_1_p;
4248 // constructors and member functions
4250 geometric_distribution() : geometric_distribution(0.5) { }
4252 explicit
4253 geometric_distribution(double __p)
4254 : _M_param(__p)
4257 explicit
4258 geometric_distribution(const param_type& __p)
4259 : _M_param(__p)
4263 * @brief Resets the distribution state.
4265 * Does nothing for the geometric distribution.
4267 void
4268 reset() { }
4271 * @brief Returns the distribution parameter @p p.
4273 double
4274 p() const
4275 { return _M_param.p(); }
4278 * @brief Returns the parameter set of the distribution.
4280 param_type
4281 param() const
4282 { return _M_param; }
4285 * @brief Sets the parameter set of the distribution.
4286 * @param __param The new parameter set of the distribution.
4288 void
4289 param(const param_type& __param)
4290 { _M_param = __param; }
4293 * @brief Returns the greatest lower bound value of the distribution.
4295 result_type
4296 min() const
4297 { return 0; }
4300 * @brief Returns the least upper bound value of the distribution.
4302 result_type
4303 max() const
4304 { return std::numeric_limits<result_type>::max(); }
4307 * @brief Generating functions.
4309 template<typename _UniformRandomNumberGenerator>
4310 result_type
4311 operator()(_UniformRandomNumberGenerator& __urng)
4312 { return this->operator()(__urng, _M_param); }
4314 template<typename _UniformRandomNumberGenerator>
4315 result_type
4316 operator()(_UniformRandomNumberGenerator& __urng,
4317 const param_type& __p);
4319 template<typename _ForwardIterator,
4320 typename _UniformRandomNumberGenerator>
4321 void
4322 __generate(_ForwardIterator __f, _ForwardIterator __t,
4323 _UniformRandomNumberGenerator& __urng)
4324 { this->__generate(__f, __t, __urng, _M_param); }
4326 template<typename _ForwardIterator,
4327 typename _UniformRandomNumberGenerator>
4328 void
4329 __generate(_ForwardIterator __f, _ForwardIterator __t,
4330 _UniformRandomNumberGenerator& __urng,
4331 const param_type& __p)
4332 { this->__generate_impl(__f, __t, __urng, __p); }
4334 template<typename _UniformRandomNumberGenerator>
4335 void
4336 __generate(result_type* __f, result_type* __t,
4337 _UniformRandomNumberGenerator& __urng,
4338 const param_type& __p)
4339 { this->__generate_impl(__f, __t, __urng, __p); }
4342 * @brief Return true if two geometric distributions have
4343 * the same parameters.
4345 friend bool
4346 operator==(const geometric_distribution& __d1,
4347 const geometric_distribution& __d2)
4348 { return __d1._M_param == __d2._M_param; }
4350 private:
4351 template<typename _ForwardIterator,
4352 typename _UniformRandomNumberGenerator>
4353 void
4354 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4355 _UniformRandomNumberGenerator& __urng,
4356 const param_type& __p);
4358 param_type _M_param;
4361 #if __cpp_impl_three_way_comparison < 201907L
4363 * @brief Return true if two geometric distributions have
4364 * different parameters.
4366 template<typename _IntType>
4367 inline bool
4368 operator!=(const std::geometric_distribution<_IntType>& __d1,
4369 const std::geometric_distribution<_IntType>& __d2)
4370 { return !(__d1 == __d2); }
4371 #endif
4374 * @brief Inserts a %geometric_distribution random number distribution
4375 * @p __x into the output stream @p __os.
4377 * @param __os An output stream.
4378 * @param __x A %geometric_distribution random number distribution.
4380 * @returns The output stream with the state of @p __x inserted or in
4381 * an error state.
4383 template<typename _IntType,
4384 typename _CharT, typename _Traits>
4385 std::basic_ostream<_CharT, _Traits>&
4386 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4387 const std::geometric_distribution<_IntType>& __x);
4390 * @brief Extracts a %geometric_distribution random number distribution
4391 * @p __x from the input stream @p __is.
4393 * @param __is An input stream.
4394 * @param __x A %geometric_distribution random number generator engine.
4396 * @returns The input stream with @p __x extracted or in an error state.
4398 template<typename _IntType,
4399 typename _CharT, typename _Traits>
4400 std::basic_istream<_CharT, _Traits>&
4401 operator>>(std::basic_istream<_CharT, _Traits>& __is,
4402 std::geometric_distribution<_IntType>& __x);
4406 * @brief A negative_binomial_distribution random number distribution.
4408 * The formula for the negative binomial probability mass function is
4409 * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
4410 * and @f$p@f$ are the parameters of the distribution.
4412 * @headerfile random
4413 * @since C++11
4415 template<typename _IntType = int>
4416 class negative_binomial_distribution
4418 static_assert(std::is_integral<_IntType>::value,
4419 "result_type must be an integral type");
4421 public:
4422 /** The type of the range of the distribution. */
4423 typedef _IntType result_type;
4425 /** Parameter type. */
4426 struct param_type
4428 typedef negative_binomial_distribution<_IntType> distribution_type;
4430 param_type() : param_type(1) { }
4432 explicit
4433 param_type(_IntType __k, double __p = 0.5)
4434 : _M_k(__k), _M_p(__p)
4436 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4439 _IntType
4440 k() const
4441 { return _M_k; }
4443 double
4444 p() const
4445 { return _M_p; }
4447 friend bool
4448 operator==(const param_type& __p1, const param_type& __p2)
4449 { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4451 #if __cpp_impl_three_way_comparison < 201907L
4452 friend bool
4453 operator!=(const param_type& __p1, const param_type& __p2)
4454 { return !(__p1 == __p2); }
4455 #endif
4457 private:
4458 _IntType _M_k;
4459 double _M_p;
4462 negative_binomial_distribution() : negative_binomial_distribution(1) { }
4464 explicit
4465 negative_binomial_distribution(_IntType __k, double __p = 0.5)
4466 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4469 explicit
4470 negative_binomial_distribution(const param_type& __p)
4471 : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
4475 * @brief Resets the distribution state.
4477 void
4478 reset()
4479 { _M_gd.reset(); }
4482 * @brief Return the @f$k@f$ parameter of the distribution.
4484 _IntType
4485 k() const
4486 { return _M_param.k(); }
4489 * @brief Return the @f$p@f$ parameter of the distribution.
4491 double
4492 p() const
4493 { return _M_param.p(); }
4496 * @brief Returns the parameter set of the distribution.
4498 param_type
4499 param() const
4500 { return _M_param; }
4503 * @brief Sets the parameter set of the distribution.
4504 * @param __param The new parameter set of the distribution.
4506 void
4507 param(const param_type& __param)
4508 { _M_param = __param; }
4511 * @brief Returns the greatest lower bound value of the distribution.
4513 result_type
4514 min() const
4515 { return result_type(0); }
4518 * @brief Returns the least upper bound value of the distribution.
4520 result_type
4521 max() const
4522 { return std::numeric_limits<result_type>::max(); }
4525 * @brief Generating functions.
4527 template<typename _UniformRandomNumberGenerator>
4528 result_type
4529 operator()(_UniformRandomNumberGenerator& __urng);
4531 template<typename _UniformRandomNumberGenerator>
4532 result_type
4533 operator()(_UniformRandomNumberGenerator& __urng,
4534 const param_type& __p);
4536 template<typename _ForwardIterator,
4537 typename _UniformRandomNumberGenerator>
4538 void
4539 __generate(_ForwardIterator __f, _ForwardIterator __t,
4540 _UniformRandomNumberGenerator& __urng)
4541 { this->__generate_impl(__f, __t, __urng); }
4543 template<typename _ForwardIterator,
4544 typename _UniformRandomNumberGenerator>
4545 void
4546 __generate(_ForwardIterator __f, _ForwardIterator __t,
4547 _UniformRandomNumberGenerator& __urng,
4548 const param_type& __p)
4549 { this->__generate_impl(__f, __t, __urng, __p); }
4551 template<typename _UniformRandomNumberGenerator>
4552 void
4553 __generate(result_type* __f, result_type* __t,
4554 _UniformRandomNumberGenerator& __urng)
4555 { this->__generate_impl(__f, __t, __urng); }
4557 template<typename _UniformRandomNumberGenerator>
4558 void
4559 __generate(result_type* __f, result_type* __t,
4560 _UniformRandomNumberGenerator& __urng,
4561 const param_type& __p)
4562 { this->__generate_impl(__f, __t, __urng, __p); }
4565 * @brief Return true if two negative binomial distributions have
4566 * the same parameters and the sequences that would be
4567 * generated are equal.
4569 friend bool
4570 operator==(const negative_binomial_distribution& __d1,
4571 const negative_binomial_distribution& __d2)
4572 { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4575 * @brief Inserts a %negative_binomial_distribution random
4576 * number distribution @p __x into the output stream @p __os.
4578 * @param __os An output stream.
4579 * @param __x A %negative_binomial_distribution random number
4580 * distribution.
4582 * @returns The output stream with the state of @p __x inserted or in
4583 * an error state.
4585 template<typename _IntType1, typename _CharT, typename _Traits>
4586 friend std::basic_ostream<_CharT, _Traits>&
4587 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4588 const std::negative_binomial_distribution<_IntType1>& __x);
4591 * @brief Extracts a %negative_binomial_distribution random number
4592 * distribution @p __x from the input stream @p __is.
4594 * @param __is An input stream.
4595 * @param __x A %negative_binomial_distribution random number
4596 * generator engine.
4598 * @returns The input stream with @p __x extracted or in an error state.
4600 template<typename _IntType1, typename _CharT, typename _Traits>
4601 friend std::basic_istream<_CharT, _Traits>&
4602 operator>>(std::basic_istream<_CharT, _Traits>& __is,
4603 std::negative_binomial_distribution<_IntType1>& __x);
4605 private:
4606 template<typename _ForwardIterator,
4607 typename _UniformRandomNumberGenerator>
4608 void
4609 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4610 _UniformRandomNumberGenerator& __urng);
4611 template<typename _ForwardIterator,
4612 typename _UniformRandomNumberGenerator>
4613 void
4614 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4615 _UniformRandomNumberGenerator& __urng,
4616 const param_type& __p);
4618 param_type _M_param;
4620 std::gamma_distribution<double> _M_gd;
4623 #if __cpp_impl_three_way_comparison < 201907L
4625 * @brief Return true if two negative binomial distributions are different.
4627 template<typename _IntType>
4628 inline bool
4629 operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
4630 const std::negative_binomial_distribution<_IntType>& __d2)
4631 { return !(__d1 == __d2); }
4632 #endif
4634 /// @} group random_distributions_bernoulli
4637 * @addtogroup random_distributions_poisson Poisson Distributions
4638 * @ingroup random_distributions
4639 * @{
4643 * @brief A discrete Poisson random number distribution.
4645 * The formula for the Poisson probability density function is
4646 * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
4647 * parameter of the distribution.
4649 * @headerfile random
4650 * @since C++11
4652 template<typename _IntType = int>
4653 class poisson_distribution
4655 static_assert(std::is_integral<_IntType>::value,
4656 "result_type must be an integral type");
4658 public:
4659 /** The type of the range of the distribution. */
4660 typedef _IntType result_type;
4662 /** Parameter type. */
4663 struct param_type
4665 typedef poisson_distribution<_IntType> distribution_type;
4666 friend class poisson_distribution<_IntType>;
4668 param_type() : param_type(1.0) { }
4670 explicit
4671 param_type(double __mean)
4672 : _M_mean(__mean)
4674 __glibcxx_assert(_M_mean > 0.0);
4675 _M_initialize();
4678 double
4679 mean() const
4680 { return _M_mean; }
4682 friend bool
4683 operator==(const param_type& __p1, const param_type& __p2)
4684 { return __p1._M_mean == __p2._M_mean; }
4686 #if __cpp_impl_three_way_comparison < 201907L
4687 friend bool
4688 operator!=(const param_type& __p1, const param_type& __p2)
4689 { return !(__p1 == __p2); }
4690 #endif
4692 private:
4693 // Hosts either log(mean) or the threshold of the simple method.
4694 void
4695 _M_initialize();
4697 double _M_mean;
4699 double _M_lm_thr;
4700 #if _GLIBCXX_USE_C99_MATH_FUNCS
4701 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4702 #endif
4705 // constructors and member functions
4707 poisson_distribution() : poisson_distribution(1.0) { }
4709 explicit
4710 poisson_distribution(double __mean)
4711 : _M_param(__mean), _M_nd()
4714 explicit
4715 poisson_distribution(const param_type& __p)
4716 : _M_param(__p), _M_nd()
4720 * @brief Resets the distribution state.
4722 void
4723 reset()
4724 { _M_nd.reset(); }
4727 * @brief Returns the distribution parameter @p mean.
4729 double
4730 mean() const
4731 { return _M_param.mean(); }
4734 * @brief Returns the parameter set of the distribution.
4736 param_type
4737 param() const
4738 { return _M_param; }
4741 * @brief Sets the parameter set of the distribution.
4742 * @param __param The new parameter set of the distribution.
4744 void
4745 param(const param_type& __param)
4746 { _M_param = __param; }
4749 * @brief Returns the greatest lower bound value of the distribution.
4751 result_type
4752 min() const
4753 { return 0; }
4756 * @brief Returns the least upper bound value of the distribution.
4758 result_type
4759 max() const
4760 { return std::numeric_limits<result_type>::max(); }
4763 * @brief Generating functions.
4765 template<typename _UniformRandomNumberGenerator>
4766 result_type
4767 operator()(_UniformRandomNumberGenerator& __urng)
4768 { return this->operator()(__urng, _M_param); }
4770 template<typename _UniformRandomNumberGenerator>
4771 result_type
4772 operator()(_UniformRandomNumberGenerator& __urng,
4773 const param_type& __p);
4775 template<typename _ForwardIterator,
4776 typename _UniformRandomNumberGenerator>
4777 void
4778 __generate(_ForwardIterator __f, _ForwardIterator __t,
4779 _UniformRandomNumberGenerator& __urng)
4780 { this->__generate(__f, __t, __urng, _M_param); }
4782 template<typename _ForwardIterator,
4783 typename _UniformRandomNumberGenerator>
4784 void
4785 __generate(_ForwardIterator __f, _ForwardIterator __t,
4786 _UniformRandomNumberGenerator& __urng,
4787 const param_type& __p)
4788 { this->__generate_impl(__f, __t, __urng, __p); }
4790 template<typename _UniformRandomNumberGenerator>
4791 void
4792 __generate(result_type* __f, result_type* __t,
4793 _UniformRandomNumberGenerator& __urng,
4794 const param_type& __p)
4795 { this->__generate_impl(__f, __t, __urng, __p); }
4798 * @brief Return true if two Poisson distributions have the same
4799 * parameters and the sequences that would be generated
4800 * are equal.
4802 friend bool
4803 operator==(const poisson_distribution& __d1,
4804 const poisson_distribution& __d2)
4805 #ifdef _GLIBCXX_USE_C99_MATH_FUNCS
4806 { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4807 #else
4808 { return __d1._M_param == __d2._M_param; }
4809 #endif
4812 * @brief Inserts a %poisson_distribution random number distribution
4813 * @p __x into the output stream @p __os.
4815 * @param __os An output stream.
4816 * @param __x A %poisson_distribution random number distribution.
4818 * @returns The output stream with the state of @p __x inserted or in
4819 * an error state.
4821 template<typename _IntType1, typename _CharT, typename _Traits>
4822 friend std::basic_ostream<_CharT, _Traits>&
4823 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4824 const std::poisson_distribution<_IntType1>& __x);
4827 * @brief Extracts a %poisson_distribution random number distribution
4828 * @p __x from the input stream @p __is.
4830 * @param __is An input stream.
4831 * @param __x A %poisson_distribution random number generator engine.
4833 * @returns The input stream with @p __x extracted or in an error
4834 * state.
4836 template<typename _IntType1, typename _CharT, typename _Traits>
4837 friend std::basic_istream<_CharT, _Traits>&
4838 operator>>(std::basic_istream<_CharT, _Traits>& __is,
4839 std::poisson_distribution<_IntType1>& __x);
4841 private:
4842 template<typename _ForwardIterator,
4843 typename _UniformRandomNumberGenerator>
4844 void
4845 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4846 _UniformRandomNumberGenerator& __urng,
4847 const param_type& __p);
4849 param_type _M_param;
4851 // NB: Unused when _GLIBCXX_USE_C99_MATH_FUNCS is undefined.
4852 std::normal_distribution<double> _M_nd;
4855 #if __cpp_impl_three_way_comparison < 201907L
4857 * @brief Return true if two Poisson distributions are different.
4859 template<typename _IntType>
4860 inline bool
4861 operator!=(const std::poisson_distribution<_IntType>& __d1,
4862 const std::poisson_distribution<_IntType>& __d2)
4863 { return !(__d1 == __d2); }
4864 #endif
4867 * @brief An exponential continuous distribution for random numbers.
4869 * The formula for the exponential probability density function is
4870 * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
4872 * <table border=1 cellpadding=10 cellspacing=0>
4873 * <caption align=top>Distribution Statistics</caption>
4874 * <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4875 * <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr>
4876 * <tr><td>Mode</td><td>@f$zero@f$</td></tr>
4877 * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
4878 * <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4879 * </table>
4881 * @headerfile random
4882 * @since C++11
4884 template<typename _RealType = double>
4885 class exponential_distribution
4887 static_assert(std::is_floating_point<_RealType>::value,
4888 "result_type must be a floating point type");
4890 public:
4891 /** The type of the range of the distribution. */
4892 typedef _RealType result_type;
4894 /** Parameter type. */
4895 struct param_type
4897 typedef exponential_distribution<_RealType> distribution_type;
4899 param_type() : param_type(1.0) { }
4901 explicit
4902 param_type(_RealType __lambda)
4903 : _M_lambda(__lambda)
4905 __glibcxx_assert(_M_lambda > _RealType(0));
4908 _RealType
4909 lambda() const
4910 { return _M_lambda; }
4912 friend bool
4913 operator==(const param_type& __p1, const param_type& __p2)
4914 { return __p1._M_lambda == __p2._M_lambda; }
4916 #if __cpp_impl_three_way_comparison < 201907L
4917 friend bool
4918 operator!=(const param_type& __p1, const param_type& __p2)
4919 { return !(__p1 == __p2); }
4920 #endif
4922 private:
4923 _RealType _M_lambda;
4926 public:
4928 * @brief Constructs an exponential distribution with inverse scale
4929 * parameter 1.0
4931 exponential_distribution() : exponential_distribution(1.0) { }
4934 * @brief Constructs an exponential distribution with inverse scale
4935 * parameter @f$\lambda@f$.
4937 explicit
4938 exponential_distribution(_RealType __lambda)
4939 : _M_param(__lambda)
4942 explicit
4943 exponential_distribution(const param_type& __p)
4944 : _M_param(__p)
4948 * @brief Resets the distribution state.
4950 * Has no effect on exponential distributions.
4952 void
4953 reset() { }
4956 * @brief Returns the inverse scale parameter of the distribution.
4958 _RealType
4959 lambda() const
4960 { return _M_param.lambda(); }
4963 * @brief Returns the parameter set of the distribution.
4965 param_type
4966 param() const
4967 { return _M_param; }
4970 * @brief Sets the parameter set of the distribution.
4971 * @param __param The new parameter set of the distribution.
4973 void
4974 param(const param_type& __param)
4975 { _M_param = __param; }
4978 * @brief Returns the greatest lower bound value of the distribution.
4980 result_type
4981 min() const
4982 { return result_type(0); }
4985 * @brief Returns the least upper bound value of the distribution.
4987 result_type
4988 max() const
4989 { return std::numeric_limits<result_type>::max(); }
4992 * @brief Generating functions.
4994 template<typename _UniformRandomNumberGenerator>
4995 result_type
4996 operator()(_UniformRandomNumberGenerator& __urng)
4997 { return this->operator()(__urng, _M_param); }
4999 template<typename _UniformRandomNumberGenerator>
5000 result_type
5001 operator()(_UniformRandomNumberGenerator& __urng,
5002 const param_type& __p)
5004 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
5005 __aurng(__urng);
5006 return -std::log(result_type(1) - __aurng()) / __p.lambda();
5009 template<typename _ForwardIterator,
5010 typename _UniformRandomNumberGenerator>
5011 void
5012 __generate(_ForwardIterator __f, _ForwardIterator __t,
5013 _UniformRandomNumberGenerator& __urng)
5014 { this->__generate(__f, __t, __urng, _M_param); }
5016 template<typename _ForwardIterator,
5017 typename _UniformRandomNumberGenerator>
5018 void
5019 __generate(_ForwardIterator __f, _ForwardIterator __t,
5020 _UniformRandomNumberGenerator& __urng,
5021 const param_type& __p)
5022 { this->__generate_impl(__f, __t, __urng, __p); }
5024 template<typename _UniformRandomNumberGenerator>
5025 void
5026 __generate(result_type* __f, result_type* __t,
5027 _UniformRandomNumberGenerator& __urng,
5028 const param_type& __p)
5029 { this->__generate_impl(__f, __t, __urng, __p); }
5032 * @brief Return true if two exponential distributions have the same
5033 * parameters.
5035 friend bool
5036 operator==(const exponential_distribution& __d1,
5037 const exponential_distribution& __d2)
5038 { return __d1._M_param == __d2._M_param; }
5040 private:
5041 template<typename _ForwardIterator,
5042 typename _UniformRandomNumberGenerator>
5043 void
5044 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5045 _UniformRandomNumberGenerator& __urng,
5046 const param_type& __p);
5048 param_type _M_param;
5051 #if __cpp_impl_three_way_comparison < 201907L
5053 * @brief Return true if two exponential distributions have different
5054 * parameters.
5056 template<typename _RealType>
5057 inline bool
5058 operator!=(const std::exponential_distribution<_RealType>& __d1,
5059 const std::exponential_distribution<_RealType>& __d2)
5060 { return !(__d1 == __d2); }
5061 #endif
5064 * @brief Inserts a %exponential_distribution random number distribution
5065 * @p __x into the output stream @p __os.
5067 * @param __os An output stream.
5068 * @param __x A %exponential_distribution random number distribution.
5070 * @returns The output stream with the state of @p __x inserted or in
5071 * an error state.
5073 template<typename _RealType, typename _CharT, typename _Traits>
5074 std::basic_ostream<_CharT, _Traits>&
5075 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5076 const std::exponential_distribution<_RealType>& __x);
5079 * @brief Extracts a %exponential_distribution random number distribution
5080 * @p __x from the input stream @p __is.
5082 * @param __is An input stream.
5083 * @param __x A %exponential_distribution random number
5084 * generator engine.
5086 * @returns The input stream with @p __x extracted or in an error state.
5088 template<typename _RealType, typename _CharT, typename _Traits>
5089 std::basic_istream<_CharT, _Traits>&
5090 operator>>(std::basic_istream<_CharT, _Traits>& __is,
5091 std::exponential_distribution<_RealType>& __x);
5095 * @brief A weibull_distribution random number distribution.
5097 * The formula for the normal probability density function is:
5098 * @f[
5099 * p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
5100 * \exp{(-(\frac{x}{\beta})^\alpha)}
5101 * @f]
5103 * @headerfile random
5104 * @since C++11
5106 template<typename _RealType = double>
5107 class weibull_distribution
5109 static_assert(std::is_floating_point<_RealType>::value,
5110 "result_type must be a floating point type");
5112 public:
5113 /** The type of the range of the distribution. */
5114 typedef _RealType result_type;
5116 /** Parameter type. */
5117 struct param_type
5119 typedef weibull_distribution<_RealType> distribution_type;
5121 param_type() : param_type(1.0) { }
5123 explicit
5124 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5125 : _M_a(__a), _M_b(__b)
5128 _RealType
5129 a() const
5130 { return _M_a; }
5132 _RealType
5133 b() const
5134 { return _M_b; }
5136 friend bool
5137 operator==(const param_type& __p1, const param_type& __p2)
5138 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5140 #if __cpp_impl_three_way_comparison < 201907L
5141 friend bool
5142 operator!=(const param_type& __p1, const param_type& __p2)
5143 { return !(__p1 == __p2); }
5144 #endif
5146 private:
5147 _RealType _M_a;
5148 _RealType _M_b;
5151 weibull_distribution() : weibull_distribution(1.0) { }
5153 explicit
5154 weibull_distribution(_RealType __a, _RealType __b = _RealType(1))
5155 : _M_param(__a, __b)
5158 explicit
5159 weibull_distribution(const param_type& __p)
5160 : _M_param(__p)
5164 * @brief Resets the distribution state.
5166 void
5167 reset()
5171 * @brief Return the @f$a@f$ parameter of the distribution.
5173 _RealType
5174 a() const
5175 { return _M_param.a(); }
5178 * @brief Return the @f$b@f$ parameter of the distribution.
5180 _RealType
5181 b() const
5182 { return _M_param.b(); }
5185 * @brief Returns the parameter set of the distribution.
5187 param_type
5188 param() const
5189 { return _M_param; }
5192 * @brief Sets the parameter set of the distribution.
5193 * @param __param The new parameter set of the distribution.
5195 void
5196 param(const param_type& __param)
5197 { _M_param = __param; }
5200 * @brief Returns the greatest lower bound value of the distribution.
5202 result_type
5203 min() const
5204 { return result_type(0); }
5207 * @brief Returns the least upper bound value of the distribution.
5209 result_type
5210 max() const
5211 { return std::numeric_limits<result_type>::max(); }
5214 * @brief Generating functions.
5216 template<typename _UniformRandomNumberGenerator>
5217 result_type
5218 operator()(_UniformRandomNumberGenerator& __urng)
5219 { return this->operator()(__urng, _M_param); }
5221 template<typename _UniformRandomNumberGenerator>
5222 result_type
5223 operator()(_UniformRandomNumberGenerator& __urng,
5224 const param_type& __p);
5226 template<typename _ForwardIterator,
5227 typename _UniformRandomNumberGenerator>
5228 void
5229 __generate(_ForwardIterator __f, _ForwardIterator __t,
5230 _UniformRandomNumberGenerator& __urng)
5231 { this->__generate(__f, __t, __urng, _M_param); }
5233 template<typename _ForwardIterator,
5234 typename _UniformRandomNumberGenerator>
5235 void
5236 __generate(_ForwardIterator __f, _ForwardIterator __t,
5237 _UniformRandomNumberGenerator& __urng,
5238 const param_type& __p)
5239 { this->__generate_impl(__f, __t, __urng, __p); }
5241 template<typename _UniformRandomNumberGenerator>
5242 void
5243 __generate(result_type* __f, result_type* __t,
5244 _UniformRandomNumberGenerator& __urng,
5245 const param_type& __p)
5246 { this->__generate_impl(__f, __t, __urng, __p); }
5249 * @brief Return true if two Weibull distributions have the same
5250 * parameters.
5252 friend bool
5253 operator==(const weibull_distribution& __d1,
5254 const weibull_distribution& __d2)
5255 { return __d1._M_param == __d2._M_param; }
5257 private:
5258 template<typename _ForwardIterator,
5259 typename _UniformRandomNumberGenerator>
5260 void
5261 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5262 _UniformRandomNumberGenerator& __urng,
5263 const param_type& __p);
5265 param_type _M_param;
5268 #if __cpp_impl_three_way_comparison < 201907L
5270 * @brief Return true if two Weibull distributions have different
5271 * parameters.
5273 template<typename _RealType>
5274 inline bool
5275 operator!=(const std::weibull_distribution<_RealType>& __d1,
5276 const std::weibull_distribution<_RealType>& __d2)
5277 { return !(__d1 == __d2); }
5278 #endif
5281 * @brief Inserts a %weibull_distribution random number distribution
5282 * @p __x into the output stream @p __os.
5284 * @param __os An output stream.
5285 * @param __x A %weibull_distribution random number distribution.
5287 * @returns The output stream with the state of @p __x inserted or in
5288 * an error state.
5290 template<typename _RealType, typename _CharT, typename _Traits>
5291 std::basic_ostream<_CharT, _Traits>&
5292 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5293 const std::weibull_distribution<_RealType>& __x);
5296 * @brief Extracts a %weibull_distribution random number distribution
5297 * @p __x from the input stream @p __is.
5299 * @param __is An input stream.
5300 * @param __x A %weibull_distribution random number
5301 * generator engine.
5303 * @returns The input stream with @p __x extracted or in an error state.
5305 template<typename _RealType, typename _CharT, typename _Traits>
5306 std::basic_istream<_CharT, _Traits>&
5307 operator>>(std::basic_istream<_CharT, _Traits>& __is,
5308 std::weibull_distribution<_RealType>& __x);
5312 * @brief A extreme_value_distribution random number distribution.
5314 * The formula for the normal probability mass function is
5315 * @f[
5316 * p(x|a,b) = \frac{1}{b}
5317 * \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
5318 * @f]
5320 * @headerfile random
5321 * @since C++11
5323 template<typename _RealType = double>
5324 class extreme_value_distribution
5326 static_assert(std::is_floating_point<_RealType>::value,
5327 "result_type must be a floating point type");
5329 public:
5330 /** The type of the range of the distribution. */
5331 typedef _RealType result_type;
5333 /** Parameter type. */
5334 struct param_type
5336 typedef extreme_value_distribution<_RealType> distribution_type;
5338 param_type() : param_type(0.0) { }
5340 explicit
5341 param_type(_RealType __a, _RealType __b = _RealType(1.0))
5342 : _M_a(__a), _M_b(__b)
5345 _RealType
5346 a() const
5347 { return _M_a; }
5349 _RealType
5350 b() const
5351 { return _M_b; }
5353 friend bool
5354 operator==(const param_type& __p1, const param_type& __p2)
5355 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5357 #if __cpp_impl_three_way_comparison < 201907L
5358 friend bool
5359 operator!=(const param_type& __p1, const param_type& __p2)
5360 { return !(__p1 == __p2); }
5361 #endif
5363 private:
5364 _RealType _M_a;
5365 _RealType _M_b;
5368 extreme_value_distribution() : extreme_value_distribution(0.0) { }
5370 explicit
5371 extreme_value_distribution(_RealType __a, _RealType __b = _RealType(1))
5372 : _M_param(__a, __b)
5375 explicit
5376 extreme_value_distribution(const param_type& __p)
5377 : _M_param(__p)
5381 * @brief Resets the distribution state.
5383 void
5384 reset()
5388 * @brief Return the @f$a@f$ parameter of the distribution.
5390 _RealType
5391 a() const
5392 { return _M_param.a(); }
5395 * @brief Return the @f$b@f$ parameter of the distribution.
5397 _RealType
5398 b() const
5399 { return _M_param.b(); }
5402 * @brief Returns the parameter set of the distribution.
5404 param_type
5405 param() const
5406 { return _M_param; }
5409 * @brief Sets the parameter set of the distribution.
5410 * @param __param The new parameter set of the distribution.
5412 void
5413 param(const param_type& __param)
5414 { _M_param = __param; }
5417 * @brief Returns the greatest lower bound value of the distribution.
5419 result_type
5420 min() const
5421 { return std::numeric_limits<result_type>::lowest(); }
5424 * @brief Returns the least upper bound value of the distribution.
5426 result_type
5427 max() const
5428 { return std::numeric_limits<result_type>::max(); }
5431 * @brief Generating functions.
5433 template<typename _UniformRandomNumberGenerator>
5434 result_type
5435 operator()(_UniformRandomNumberGenerator& __urng)
5436 { return this->operator()(__urng, _M_param); }
5438 template<typename _UniformRandomNumberGenerator>
5439 result_type
5440 operator()(_UniformRandomNumberGenerator& __urng,
5441 const param_type& __p);
5443 template<typename _ForwardIterator,
5444 typename _UniformRandomNumberGenerator>
5445 void
5446 __generate(_ForwardIterator __f, _ForwardIterator __t,
5447 _UniformRandomNumberGenerator& __urng)
5448 { this->__generate(__f, __t, __urng, _M_param); }
5450 template<typename _ForwardIterator,
5451 typename _UniformRandomNumberGenerator>
5452 void
5453 __generate(_ForwardIterator __f, _ForwardIterator __t,
5454 _UniformRandomNumberGenerator& __urng,
5455 const param_type& __p)
5456 { this->__generate_impl(__f, __t, __urng, __p); }
5458 template<typename _UniformRandomNumberGenerator>
5459 void
5460 __generate(result_type* __f, result_type* __t,
5461 _UniformRandomNumberGenerator& __urng,
5462 const param_type& __p)
5463 { this->__generate_impl(__f, __t, __urng, __p); }
5466 * @brief Return true if two extreme value distributions have the same
5467 * parameters.
5469 friend bool
5470 operator==(const extreme_value_distribution& __d1,
5471 const extreme_value_distribution& __d2)
5472 { return __d1._M_param == __d2._M_param; }
5474 private:
5475 template<typename _ForwardIterator,
5476 typename _UniformRandomNumberGenerator>
5477 void
5478 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5479 _UniformRandomNumberGenerator& __urng,
5480 const param_type& __p);
5482 param_type _M_param;
5485 #if __cpp_impl_three_way_comparison < 201907L
5487 * @brief Return true if two extreme value distributions have different
5488 * parameters.
5490 template<typename _RealType>
5491 inline bool
5492 operator!=(const std::extreme_value_distribution<_RealType>& __d1,
5493 const std::extreme_value_distribution<_RealType>& __d2)
5494 { return !(__d1 == __d2); }
5495 #endif
5498 * @brief Inserts a %extreme_value_distribution random number distribution
5499 * @p __x into the output stream @p __os.
5501 * @param __os An output stream.
5502 * @param __x A %extreme_value_distribution random number distribution.
5504 * @returns The output stream with the state of @p __x inserted or in
5505 * an error state.
5507 template<typename _RealType, typename _CharT, typename _Traits>
5508 std::basic_ostream<_CharT, _Traits>&
5509 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5510 const std::extreme_value_distribution<_RealType>& __x);
5513 * @brief Extracts a %extreme_value_distribution random number
5514 * distribution @p __x from the input stream @p __is.
5516 * @param __is An input stream.
5517 * @param __x A %extreme_value_distribution random number
5518 * generator engine.
5520 * @returns The input stream with @p __x extracted or in an error state.
5522 template<typename _RealType, typename _CharT, typename _Traits>
5523 std::basic_istream<_CharT, _Traits>&
5524 operator>>(std::basic_istream<_CharT, _Traits>& __is,
5525 std::extreme_value_distribution<_RealType>& __x);
5527 /// @} group random_distributions_poisson
5530 * @addtogroup random_distributions_sampling Sampling Distributions
5531 * @ingroup random_distributions
5532 * @{
5536 * @brief A discrete_distribution random number distribution.
5538 * This distribution produces random numbers @f$ i, 0 \leq i < n @f$,
5539 * distributed according to the probability mass function
5540 * @f$ p(i | p_0, ..., p_{n-1}) = p_i @f$.
5542 * @headerfile random
5543 * @since C++11
5545 template<typename _IntType = int>
5546 class discrete_distribution
5548 static_assert(std::is_integral<_IntType>::value,
5549 "result_type must be an integral type");
5551 public:
5552 /** The type of the range of the distribution. */
5553 typedef _IntType result_type;
5555 /** Parameter type. */
5556 struct param_type
5558 typedef discrete_distribution<_IntType> distribution_type;
5559 friend class discrete_distribution<_IntType>;
5561 param_type()
5562 : _M_prob(), _M_cp()
5565 template<typename _InputIterator>
5566 param_type(_InputIterator __wbegin,
5567 _InputIterator __wend)
5568 : _M_prob(__wbegin, __wend), _M_cp()
5569 { _M_initialize(); }
5571 param_type(initializer_list<double> __wil)
5572 : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5573 { _M_initialize(); }
5575 template<typename _Func>
5576 param_type(size_t __nw, double __xmin, double __xmax,
5577 _Func __fw);
5579 // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5580 param_type(const param_type&) = default;
5581 param_type& operator=(const param_type&) = default;
5583 std::vector<double>
5584 probabilities() const
5585 { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
5587 friend bool
5588 operator==(const param_type& __p1, const param_type& __p2)
5589 { return __p1._M_prob == __p2._M_prob; }
5591 #if __cpp_impl_three_way_comparison < 201907L
5592 friend bool
5593 operator!=(const param_type& __p1, const param_type& __p2)
5594 { return !(__p1 == __p2); }
5595 #endif
5597 private:
5598 void
5599 _M_initialize();
5601 std::vector<double> _M_prob;
5602 std::vector<double> _M_cp;
5605 discrete_distribution()
5606 : _M_param()
5609 template<typename _InputIterator>
5610 discrete_distribution(_InputIterator __wbegin,
5611 _InputIterator __wend)
5612 : _M_param(__wbegin, __wend)
5615 discrete_distribution(initializer_list<double> __wl)
5616 : _M_param(__wl)
5619 template<typename _Func>
5620 discrete_distribution(size_t __nw, double __xmin, double __xmax,
5621 _Func __fw)
5622 : _M_param(__nw, __xmin, __xmax, __fw)
5625 explicit
5626 discrete_distribution(const param_type& __p)
5627 : _M_param(__p)
5631 * @brief Resets the distribution state.
5633 void
5634 reset()
5638 * @brief Returns the probabilities of the distribution.
5640 std::vector<double>
5641 probabilities() const
5643 return _M_param._M_prob.empty()
5644 ? std::vector<double>(1, 1.0) : _M_param._M_prob;
5648 * @brief Returns the parameter set of the distribution.
5650 param_type
5651 param() const
5652 { return _M_param; }
5655 * @brief Sets the parameter set of the distribution.
5656 * @param __param The new parameter set of the distribution.
5658 void
5659 param(const param_type& __param)
5660 { _M_param = __param; }
5663 * @brief Returns the greatest lower bound value of the distribution.
5665 result_type
5666 min() const
5667 { return result_type(0); }
5670 * @brief Returns the least upper bound value of the distribution.
5672 result_type
5673 max() const
5675 return _M_param._M_prob.empty()
5676 ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
5680 * @brief Generating functions.
5682 template<typename _UniformRandomNumberGenerator>
5683 result_type
5684 operator()(_UniformRandomNumberGenerator& __urng)
5685 { return this->operator()(__urng, _M_param); }
5687 template<typename _UniformRandomNumberGenerator>
5688 result_type
5689 operator()(_UniformRandomNumberGenerator& __urng,
5690 const param_type& __p);
5692 template<typename _ForwardIterator,
5693 typename _UniformRandomNumberGenerator>
5694 void
5695 __generate(_ForwardIterator __f, _ForwardIterator __t,
5696 _UniformRandomNumberGenerator& __urng)
5697 { this->__generate(__f, __t, __urng, _M_param); }
5699 template<typename _ForwardIterator,
5700 typename _UniformRandomNumberGenerator>
5701 void
5702 __generate(_ForwardIterator __f, _ForwardIterator __t,
5703 _UniformRandomNumberGenerator& __urng,
5704 const param_type& __p)
5705 { this->__generate_impl(__f, __t, __urng, __p); }
5707 template<typename _UniformRandomNumberGenerator>
5708 void
5709 __generate(result_type* __f, result_type* __t,
5710 _UniformRandomNumberGenerator& __urng,
5711 const param_type& __p)
5712 { this->__generate_impl(__f, __t, __urng, __p); }
5715 * @brief Return true if two discrete distributions have the same
5716 * parameters.
5718 friend bool
5719 operator==(const discrete_distribution& __d1,
5720 const discrete_distribution& __d2)
5721 { return __d1._M_param == __d2._M_param; }
5724 * @brief Inserts a %discrete_distribution random number distribution
5725 * @p __x into the output stream @p __os.
5727 * @param __os An output stream.
5728 * @param __x A %discrete_distribution random number distribution.
5730 * @returns The output stream with the state of @p __x inserted or in
5731 * an error state.
5733 template<typename _IntType1, typename _CharT, typename _Traits>
5734 friend std::basic_ostream<_CharT, _Traits>&
5735 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5736 const std::discrete_distribution<_IntType1>& __x);
5739 * @brief Extracts a %discrete_distribution random number distribution
5740 * @p __x from the input stream @p __is.
5742 * @param __is An input stream.
5743 * @param __x A %discrete_distribution random number
5744 * generator engine.
5746 * @returns The input stream with @p __x extracted or in an error
5747 * state.
5749 template<typename _IntType1, typename _CharT, typename _Traits>
5750 friend std::basic_istream<_CharT, _Traits>&
5751 operator>>(std::basic_istream<_CharT, _Traits>& __is,
5752 std::discrete_distribution<_IntType1>& __x);
5754 private:
5755 template<typename _ForwardIterator,
5756 typename _UniformRandomNumberGenerator>
5757 void
5758 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5759 _UniformRandomNumberGenerator& __urng,
5760 const param_type& __p);
5762 param_type _M_param;
5765 #if __cpp_impl_three_way_comparison < 201907L
5767 * @brief Return true if two discrete distributions have different
5768 * parameters.
5770 template<typename _IntType>
5771 inline bool
5772 operator!=(const std::discrete_distribution<_IntType>& __d1,
5773 const std::discrete_distribution<_IntType>& __d2)
5774 { return !(__d1 == __d2); }
5775 #endif
5778 * @brief A piecewise_constant_distribution random number distribution.
5780 * This distribution produces random numbers @f$ x, b_0 \leq x < b_n @f$,
5781 * uniformly distributed over each subinterval @f$ [b_i, b_{i+1}) @f$
5782 * according to the probability mass function
5783 * @f[
5784 * p(x | b_0, ..., b_n, \rho_0, ..., \rho_{n-1})
5785 * = \rho_i \cdot \frac{b_{i+1} - x}{b_{i+1} - b_i}
5786 * + \rho_{i+1} \cdot \frac{ x - b_i}{b_{i+1} - b_i}
5787 * @f]
5788 * for @f$ b_i \leq x < b_{i+1} @f$.
5790 * @headerfile random
5791 * @since C++11
5793 template<typename _RealType = double>
5794 class piecewise_constant_distribution
5796 static_assert(std::is_floating_point<_RealType>::value,
5797 "result_type must be a floating point type");
5799 public:
5800 /** The type of the range of the distribution. */
5801 typedef _RealType result_type;
5803 /** Parameter type. */
5804 struct param_type
5806 typedef piecewise_constant_distribution<_RealType> distribution_type;
5807 friend class piecewise_constant_distribution<_RealType>;
5809 param_type()
5810 : _M_int(), _M_den(), _M_cp()
5813 template<typename _InputIteratorB, typename _InputIteratorW>
5814 param_type(_InputIteratorB __bfirst,
5815 _InputIteratorB __bend,
5816 _InputIteratorW __wbegin);
5818 template<typename _Func>
5819 param_type(initializer_list<_RealType> __bi, _Func __fw);
5821 template<typename _Func>
5822 param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
5823 _Func __fw);
5825 // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5826 param_type(const param_type&) = default;
5827 param_type& operator=(const param_type&) = default;
5829 std::vector<_RealType>
5830 intervals() const
5832 if (_M_int.empty())
5834 std::vector<_RealType> __tmp(2);
5835 __tmp[1] = _RealType(1);
5836 return __tmp;
5838 else
5839 return _M_int;
5842 std::vector<double>
5843 densities() const
5844 { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
5846 friend bool
5847 operator==(const param_type& __p1, const param_type& __p2)
5848 { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5850 #if __cpp_impl_three_way_comparison < 201907L
5851 friend bool
5852 operator!=(const param_type& __p1, const param_type& __p2)
5853 { return !(__p1 == __p2); }
5854 #endif
5856 private:
5857 void
5858 _M_initialize();
5860 std::vector<_RealType> _M_int;
5861 std::vector<double> _M_den;
5862 std::vector<double> _M_cp;
5865 piecewise_constant_distribution()
5866 : _M_param()
5869 template<typename _InputIteratorB, typename _InputIteratorW>
5870 piecewise_constant_distribution(_InputIteratorB __bfirst,
5871 _InputIteratorB __bend,
5872 _InputIteratorW __wbegin)
5873 : _M_param(__bfirst, __bend, __wbegin)
5876 template<typename _Func>
5877 piecewise_constant_distribution(initializer_list<_RealType> __bl,
5878 _Func __fw)
5879 : _M_param(__bl, __fw)
5882 template<typename _Func>
5883 piecewise_constant_distribution(size_t __nw,
5884 _RealType __xmin, _RealType __xmax,
5885 _Func __fw)
5886 : _M_param(__nw, __xmin, __xmax, __fw)
5889 explicit
5890 piecewise_constant_distribution(const param_type& __p)
5891 : _M_param(__p)
5895 * @brief Resets the distribution state.
5897 void
5898 reset()
5902 * @brief Returns a vector of the intervals.
5904 std::vector<_RealType>
5905 intervals() const
5907 if (_M_param._M_int.empty())
5909 std::vector<_RealType> __tmp(2);
5910 __tmp[1] = _RealType(1);
5911 return __tmp;
5913 else
5914 return _M_param._M_int;
5918 * @brief Returns a vector of the probability densities.
5920 std::vector<double>
5921 densities() const
5923 return _M_param._M_den.empty()
5924 ? std::vector<double>(1, 1.0) : _M_param._M_den;
5928 * @brief Returns the parameter set of the distribution.
5930 param_type
5931 param() const
5932 { return _M_param; }
5935 * @brief Sets the parameter set of the distribution.
5936 * @param __param The new parameter set of the distribution.
5938 void
5939 param(const param_type& __param)
5940 { _M_param = __param; }
5943 * @brief Returns the greatest lower bound value of the distribution.
5945 result_type
5946 min() const
5948 return _M_param._M_int.empty()
5949 ? result_type(0) : _M_param._M_int.front();
5953 * @brief Returns the least upper bound value of the distribution.
5955 result_type
5956 max() const
5958 return _M_param._M_int.empty()
5959 ? result_type(1) : _M_param._M_int.back();
5963 * @brief Generating functions.
5965 template<typename _UniformRandomNumberGenerator>
5966 result_type
5967 operator()(_UniformRandomNumberGenerator& __urng)
5968 { return this->operator()(__urng, _M_param); }
5970 template<typename _UniformRandomNumberGenerator>
5971 result_type
5972 operator()(_UniformRandomNumberGenerator& __urng,
5973 const param_type& __p);
5975 template<typename _ForwardIterator,
5976 typename _UniformRandomNumberGenerator>
5977 void
5978 __generate(_ForwardIterator __f, _ForwardIterator __t,
5979 _UniformRandomNumberGenerator& __urng)
5980 { this->__generate(__f, __t, __urng, _M_param); }
5982 template<typename _ForwardIterator,
5983 typename _UniformRandomNumberGenerator>
5984 void
5985 __generate(_ForwardIterator __f, _ForwardIterator __t,
5986 _UniformRandomNumberGenerator& __urng,
5987 const param_type& __p)
5988 { this->__generate_impl(__f, __t, __urng, __p); }
5990 template<typename _UniformRandomNumberGenerator>
5991 void
5992 __generate(result_type* __f, result_type* __t,
5993 _UniformRandomNumberGenerator& __urng,
5994 const param_type& __p)
5995 { this->__generate_impl(__f, __t, __urng, __p); }
5998 * @brief Return true if two piecewise constant distributions have the
5999 * same parameters.
6001 friend bool
6002 operator==(const piecewise_constant_distribution& __d1,
6003 const piecewise_constant_distribution& __d2)
6004 { return __d1._M_param == __d2._M_param; }
6007 * @brief Inserts a %piecewise_constant_distribution random
6008 * number distribution @p __x into the output stream @p __os.
6010 * @param __os An output stream.
6011 * @param __x A %piecewise_constant_distribution random number
6012 * distribution.
6014 * @returns The output stream with the state of @p __x inserted or in
6015 * an error state.
6017 template<typename _RealType1, typename _CharT, typename _Traits>
6018 friend std::basic_ostream<_CharT, _Traits>&
6019 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
6020 const std::piecewise_constant_distribution<_RealType1>& __x);
6023 * @brief Extracts a %piecewise_constant_distribution random
6024 * number distribution @p __x from the input stream @p __is.
6026 * @param __is An input stream.
6027 * @param __x A %piecewise_constant_distribution random number
6028 * generator engine.
6030 * @returns The input stream with @p __x extracted or in an error
6031 * state.
6033 template<typename _RealType1, typename _CharT, typename _Traits>
6034 friend std::basic_istream<_CharT, _Traits>&
6035 operator>>(std::basic_istream<_CharT, _Traits>& __is,
6036 std::piecewise_constant_distribution<_RealType1>& __x);
6038 private:
6039 template<typename _ForwardIterator,
6040 typename _UniformRandomNumberGenerator>
6041 void
6042 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6043 _UniformRandomNumberGenerator& __urng,
6044 const param_type& __p);
6046 param_type _M_param;
6049 #if __cpp_impl_three_way_comparison < 201907L
6051 * @brief Return true if two piecewise constant distributions have
6052 * different parameters.
6054 template<typename _RealType>
6055 inline bool
6056 operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
6057 const std::piecewise_constant_distribution<_RealType>& __d2)
6058 { return !(__d1 == __d2); }
6059 #endif
6062 * @brief A piecewise_linear_distribution random number distribution.
6064 * This distribution produces random numbers @f$ x, b_0 \leq x < b_n @f$,
6065 * distributed over each subinterval @f$ [b_i, b_{i+1}) @f$
6066 * according to the probability mass function
6067 * @f$ p(x | b_0, ..., b_n, \rho_0, ..., \rho_n) = \rho_i @f$,
6068 * for @f$ b_i \leq x < b_{i+1} @f$.
6070 * @headerfile random
6071 * @since C++11
6073 template<typename _RealType = double>
6074 class piecewise_linear_distribution
6076 static_assert(std::is_floating_point<_RealType>::value,
6077 "result_type must be a floating point type");
6079 public:
6080 /** The type of the range of the distribution. */
6081 typedef _RealType result_type;
6083 /** Parameter type. */
6084 struct param_type
6086 typedef piecewise_linear_distribution<_RealType> distribution_type;
6087 friend class piecewise_linear_distribution<_RealType>;
6089 param_type()
6090 : _M_int(), _M_den(), _M_cp(), _M_m()
6093 template<typename _InputIteratorB, typename _InputIteratorW>
6094 param_type(_InputIteratorB __bfirst,
6095 _InputIteratorB __bend,
6096 _InputIteratorW __wbegin);
6098 template<typename _Func>
6099 param_type(initializer_list<_RealType> __bl, _Func __fw);
6101 template<typename _Func>
6102 param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
6103 _Func __fw);
6105 // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
6106 param_type(const param_type&) = default;
6107 param_type& operator=(const param_type&) = default;
6109 std::vector<_RealType>
6110 intervals() const
6112 if (_M_int.empty())
6114 std::vector<_RealType> __tmp(2);
6115 __tmp[1] = _RealType(1);
6116 return __tmp;
6118 else
6119 return _M_int;
6122 std::vector<double>
6123 densities() const
6124 { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
6126 friend bool
6127 operator==(const param_type& __p1, const param_type& __p2)
6128 { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
6130 #if __cpp_impl_three_way_comparison < 201907L
6131 friend bool
6132 operator!=(const param_type& __p1, const param_type& __p2)
6133 { return !(__p1 == __p2); }
6134 #endif
6136 private:
6137 void
6138 _M_initialize();
6140 std::vector<_RealType> _M_int;
6141 std::vector<double> _M_den;
6142 std::vector<double> _M_cp;
6143 std::vector<double> _M_m;
6146 piecewise_linear_distribution()
6147 : _M_param()
6150 template<typename _InputIteratorB, typename _InputIteratorW>
6151 piecewise_linear_distribution(_InputIteratorB __bfirst,
6152 _InputIteratorB __bend,
6153 _InputIteratorW __wbegin)
6154 : _M_param(__bfirst, __bend, __wbegin)
6157 template<typename _Func>
6158 piecewise_linear_distribution(initializer_list<_RealType> __bl,
6159 _Func __fw)
6160 : _M_param(__bl, __fw)
6163 template<typename _Func>
6164 piecewise_linear_distribution(size_t __nw,
6165 _RealType __xmin, _RealType __xmax,
6166 _Func __fw)
6167 : _M_param(__nw, __xmin, __xmax, __fw)
6170 explicit
6171 piecewise_linear_distribution(const param_type& __p)
6172 : _M_param(__p)
6176 * Resets the distribution state.
6178 void
6179 reset()
6183 * @brief Return the intervals of the distribution.
6185 std::vector<_RealType>
6186 intervals() const
6188 if (_M_param._M_int.empty())
6190 std::vector<_RealType> __tmp(2);
6191 __tmp[1] = _RealType(1);
6192 return __tmp;
6194 else
6195 return _M_param._M_int;
6199 * @brief Return a vector of the probability densities of the
6200 * distribution.
6202 std::vector<double>
6203 densities() const
6205 return _M_param._M_den.empty()
6206 ? std::vector<double>(2, 1.0) : _M_param._M_den;
6210 * @brief Returns the parameter set of the distribution.
6212 param_type
6213 param() const
6214 { return _M_param; }
6217 * @brief Sets the parameter set of the distribution.
6218 * @param __param The new parameter set of the distribution.
6220 void
6221 param(const param_type& __param)
6222 { _M_param = __param; }
6225 * @brief Returns the greatest lower bound value of the distribution.
6227 result_type
6228 min() const
6230 return _M_param._M_int.empty()
6231 ? result_type(0) : _M_param._M_int.front();
6235 * @brief Returns the least upper bound value of the distribution.
6237 result_type
6238 max() const
6240 return _M_param._M_int.empty()
6241 ? result_type(1) : _M_param._M_int.back();
6245 * @brief Generating functions.
6247 template<typename _UniformRandomNumberGenerator>
6248 result_type
6249 operator()(_UniformRandomNumberGenerator& __urng)
6250 { return this->operator()(__urng, _M_param); }
6252 template<typename _UniformRandomNumberGenerator>
6253 result_type
6254 operator()(_UniformRandomNumberGenerator& __urng,
6255 const param_type& __p);
6257 template<typename _ForwardIterator,
6258 typename _UniformRandomNumberGenerator>
6259 void
6260 __generate(_ForwardIterator __f, _ForwardIterator __t,
6261 _UniformRandomNumberGenerator& __urng)
6262 { this->__generate(__f, __t, __urng, _M_param); }
6264 template<typename _ForwardIterator,
6265 typename _UniformRandomNumberGenerator>
6266 void
6267 __generate(_ForwardIterator __f, _ForwardIterator __t,
6268 _UniformRandomNumberGenerator& __urng,
6269 const param_type& __p)
6270 { this->__generate_impl(__f, __t, __urng, __p); }
6272 template<typename _UniformRandomNumberGenerator>
6273 void
6274 __generate(result_type* __f, result_type* __t,
6275 _UniformRandomNumberGenerator& __urng,
6276 const param_type& __p)
6277 { this->__generate_impl(__f, __t, __urng, __p); }
6280 * @brief Return true if two piecewise linear distributions have the
6281 * same parameters.
6283 friend bool
6284 operator==(const piecewise_linear_distribution& __d1,
6285 const piecewise_linear_distribution& __d2)
6286 { return __d1._M_param == __d2._M_param; }
6289 * @brief Inserts a %piecewise_linear_distribution random number
6290 * distribution @p __x into the output stream @p __os.
6292 * @param __os An output stream.
6293 * @param __x A %piecewise_linear_distribution random number
6294 * distribution.
6296 * @returns The output stream with the state of @p __x inserted or in
6297 * an error state.
6299 template<typename _RealType1, typename _CharT, typename _Traits>
6300 friend std::basic_ostream<_CharT, _Traits>&
6301 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
6302 const std::piecewise_linear_distribution<_RealType1>& __x);
6305 * @brief Extracts a %piecewise_linear_distribution random number
6306 * distribution @p __x from the input stream @p __is.
6308 * @param __is An input stream.
6309 * @param __x A %piecewise_linear_distribution random number
6310 * generator engine.
6312 * @returns The input stream with @p __x extracted or in an error
6313 * state.
6315 template<typename _RealType1, typename _CharT, typename _Traits>
6316 friend std::basic_istream<_CharT, _Traits>&
6317 operator>>(std::basic_istream<_CharT, _Traits>& __is,
6318 std::piecewise_linear_distribution<_RealType1>& __x);
6320 private:
6321 template<typename _ForwardIterator,
6322 typename _UniformRandomNumberGenerator>
6323 void
6324 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6325 _UniformRandomNumberGenerator& __urng,
6326 const param_type& __p);
6328 param_type _M_param;
6331 #if __cpp_impl_three_way_comparison < 201907L
6333 * @brief Return true if two piecewise linear distributions have
6334 * different parameters.
6336 template<typename _RealType>
6337 inline bool
6338 operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
6339 const std::piecewise_linear_distribution<_RealType>& __d2)
6340 { return !(__d1 == __d2); }
6341 #endif
6343 /// @} group random_distributions_sampling
6345 /// @} *group random_distributions
6348 * @addtogroup random_utilities Random Number Utilities
6349 * @ingroup random
6350 * @{
6354 * @brief The seed_seq class generates sequences of seeds for random
6355 * number generators.
6357 * @headerfile random
6358 * @since C++11
6360 class seed_seq
6362 public:
6363 /** The type of the seed vales. */
6364 typedef uint_least32_t result_type;
6366 /** Default constructor. */
6367 seed_seq() noexcept
6368 : _M_v()
6371 template<typename _IntType, typename = _Require<is_integral<_IntType>>>
6372 seed_seq(std::initializer_list<_IntType> __il);
6374 template<typename _InputIterator>
6375 seed_seq(_InputIterator __begin, _InputIterator __end);
6377 // generating functions
6378 template<typename _RandomAccessIterator>
6379 void
6380 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6382 // property functions
6383 size_t size() const noexcept
6384 { return _M_v.size(); }
6386 template<typename _OutputIterator>
6387 void
6388 param(_OutputIterator __dest) const
6389 { std::copy(_M_v.begin(), _M_v.end(), __dest); }
6391 // no copy functions
6392 seed_seq(const seed_seq&) = delete;
6393 seed_seq& operator=(const seed_seq&) = delete;
6395 private:
6396 std::vector<result_type> _M_v;
6399 /// @} group random_utilities
6401 /// @} group random
6403 _GLIBCXX_END_NAMESPACE_VERSION
6404 } // namespace std
6406 #endif