1 // random number generation -*- C++ -*-
3 // Copyright (C) 2009-2024 Free Software Foundation, Inc.
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)
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/>.
27 * This is an internal header file, included by other library headers.
28 * Do not attempt to use it directly. @headername{random}
35 #include <bits/uniform_int_dist.h>
37 namespace std
_GLIBCXX_VISIBILITY(default)
39 _GLIBCXX_BEGIN_NAMESPACE_VERSION
41 // [26.4] Random number generation
44 * @defgroup random Random Number Generation
47 * A facility for generating random numbers on selected distributions.
51 // std::uniform_random_bit_generator is defined in <bits/uniform_int_dist.h>
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
58 template<typename _RealType
, size_t __bits
,
59 typename _UniformRandomNumberGenerator
>
61 generate_canonical(_UniformRandomNumberGenerator
& __g
);
63 /// @cond undocumented
64 // Implementation-space details.
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
)>
74 { static constexpr _UIntType __value
= 0; };
76 template<typename _UIntType
, size_t __w
>
77 struct _Shift
<_UIntType
, __w
, true>
78 { static constexpr _UIntType __value
= _UIntType(1) << __w
; };
81 int __which
= ((__s
<= __CHAR_BIT__
* sizeof (int))
82 + (__s
<= __CHAR_BIT__
* sizeof (long))
83 + (__s
<= __CHAR_BIT__
* sizeof (long long))
84 /* assume long long no bigger than __int128 */
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");
93 struct _Select_uint_least_t
<__s
, 4>
94 { using type
= unsigned int; };
97 struct _Select_uint_least_t
<__s
, 3>
98 { using type
= unsigned long; };
101 struct _Select_uint_least_t
<__s
, 2>
102 { using type
= unsigned long long; };
104 #if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
106 struct _Select_uint_least_t
<__s
, 1>
107 { __extension__
using type
= unsigned __int128
; };
108 #elif __has_builtin(__builtin_add_overflow) \
109 && __has_builtin(__builtin_sub_overflow) \
110 && defined __UINT64_TYPE__
112 struct _Select_uint_least_t
<__s
, 1>
114 // This is NOT a general-purpose 128-bit integer type.
115 // It only supports (type(a) * x + c) % m as needed by __mod.
119 type(uint64_t __a
) noexcept
: _M_lo(__a
), _M_hi(0) { }
121 // pre: __l._M_hi == 0
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.
139 = (__l0x1
& __mask
) + (__l1x0
& __mask
) + (__l1x1
>> 32);
140 __l
._M_hi
= __l0x0
+ (__l0x1
>> 32) + (__l1x0
>> 32) + (__mid
>> 32);
141 __l
._M_lo
= (__mid
<< 32) + (__l1x1
& __mask
);
146 operator+(type __l
, uint64_t __c
) noexcept
148 __l
._M_hi
+= __builtin_add_overflow(__l
._M_lo
, __c
, &__l
._M_lo
);
153 operator%(type __l
, uint64_t __m
) noexcept
155 if (__builtin_expect(__l
._M_hi
== 0, 0))
161 int __shift
= __builtin_clzll(__m
) + 64
162 - __builtin_clzll(__l
._M_hi
);
166 __x
._M_hi
= __m
<< (__shift
- 64);
171 __x
._M_hi
= __m
>> (64 - __shift
);
172 __x
._M_lo
= __m
<< __shift
;
175 while (__l
._M_hi
!= 0 || __l
._M_lo
>= __m
)
179 __l
._M_hi
-= __x
._M_hi
;
180 __l
._M_hi
-= __builtin_sub_overflow(__l
._M_lo
, __x
._M_lo
,
183 __x
._M_lo
= (__x
._M_lo
>> 1) | (__x
._M_hi
<< 63);
189 // pre: __l._M_hi == 0
190 explicit operator uint64_t() const noexcept
193 friend bool operator<(const type
& __l
, const type
& __r
) noexcept
195 if (__l
._M_hi
< __r
._M_hi
)
197 else if (__l
._M_hi
== __r
._M_hi
)
198 return __l
._M_lo
< __r
._M_lo
;
203 friend bool operator<=(const type
& __l
, const type
& __r
) noexcept
204 { return !(__r
< __l
); }
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
>
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
);
230 template<typename _Tp
, _Tp __m
, _Tp __a
, _Tp __c
>
231 struct _Mod
<_Tp
, __m
, __a
, __c
, false, true>
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
>
246 _Tp __res
= __a
* __x
+ __c
;
253 template<typename _Tp
, _Tp __m
, _Tp __a
= 1, _Tp __c
= 0>
257 if constexpr (__a
== 0)
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
>
270 static_assert(std::is_floating_point
<_DInputType
>::value
,
271 "template argument must be a floating point type");
274 _Adaptor(_Engine
& __g
)
279 { return _DInputType(0); }
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
293 return std::generate_canonical
<_DInputType
,
294 std::numeric_limits
<_DInputType
>::digits
,
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
325 * @addtogroup random_generators Random Number Generators
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>
346 * @brief A model of a linear congruential random number generator.
348 * A random number generator that produces pseudorandom numbers via
351 * x_{i+1}\leftarrow(ax_{i} + c) \bmod m
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$.
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
>
375 = __detail::_If_seed_seq_for
<_Sseq
, linear_congruential_engine
,
379 /** The type of the generated random value. */
380 typedef _UIntType result_type
;
382 /** The multiplier. */
383 static constexpr result_type multiplier
= __a
;
385 static constexpr result_type increment
= __c
;
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
402 * @param __s The initial seed value.
405 linear_congruential_engine(result_type __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
>>
416 linear_congruential_engine(_Sseq
& __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.
426 seed(result_type __s
= default_seed
);
429 * @brief Reseeds the %linear_congruential_engine random number generator
431 * sequence using values from the seed sequence @p __q.
433 * @param __q the seed sequence.
435 template<typename _Sseq
>
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
447 { return __c
== 0u ? 1u : 0u; }
450 * @brief Gets the largest possible value in the output range.
452 static constexpr result_type
457 * @brief Discard a sequence of random numbers.
460 discard(unsigned long long __z
)
462 for (; __z
!= 0ULL; --__z
)
467 * @brief Gets the next random number in the sequence.
472 _M_x
= __detail::__mod
<_UIntType
, __m
, __a
, __c
>(_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
484 * @returns true if the infinite sequences of generated values
485 * would be equal, false otherwise.
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
496 * @param __os The output stream.
497 * @param __lcr A % linear_congruential_engine random number generator.
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
516 * @param __is The input stream.
517 * @param __lcr A % linear_congruential_engine random number generator.
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
,
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
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
>
545 operator!=(const std::linear_congruential_engine
<_UIntType
, __a
,
547 const std::linear_congruential_engine
<_UIntType
, __a
,
549 { return !(__lhs
== __rhs
); }
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
565 * @tparam __w Word size, the number of bits in each element of
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.
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 "
596 static_assert(__u
<= __w
, "template argument substituting "
598 static_assert(__s
<= __w
, "template argument substituting "
600 static_assert(__t
<= __w
, "template argument substituting "
602 static_assert(__l
<= __w
, "template argument substituting "
604 static_assert(__w
<= std::numeric_limits
<_UIntType
>::digits
,
605 "template argument substituting __w out of bound");
606 static_assert(__a
<= (__detail::_Shift
<_UIntType
, __w
>::__value
- 1),
607 "template argument substituting __a out of bound");
608 static_assert(__b
<= (__detail::_Shift
<_UIntType
, __w
>::__value
- 1),
609 "template argument substituting __b out of bound");
610 static_assert(__c
<= (__detail::_Shift
<_UIntType
, __w
>::__value
- 1),
611 "template argument substituting __c out of bound");
612 static_assert(__d
<= (__detail::_Shift
<_UIntType
, __w
>::__value
- 1),
613 "template argument substituting __d out of bound");
614 static_assert(__f
<= (__detail::_Shift
<_UIntType
, __w
>::__value
- 1),
615 "template argument substituting __f out of bound");
617 template<typename _Sseq
>
619 = __detail::_If_seed_seq_for
<_Sseq
, mersenne_twister_engine
,
623 /** The type of the generated random value. */
624 typedef _UIntType result_type
;
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
) { }
647 mersenne_twister_engine(result_type __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
>>
658 mersenne_twister_engine(_Sseq
& __q
)
662 seed(result_type __sd
= default_seed
);
664 template<typename _Sseq
>
669 * @brief Gets the smallest possible value in the output range.
671 static constexpr result_type
676 * @brief Gets the largest possible value in the output range.
678 static constexpr result_type
680 { return __detail::_Shift
<_UIntType
, __w
>::__value
- 1; }
683 * @brief Discard a sequence of random numbers.
686 discard(unsigned long long __z
);
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
697 * @param __rhs Another % mersenne_twister_engine random number
700 * @returns true if the infinite sequences of generated values
701 * would be equal, false otherwise.
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
714 * @param __os An output stream.
715 * @param __x A % mersenne_twister_engine random number generator
718 * @returns The output stream with the state of @p __x inserted or in
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
,
736 * @brief Extracts the current state of a % mersenne_twister_engine
737 * random number generator engine @p __x from the input stream
740 * @param __is An input stream.
741 * @param __x A % mersenne_twister_engine random number generator
744 * @returns The input stream with the state of @p __x extracted or in
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
,
764 _UIntType _M_x
[state_size
];
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
775 * @param __rhs Another % mersenne_twister_engine random number
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
>
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
); }
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
803 * x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m
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$.
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
,
819 static_assert(0u < __w
&& __w
<= std::numeric_limits
<_UIntType
>::digits
,
820 "template argument substituting __w out of bounds");
822 template<typename _Sseq
>
824 = __detail::_If_seed_seq_for
<_Sseq
, subtract_with_carry_engine
,
828 /** The type of the generated random value. */
829 typedef _UIntType result_type
;
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.
845 subtract_with_carry_engine(result_type __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
>>
856 subtract_with_carry_engine(_Sseq
& __q
)
860 * @brief Seeds the initial state @f$x_0@f$ of the random number
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.
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
>
883 * @brief Gets the inclusive minimum value of the range of random
884 * integers returned by this generator.
886 static constexpr result_type
891 * @brief Gets the inclusive maximum value of the range of random
892 * integers returned by this generator.
894 static constexpr result_type
896 { return __detail::_Shift
<_UIntType
, __w
>::__value
- 1; }
899 * @brief Discard a sequence of random numbers.
902 discard(unsigned long long __z
)
904 for (; __z
!= 0ULL; --__z
)
909 * @brief Gets the next random number in the sequence.
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
920 * @param __rhs Another % subtract_with_carry_engine random number
923 * @returns true if the infinite sequences of generated values
924 * would be equal, false otherwise.
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
938 * @param __os An output stream.
939 * @param __x A % subtract_with_carry_engine random number generator
942 * @returns The output stream with the state of @p __x inserted or in
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
,
953 * @brief Extracts the current state of a % subtract_with_carry_engine
954 * random number generator engine @p __x from the input stream
957 * @param __is An input stream.
958 * @param __x A % subtract_with_carry_engine random number generator
961 * @returns The input stream with the state of @p __x extracted or in
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
,
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
985 * @param __rhs Another % subtract_with_carry_engine random number
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
>
993 operator!=(const std::subtract_with_carry_engine
<_UIntType
, __w
,
995 const std::subtract_with_carry_engine
<_UIntType
, __w
,
997 { return !(__lhs
== __rhs
); }
1001 * Produces random numbers from some base engine by discarding blocks of
1004 * @pre @f$ 0 \leq r \leq p @f$
1006 * @headerfile random
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");
1016 /** The type of the generated random value. */
1017 typedef typename
_RandomNumberEngine::result_type result_type
;
1019 template<typename _Sseq
>
1021 = __detail::_If_seed_seq_for
<_Sseq
, discard_block_engine
,
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.
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.
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.
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
>>
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.
1089 * @brief Reseeds the %discard_block_engine object with the default
1090 * seed for the underlying base class generator engine.
1093 seed(result_type __s
)
1100 * @brief Reseeds the %discard_block_engine object with the given seed
1102 * @param __q A seed generator function.
1104 template<typename _Sseq
>
1113 * @brief Gets a const reference to the underlying generator engine
1116 const _RandomNumberEngine
&
1117 base() const noexcept
1121 * @brief Gets the minimum value in the generated random number range.
1123 static constexpr result_type
1125 { return _RandomNumberEngine::min(); }
1128 * @brief Gets the maximum value in the generated random number range.
1130 static constexpr result_type
1132 { return _RandomNumberEngine::max(); }
1135 * @brief Discard a sequence of random numbers.
1138 discard(unsigned long long __z
)
1140 for (; __z
!= 0ULL; --__z
)
1145 * @brief Gets the next value in the generated random number sequence.
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
1158 * @returns true if the infinite sequences of generated values
1159 * would be equal, false otherwise.
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
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
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
,
1185 * @brief Extracts the current state of a % subtract_with_carry_engine
1186 * random number generator engine @p __x from the input stream
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
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
,
1203 _RandomNumberEngine _M_b
;
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
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
>
1221 operator!=(const std::discard_block_engine
<_RandomNumberEngine
, __p
,
1223 const std::discard_block_engine
<_RandomNumberEngine
, __p
,
1225 { return !(__lhs
== __rhs
); }
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
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
>
1245 = __detail::_If_seed_seq_for
<_Sseq
, independent_bits_engine
,
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()
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.
1267 independent_bits_engine(const _RandomNumberEngine
& __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.
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.
1287 independent_bits_engine(result_type __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
>>
1297 independent_bits_engine(_Sseq
& __q
)
1302 * @brief Reseeds the %independent_bits_engine object with the default
1303 * seed for the underlying base class generator engine.
1310 * @brief Reseeds the %independent_bits_engine object with the default
1311 * seed for the underlying base class generator engine.
1314 seed(result_type __s
)
1318 * @brief Reseeds the %independent_bits_engine object with the given
1320 * @param __q A seed generator function.
1322 template<typename _Sseq
>
1328 * @brief Gets a const reference to the underlying generator engine
1331 const _RandomNumberEngine
&
1332 base() const noexcept
1336 * @brief Gets the minimum value in the generated random number range.
1338 static constexpr result_type
1343 * @brief Gets the maximum value in the generated random number range.
1345 static constexpr result_type
1347 { return __detail::_Shift
<_UIntType
, __w
>::__value
- 1; }
1350 * @brief Discard a sequence of random numbers.
1353 discard(unsigned long long __z
)
1355 for (; __z
!= 0ULL; --__z
)
1360 * @brief Gets the next value in the generated random number sequence.
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
1371 * @param __rhs Another %independent_bits_engine random number generator
1374 * @returns true if the infinite sequences of generated values
1375 * would be equal, false otherwise.
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
1387 * @param __is An input stream.
1388 * @param __x A %independent_bits_engine random number generator
1391 * @returns The input stream with the state of @p __x extracted or in
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
)
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
1415 * @param __rhs Another %independent_bits_engine random number generator
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
>
1423 operator!=(const std::independent_bits_engine
<_RandomNumberEngine
, __w
,
1425 const std::independent_bits_engine
<_RandomNumberEngine
, __w
,
1427 { return !(__lhs
== __rhs
); }
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
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
)
1453 * @brief Produces random numbers by reordering random numbers from some
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
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");
1469 /** The type of the generated random value. */
1470 typedef typename
_RandomNumberEngine::result_type result_type
;
1472 template<typename _Sseq
>
1474 = __detail::_If_seed_seq_for
<_Sseq
, shuffle_order_engine
,
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()
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.
1495 shuffle_order_engine(const _RandomNumberEngine
& __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.
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.
1517 shuffle_order_engine(result_type __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
>>
1528 shuffle_order_engine(_Sseq
& __q
)
1530 { _M_initialize(); }
1533 * @brief Reseeds the %shuffle_order_engine object with the default seed
1534 for the underlying base class generator engine.
1544 * @brief Reseeds the %shuffle_order_engine object with the default seed
1545 * for the underlying base class generator engine.
1548 seed(result_type __s
)
1555 * @brief Reseeds the %shuffle_order_engine object with the given seed
1557 * @param __q A seed generator function.
1559 template<typename _Sseq
>
1568 * Gets a const reference to the underlying generator engine object.
1570 const _RandomNumberEngine
&
1571 base() const noexcept
1575 * Gets the minimum value in the generated random number range.
1577 static constexpr result_type
1579 { return _RandomNumberEngine::min(); }
1582 * Gets the maximum value in the generated random number range.
1584 static constexpr result_type
1586 { return _RandomNumberEngine::max(); }
1589 * Discard a sequence of random numbers.
1592 discard(unsigned long long __z
)
1594 for (; __z
!= 0ULL; --__z
)
1599 * Gets the next value in the generated random number sequence.
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
1612 * @returns true if the infinite sequences of generated values
1613 * would be equal, false otherwise.
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
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
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
,
1641 * @brief Extracts the current state of a % subtract_with_carry_engine
1642 * random number generator engine @p __x from the input stream
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
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
);
1658 void _M_initialize()
1660 for (size_t __i
= 0; __i
< __k
; ++__i
)
1665 _RandomNumberEngine _M_b
;
1666 result_type _M_v
[__k
];
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
1679 * @returns true if the infinite sequences of generated values
1680 * would be different, false otherwise.
1682 template<typename _RandomNumberEngine
, size_t __k
>
1684 operator!=(const std::shuffle_order_engine
<_RandomNumberEngine
,
1686 const std::shuffle_order_engine
<_RandomNumberEngine
,
1688 { return !(__lhs
== __rhs
); }
1692 * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
1694 typedef linear_congruential_engine
<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1698 * An alternative LCR (Lehmer Generator function).
1700 typedef linear_congruential_engine
<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
1704 * The classic Mersenne Twister.
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
<
1717 0xefc60000UL
, 18, 1812433253UL> mt19937
;
1720 * An alternative Mersenne Twister.
1722 typedef mersenne_twister_engine
<
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>
1734 typedef subtract_with_carry_engine
<uint_fast64_t, 48, 5, 12>
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
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"); }
1763 random_device(const std::string
& __token
) { _M_init(__token
); }
1768 static constexpr result_type
1770 { return std::numeric_limits
<result_type
>::min(); }
1772 static constexpr result_type
1774 { return std::numeric_limits
<result_type
>::max(); }
1777 entropy() const noexcept
1778 { return this->_M_getentropy(); }
1782 { return this->_M_getval(); }
1784 // No copy functions.
1785 random_device(const random_device
&) = delete;
1786 void operator=(const random_device
&) = delete;
1790 void _M_init(const std::string
& __token
);
1791 void _M_init_pretr1(const std::string
& __token
);
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
1805 result_type (*_M_func
)(void*);
1812 /// @} group random_generators
1815 * @addtogroup random_distributions Random Number Distributions
1821 * @addtogroup random_distributions_uniform Uniform Distributions
1822 * @ingroup random_distributions
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
>
1835 operator!=(const std::uniform_int_distribution
<_IntType
>& __d1
,
1836 const std::uniform_int_distribution
<_IntType
>& __d2
)
1837 { return !(__d1
== __d2
); }
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
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
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");
1887 /** The type of the range of the distribution. */
1888 typedef _RealType result_type
;
1890 /** Parameter type. */
1893 typedef uniform_real_distribution
<_RealType
> distribution_type
;
1895 param_type() : param_type(0) { }
1898 param_type(_RealType __a
, _RealType __b
= _RealType(1))
1899 : _M_a(__a
), _M_b(__b
)
1901 __glibcxx_assert(_M_a
<= _M_b
);
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
1918 operator!=(const param_type
& __p1
, const param_type
& __p2
)
1919 { return !(__p1
== __p2
); }
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.
1942 uniform_real_distribution(_RealType __a
, _RealType __b
= _RealType(1))
1943 : _M_param(__a
, __b
)
1947 uniform_real_distribution(const param_type
& __p
)
1952 * @brief Resets the distribution state.
1954 * Does nothing for the uniform real distribution.
1961 { return _M_param
.a(); }
1965 { return _M_param
.b(); }
1968 * @brief Returns the parameter set of the distribution.
1972 { return _M_param
; }
1975 * @brief Sets the parameter set of the distribution.
1976 * @param __param The new parameter set of the distribution.
1979 param(const param_type
& __param
)
1980 { _M_param
= __param
; }
1983 * @brief Returns the inclusive lower bound of the distribution range.
1987 { return this->a(); }
1990 * @brief Returns the inclusive upper bound of the distribution range.
1994 { return this->b(); }
1997 * @brief Generating functions.
1999 template<typename _UniformRandomNumberGenerator
>
2001 operator()(_UniformRandomNumberGenerator
& __urng
)
2002 { return this->operator()(__urng
, _M_param
); }
2004 template<typename _UniformRandomNumberGenerator
>
2006 operator()(_UniformRandomNumberGenerator
& __urng
,
2007 const param_type
& __p
)
2009 __detail::_Adaptor
<_UniformRandomNumberGenerator
, result_type
>
2011 return (__aurng() * (__p
.b() - __p
.a())) + __p
.a();
2014 template<typename _ForwardIterator
,
2015 typename _UniformRandomNumberGenerator
>
2017 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2018 _UniformRandomNumberGenerator
& __urng
)
2019 { this->__generate(__f
, __t
, __urng
, _M_param
); }
2021 template<typename _ForwardIterator
,
2022 typename _UniformRandomNumberGenerator
>
2024 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2025 _UniformRandomNumberGenerator
& __urng
,
2026 const param_type
& __p
)
2027 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
2029 template<typename _UniformRandomNumberGenerator
>
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.
2041 operator==(const uniform_real_distribution
& __d1
,
2042 const uniform_real_distribution
& __d2
)
2043 { return __d1
._M_param
== __d2
._M_param
; }
2046 template<typename _ForwardIterator
,
2047 typename _UniformRandomNumberGenerator
>
2049 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
2050 _UniformRandomNumberGenerator
& __urng
,
2051 const param_type
& __p
);
2053 param_type _M_param
;
2056 #if __cpp_impl_three_way_comparison < 201907L
2058 * @brief Return true if two uniform real distributions have
2059 * different parameters.
2061 template<typename _IntType
>
2063 operator!=(const std::uniform_real_distribution
<_IntType
>& __d1
,
2064 const std::uniform_real_distribution
<_IntType
>& __d2
)
2065 { return !(__d1
== __d2
); }
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
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
2106 * @brief A normal continuous distribution for random numbers.
2108 * The formula for the normal probability density function is
2110 * p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
2111 * e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} }
2114 * @headerfile random
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");
2124 /** The type of the range of the distribution. */
2125 typedef _RealType result_type
;
2127 /** Parameter type. */
2130 typedef normal_distribution
<_RealType
> distribution_type
;
2132 param_type() : param_type(0.0) { }
2135 param_type(_RealType __mean
, _RealType __stddev
= _RealType(1))
2136 : _M_mean(__mean
), _M_stddev(__stddev
)
2138 __glibcxx_assert(_M_stddev
> _RealType(0));
2147 { return _M_stddev
; }
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
2156 operator!=(const param_type
& __p1
, const param_type
& __p2
)
2157 { return !(__p1
== __p2
); }
2162 _RealType _M_stddev
;
2166 normal_distribution() : normal_distribution(0.0) { }
2169 * Constructs a normal distribution with parameters @f$mean@f$ and
2170 * standard deviation.
2173 normal_distribution(result_type __mean
,
2174 result_type __stddev
= result_type(1))
2175 : _M_param(__mean
, __stddev
)
2179 normal_distribution(const param_type
& __p
)
2184 * @brief Resets the distribution state.
2188 { _M_saved_available
= false; }
2191 * @brief Returns the mean of the distribution.
2195 { return _M_param
.mean(); }
2198 * @brief Returns the standard deviation of the distribution.
2202 { return _M_param
.stddev(); }
2205 * @brief Returns the parameter set of the distribution.
2209 { return _M_param
; }
2212 * @brief Sets the parameter set of the distribution.
2213 * @param __param The new parameter set of the distribution.
2216 param(const param_type
& __param
)
2217 { _M_param
= __param
; }
2220 * @brief Returns the greatest lower bound value of the distribution.
2224 { return std::numeric_limits
<result_type
>::lowest(); }
2227 * @brief Returns the least upper bound value of the distribution.
2231 { return std::numeric_limits
<result_type
>::max(); }
2234 * @brief Generating functions.
2236 template<typename _UniformRandomNumberGenerator
>
2238 operator()(_UniformRandomNumberGenerator
& __urng
)
2239 { return this->operator()(__urng
, _M_param
); }
2241 template<typename _UniformRandomNumberGenerator
>
2243 operator()(_UniformRandomNumberGenerator
& __urng
,
2244 const param_type
& __p
);
2246 template<typename _ForwardIterator
,
2247 typename _UniformRandomNumberGenerator
>
2249 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2250 _UniformRandomNumberGenerator
& __urng
)
2251 { this->__generate(__f
, __t
, __urng
, _M_param
); }
2253 template<typename _ForwardIterator
,
2254 typename _UniformRandomNumberGenerator
>
2256 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2257 _UniformRandomNumberGenerator
& __urng
,
2258 const param_type
& __p
)
2259 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
2261 template<typename _UniformRandomNumberGenerator
>
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
>
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
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
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
);
2309 template<typename _ForwardIterator
,
2310 typename _UniformRandomNumberGenerator
>
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
>
2327 operator!=(const std::normal_distribution
<_RealType
>& __d1
,
2328 const std::normal_distribution
<_RealType
>& __d2
)
2329 { return !(__d1
== __d2
); }
2333 * @brief A lognormal_distribution random number distribution.
2335 * The formula for the normal probability mass function is
2337 * p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
2338 * \exp{-\frac{(\ln{x} - m)^2}{2s^2}}
2341 * @headerfile random
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");
2351 /** The type of the range of the distribution. */
2352 typedef _RealType result_type
;
2354 /** Parameter type. */
2357 typedef lognormal_distribution
<_RealType
> distribution_type
;
2359 param_type() : param_type(0.0) { }
2362 param_type(_RealType __m
, _RealType __s
= _RealType(1))
2363 : _M_m(__m
), _M_s(__s
)
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
2380 operator!=(const param_type
& __p1
, const param_type
& __p2
)
2381 { return !(__p1
== __p2
); }
2389 lognormal_distribution() : lognormal_distribution(0.0) { }
2392 lognormal_distribution(_RealType __m
, _RealType __s
= _RealType(1))
2393 : _M_param(__m
, __s
), _M_nd()
2397 lognormal_distribution(const param_type
& __p
)
2398 : _M_param(__p
), _M_nd()
2402 * Resets the distribution state.
2413 { return _M_param
.m(); }
2417 { return _M_param
.s(); }
2420 * @brief Returns the parameter set of the distribution.
2424 { return _M_param
; }
2427 * @brief Sets the parameter set of the distribution.
2428 * @param __param The new parameter set of the distribution.
2431 param(const param_type
& __param
)
2432 { _M_param
= __param
; }
2435 * @brief Returns the greatest lower bound value of the distribution.
2439 { return result_type(0); }
2442 * @brief Returns the least upper bound value of the distribution.
2446 { return std::numeric_limits
<result_type
>::max(); }
2449 * @brief Generating functions.
2451 template<typename _UniformRandomNumberGenerator
>
2453 operator()(_UniformRandomNumberGenerator
& __urng
)
2454 { return this->operator()(__urng
, _M_param
); }
2456 template<typename _UniformRandomNumberGenerator
>
2458 operator()(_UniformRandomNumberGenerator
& __urng
,
2459 const param_type
& __p
)
2460 { return std::exp(__p
.s() * _M_nd(__urng
) + __p
.m()); }
2462 template<typename _ForwardIterator
,
2463 typename _UniformRandomNumberGenerator
>
2465 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2466 _UniformRandomNumberGenerator
& __urng
)
2467 { this->__generate(__f
, __t
, __urng
, _M_param
); }
2469 template<typename _ForwardIterator
,
2470 typename _UniformRandomNumberGenerator
>
2472 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2473 _UniformRandomNumberGenerator
& __urng
,
2474 const param_type
& __p
)
2475 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
2477 template<typename _UniformRandomNumberGenerator
>
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.
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
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
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
);
2526 template<typename _ForwardIterator
,
2527 typename _UniformRandomNumberGenerator
>
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
>
2544 operator!=(const std::lognormal_distribution
<_RealType
>& __d1
,
2545 const std::lognormal_distribution
<_RealType
>& __d2
)
2546 { return !(__d1
== __d2
); }
2549 /// @} group random_distributions_normal
2552 * @addtogroup random_distributions_poisson Poisson Distributions
2553 * @ingroup random_distributions
2558 * @brief A gamma continuous distribution for random numbers.
2560 * The formula for the gamma probability density function is:
2562 * p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
2563 * (x/\beta)^{\alpha - 1} e^{-x/\beta}
2566 * @headerfile random
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");
2576 /** The type of the range of the distribution. */
2577 typedef _RealType result_type
;
2579 /** Parameter type. */
2582 typedef gamma_distribution
<_RealType
> distribution_type
;
2583 friend class gamma_distribution
<_RealType
>;
2585 param_type() : param_type(1.0) { }
2588 param_type(_RealType __alpha_val
, _RealType __beta_val
= _RealType(1))
2589 : _M_alpha(__alpha_val
), _M_beta(__beta_val
)
2591 __glibcxx_assert(_M_alpha
> _RealType(0));
2597 { return _M_alpha
; }
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
2610 operator!=(const param_type
& __p1
, const param_type
& __p2
)
2611 { return !(__p1
== __p2
); }
2621 _RealType _M_malpha
, _M_a2
;
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$.
2635 gamma_distribution(_RealType __alpha_val
,
2636 _RealType __beta_val
= _RealType(1))
2637 : _M_param(__alpha_val
, __beta_val
), _M_nd()
2641 gamma_distribution(const param_type
& __p
)
2642 : _M_param(__p
), _M_nd()
2646 * @brief Resets the distribution state.
2653 * @brief Returns the @f$\alpha@f$ of the distribution.
2657 { return _M_param
.alpha(); }
2660 * @brief Returns the @f$\beta@f$ of the distribution.
2664 { return _M_param
.beta(); }
2667 * @brief Returns the parameter set of the distribution.
2671 { return _M_param
; }
2674 * @brief Sets the parameter set of the distribution.
2675 * @param __param The new parameter set of the distribution.
2678 param(const param_type
& __param
)
2679 { _M_param
= __param
; }
2682 * @brief Returns the greatest lower bound value of the distribution.
2686 { return result_type(0); }
2689 * @brief Returns the least upper bound value of the distribution.
2693 { return std::numeric_limits
<result_type
>::max(); }
2696 * @brief Generating functions.
2698 template<typename _UniformRandomNumberGenerator
>
2700 operator()(_UniformRandomNumberGenerator
& __urng
)
2701 { return this->operator()(__urng
, _M_param
); }
2703 template<typename _UniformRandomNumberGenerator
>
2705 operator()(_UniformRandomNumberGenerator
& __urng
,
2706 const param_type
& __p
);
2708 template<typename _ForwardIterator
,
2709 typename _UniformRandomNumberGenerator
>
2711 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2712 _UniformRandomNumberGenerator
& __urng
)
2713 { this->__generate(__f
, __t
, __urng
, _M_param
); }
2715 template<typename _ForwardIterator
,
2716 typename _UniformRandomNumberGenerator
>
2718 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2719 _UniformRandomNumberGenerator
& __urng
,
2720 const param_type
& __p
)
2721 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
2723 template<typename _UniformRandomNumberGenerator
>
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
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
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
);
2771 template<typename _ForwardIterator
,
2772 typename _UniformRandomNumberGenerator
>
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
>
2789 operator!=(const std::gamma_distribution
<_RealType
>& __d1
,
2790 const std::gamma_distribution
<_RealType
>& __d2
)
2791 { return !(__d1
== __d2
); }
2794 /// @} group random_distributions_poisson
2797 * @addtogroup random_distributions_normal Normal Distributions
2798 * @ingroup random_distributions
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
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");
2818 /** The type of the range of the distribution. */
2819 typedef _RealType result_type
;
2821 /** Parameter type. */
2824 typedef chi_squared_distribution
<_RealType
> distribution_type
;
2826 param_type() : param_type(1) { }
2829 param_type(_RealType __n
)
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
2843 operator!=(const param_type
& __p1
, const param_type
& __p2
)
2844 { return !(__p1
== __p2
); }
2851 chi_squared_distribution() : chi_squared_distribution(1) { }
2854 chi_squared_distribution(_RealType __n
)
2855 : _M_param(__n
), _M_gd(__n
/ 2)
2859 chi_squared_distribution(const param_type
& __p
)
2860 : _M_param(__p
), _M_gd(__p
.n() / 2)
2864 * @brief Resets the distribution state.
2875 { return _M_param
.n(); }
2878 * @brief Returns the parameter set of the distribution.
2882 { return _M_param
; }
2885 * @brief Sets the parameter set of the distribution.
2886 * @param __param The new parameter set of the distribution.
2889 param(const param_type
& __param
)
2892 typedef typename
std::gamma_distribution
<result_type
>::param_type
2894 _M_gd
.param(param_type
{__param
.n() / 2});
2898 * @brief Returns the greatest lower bound value of the distribution.
2902 { return result_type(0); }
2905 * @brief Returns the least upper bound value of the distribution.
2909 { return std::numeric_limits
<result_type
>::max(); }
2912 * @brief Generating functions.
2914 template<typename _UniformRandomNumberGenerator
>
2916 operator()(_UniformRandomNumberGenerator
& __urng
)
2917 { return 2 * _M_gd(__urng
); }
2919 template<typename _UniformRandomNumberGenerator
>
2921 operator()(_UniformRandomNumberGenerator
& __urng
,
2922 const param_type
& __p
)
2924 typedef typename
std::gamma_distribution
<result_type
>::param_type
2926 return 2 * _M_gd(__urng
, param_type(__p
.n() / 2));
2929 template<typename _ForwardIterator
,
2930 typename _UniformRandomNumberGenerator
>
2932 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2933 _UniformRandomNumberGenerator
& __urng
)
2934 { this->__generate_impl(__f
, __t
, __urng
); }
2936 template<typename _ForwardIterator
,
2937 typename _UniformRandomNumberGenerator
>
2939 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
2940 _UniformRandomNumberGenerator
& __urng
,
2941 const param_type
& __p
)
2942 { typename
std::gamma_distribution
<result_type
>::param_type
2944 this->__generate_impl(__f
, __t
, __urng
, __p2
); }
2946 template<typename _UniformRandomNumberGenerator
>
2948 __generate(result_type
* __f
, result_type
* __t
,
2949 _UniformRandomNumberGenerator
& __urng
)
2950 { this->__generate_impl(__f
, __t
, __urng
); }
2952 template<typename _UniformRandomNumberGenerator
>
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
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.
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
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
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
);
3002 template<typename _ForwardIterator
,
3003 typename _UniformRandomNumberGenerator
>
3005 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3006 _UniformRandomNumberGenerator
& __urng
);
3008 template<typename _ForwardIterator
,
3009 typename _UniformRandomNumberGenerator
>
3011 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3012 _UniformRandomNumberGenerator
& __urng
,
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
>
3027 operator!=(const std::chi_squared_distribution
<_RealType
>& __d1
,
3028 const std::chi_squared_distribution
<_RealType
>& __d2
)
3029 { return !(__d1
== __d2
); }
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
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");
3048 /** The type of the range of the distribution. */
3049 typedef _RealType result_type
;
3051 /** Parameter type. */
3054 typedef cauchy_distribution
<_RealType
> distribution_type
;
3056 param_type() : param_type(0) { }
3059 param_type(_RealType __a
, _RealType __b
= _RealType(1))
3060 : _M_a(__a
), _M_b(__b
)
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
3077 operator!=(const param_type
& __p1
, const param_type
& __p2
)
3078 { return !(__p1
== __p2
); }
3086 cauchy_distribution() : cauchy_distribution(0.0) { }
3089 cauchy_distribution(_RealType __a
, _RealType __b
= 1.0)
3090 : _M_param(__a
, __b
)
3094 cauchy_distribution(const param_type
& __p
)
3099 * @brief Resets the distribution state.
3110 { return _M_param
.a(); }
3114 { return _M_param
.b(); }
3117 * @brief Returns the parameter set of the distribution.
3121 { return _M_param
; }
3124 * @brief Sets the parameter set of the distribution.
3125 * @param __param The new parameter set of the distribution.
3128 param(const param_type
& __param
)
3129 { _M_param
= __param
; }
3132 * @brief Returns the greatest lower bound value of the distribution.
3136 { return std::numeric_limits
<result_type
>::lowest(); }
3139 * @brief Returns the least upper bound value of the distribution.
3143 { return std::numeric_limits
<result_type
>::max(); }
3146 * @brief Generating functions.
3148 template<typename _UniformRandomNumberGenerator
>
3150 operator()(_UniformRandomNumberGenerator
& __urng
)
3151 { return this->operator()(__urng
, _M_param
); }
3153 template<typename _UniformRandomNumberGenerator
>
3155 operator()(_UniformRandomNumberGenerator
& __urng
,
3156 const param_type
& __p
);
3158 template<typename _ForwardIterator
,
3159 typename _UniformRandomNumberGenerator
>
3161 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3162 _UniformRandomNumberGenerator
& __urng
)
3163 { this->__generate(__f
, __t
, __urng
, _M_param
); }
3165 template<typename _ForwardIterator
,
3166 typename _UniformRandomNumberGenerator
>
3168 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3169 _UniformRandomNumberGenerator
& __urng
,
3170 const param_type
& __p
)
3171 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
3173 template<typename _UniformRandomNumberGenerator
>
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.
3185 operator==(const cauchy_distribution
& __d1
,
3186 const cauchy_distribution
& __d2
)
3187 { return __d1
._M_param
== __d2
._M_param
; }
3190 template<typename _ForwardIterator
,
3191 typename _UniformRandomNumberGenerator
>
3193 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3194 _UniformRandomNumberGenerator
& __urng
,
3195 const param_type
& __p
);
3197 param_type _M_param
;
3200 #if __cpp_impl_three_way_comparison < 201907L
3202 * @brief Return true if two Cauchy distributions have
3203 * different parameters.
3205 template<typename _RealType
>
3207 operator!=(const std::cauchy_distribution
<_RealType
>& __d1
,
3208 const std::cauchy_distribution
<_RealType
>& __d2
)
3209 { return !(__d1
== __d2
); }
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
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
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
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}
3253 * @headerfile random
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");
3263 /** The type of the range of the distribution. */
3264 typedef _RealType result_type
;
3266 /** Parameter type. */
3269 typedef fisher_f_distribution
<_RealType
> distribution_type
;
3271 param_type() : param_type(1) { }
3274 param_type(_RealType __m
, _RealType __n
= _RealType(1))
3275 : _M_m(__m
), _M_n(__n
)
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
3292 operator!=(const param_type
& __p1
, const param_type
& __p2
)
3293 { return !(__p1
== __p2
); }
3301 fisher_f_distribution() : fisher_f_distribution(1.0) { }
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)
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.
3329 { return _M_param
.m(); }
3333 { return _M_param
.n(); }
3336 * @brief Returns the parameter set of the distribution.
3340 { return _M_param
; }
3343 * @brief Sets the parameter set of the distribution.
3344 * @param __param The new parameter set of the distribution.
3347 param(const param_type
& __param
)
3348 { _M_param
= __param
; }
3351 * @brief Returns the greatest lower bound value of the distribution.
3355 { return result_type(0); }
3358 * @brief Returns the least upper bound value of the distribution.
3362 { return std::numeric_limits
<result_type
>::max(); }
3365 * @brief Generating functions.
3367 template<typename _UniformRandomNumberGenerator
>
3369 operator()(_UniformRandomNumberGenerator
& __urng
)
3370 { return (_M_gd_x(__urng
) * n()) / (_M_gd_y(__urng
) * m()); }
3372 template<typename _UniformRandomNumberGenerator
>
3374 operator()(_UniformRandomNumberGenerator
& __urng
,
3375 const param_type
& __p
)
3377 typedef typename
std::gamma_distribution
<result_type
>::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
>
3386 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3387 _UniformRandomNumberGenerator
& __urng
)
3388 { this->__generate_impl(__f
, __t
, __urng
); }
3390 template<typename _ForwardIterator
,
3391 typename _UniformRandomNumberGenerator
>
3393 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3394 _UniformRandomNumberGenerator
& __urng
,
3395 const param_type
& __p
)
3396 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
3398 template<typename _UniformRandomNumberGenerator
>
3400 __generate(result_type
* __f
, result_type
* __t
,
3401 _UniformRandomNumberGenerator
& __urng
)
3402 { this->__generate_impl(__f
, __t
, __urng
); }
3404 template<typename _UniformRandomNumberGenerator
>
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.
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
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
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
);
3454 template<typename _ForwardIterator
,
3455 typename _UniformRandomNumberGenerator
>
3457 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3458 _UniformRandomNumberGenerator
& __urng
);
3460 template<typename _ForwardIterator
,
3461 typename _UniformRandomNumberGenerator
>
3463 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3464 _UniformRandomNumberGenerator
& __urng
,
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
>
3478 operator!=(const std::fisher_f_distribution
<_RealType
>& __d1
,
3479 const std::fisher_f_distribution
<_RealType
>& __d2
)
3480 { return !(__d1
== __d2
); }
3484 * @brief A student_t_distribution random number distribution.
3486 * The formula for the normal probability mass function is:
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}
3492 * @headerfile random
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");
3502 /** The type of the range of the distribution. */
3503 typedef _RealType result_type
;
3505 /** Parameter type. */
3508 typedef student_t_distribution
<_RealType
> distribution_type
;
3510 param_type() : param_type(1) { }
3513 param_type(_RealType __n
)
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
3527 operator!=(const param_type
& __p1
, const param_type
& __p2
)
3528 { return !(__p1
== __p2
); }
3535 student_t_distribution() : student_t_distribution(1.0) { }
3538 student_t_distribution(_RealType __n
)
3539 : _M_param(__n
), _M_nd(), _M_gd(__n
/ 2, 2)
3543 student_t_distribution(const param_type
& __p
)
3544 : _M_param(__p
), _M_nd(), _M_gd(__p
.n() / 2, 2)
3548 * @brief Resets the distribution state.
3562 { return _M_param
.n(); }
3565 * @brief Returns the parameter set of the distribution.
3569 { return _M_param
; }
3572 * @brief Sets the parameter set of the distribution.
3573 * @param __param The new parameter set of the distribution.
3576 param(const param_type
& __param
)
3577 { _M_param
= __param
; }
3580 * @brief Returns the greatest lower bound value of the distribution.
3584 { return std::numeric_limits
<result_type
>::lowest(); }
3587 * @brief Returns the least upper bound value of the distribution.
3591 { return std::numeric_limits
<result_type
>::max(); }
3594 * @brief Generating functions.
3596 template<typename _UniformRandomNumberGenerator
>
3598 operator()(_UniformRandomNumberGenerator
& __urng
)
3599 { return _M_nd(__urng
) * std::sqrt(n() / _M_gd(__urng
)); }
3601 template<typename _UniformRandomNumberGenerator
>
3603 operator()(_UniformRandomNumberGenerator
& __urng
,
3604 const param_type
& __p
)
3606 typedef typename
std::gamma_distribution
<result_type
>::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
>
3616 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3617 _UniformRandomNumberGenerator
& __urng
)
3618 { this->__generate_impl(__f
, __t
, __urng
); }
3620 template<typename _ForwardIterator
,
3621 typename _UniformRandomNumberGenerator
>
3623 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3624 _UniformRandomNumberGenerator
& __urng
,
3625 const param_type
& __p
)
3626 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
3628 template<typename _UniformRandomNumberGenerator
>
3630 __generate(result_type
* __f
, result_type
* __t
,
3631 _UniformRandomNumberGenerator
& __urng
)
3632 { this->__generate_impl(__f
, __t
, __urng
); }
3634 template<typename _UniformRandomNumberGenerator
>
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.
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
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
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
);
3683 template<typename _ForwardIterator
,
3684 typename _UniformRandomNumberGenerator
>
3686 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3687 _UniformRandomNumberGenerator
& __urng
);
3688 template<typename _ForwardIterator
,
3689 typename _UniformRandomNumberGenerator
>
3691 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3692 _UniformRandomNumberGenerator
& __urng
,
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
>
3707 operator!=(const std::student_t_distribution
<_RealType
>& __d1
,
3708 const std::student_t_distribution
<_RealType
>& __d2
)
3709 { return !(__d1
== __d2
); }
3712 /// @} group random_distributions_normal
3715 * @addtogroup random_distributions_bernoulli Bernoulli Distributions
3716 * @ingroup random_distributions
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
3729 class bernoulli_distribution
3732 /** The type of the range of the distribution. */
3733 typedef bool result_type
;
3735 /** Parameter type. */
3738 typedef bernoulli_distribution distribution_type
;
3740 param_type() : param_type(0.5) { }
3743 param_type(double __p
)
3746 __glibcxx_assert((_M_p
>= 0.0) && (_M_p
<= 1.0));
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
3759 operator!=(const param_type
& __p1
, const param_type
& __p2
)
3760 { return !(__p1
== __p2
); }
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$.
3780 bernoulli_distribution(double __p
)
3785 bernoulli_distribution(const param_type
& __p
)
3790 * @brief Resets the distribution state.
3792 * Does nothing for a Bernoulli distribution.
3798 * @brief Returns the @p p parameter of the distribution.
3802 { return _M_param
.p(); }
3805 * @brief Returns the parameter set of the distribution.
3809 { return _M_param
; }
3812 * @brief Sets the parameter set of the distribution.
3813 * @param __param The new parameter set of the distribution.
3816 param(const param_type
& __param
)
3817 { _M_param
= __param
; }
3820 * @brief Returns the greatest lower bound value of the distribution.
3824 { return std::numeric_limits
<result_type
>::min(); }
3827 * @brief Returns the least upper bound value of the distribution.
3831 { return std::numeric_limits
<result_type
>::max(); }
3834 * @brief Generating functions.
3836 template<typename _UniformRandomNumberGenerator
>
3838 operator()(_UniformRandomNumberGenerator
& __urng
)
3839 { return this->operator()(__urng
, _M_param
); }
3841 template<typename _UniformRandomNumberGenerator
>
3843 operator()(_UniformRandomNumberGenerator
& __urng
,
3844 const param_type
& __p
)
3846 __detail::_Adaptor
<_UniformRandomNumberGenerator
, double>
3848 if ((__aurng() - __aurng
.min())
3849 < __p
.p() * (__aurng
.max() - __aurng
.min()))
3854 template<typename _ForwardIterator
,
3855 typename _UniformRandomNumberGenerator
>
3857 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3858 _UniformRandomNumberGenerator
& __urng
)
3859 { this->__generate(__f
, __t
, __urng
, _M_param
); }
3861 template<typename _ForwardIterator
,
3862 typename _UniformRandomNumberGenerator
>
3864 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
3865 _UniformRandomNumberGenerator
& __urng
, const param_type
& __p
)
3866 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
3868 template<typename _UniformRandomNumberGenerator
>
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.
3880 operator==(const bernoulli_distribution
& __d1
,
3881 const bernoulli_distribution
& __d2
)
3882 { return __d1
._M_param
== __d2
._M_param
; }
3885 template<typename _ForwardIterator
,
3886 typename _UniformRandomNumberGenerator
>
3888 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
3889 _UniformRandomNumberGenerator
& __urng
,
3890 const param_type
& __p
);
3892 param_type _M_param
;
3895 #if __cpp_impl_three_way_comparison < 201907L
3897 * @brief Return true if two Bernoulli distributions have
3898 * different parameters.
3901 operator!=(const std::bernoulli_distribution
& __d1
,
3902 const std::bernoulli_distribution
& __d2
)
3903 { return !(__d1
== __d2
); }
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
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
)
3937 __x
.param(bernoulli_distribution::param_type(__p
));
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
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");
3959 /** The type of the range of the distribution. */
3960 typedef _IntType result_type
;
3962 /** Parameter type. */
3965 typedef binomial_distribution
<_IntType
> distribution_type
;
3966 friend class binomial_distribution
<_IntType
>;
3968 param_type() : param_type(1) { }
3971 param_type(_IntType __t
, double __p
= 0.5)
3972 : _M_t(__t
), _M_p(__p
)
3974 __glibcxx_assert((_M_t
>= _IntType(0))
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
3994 operator!=(const param_type
& __p1
, const param_type
& __p2
)
3995 { return !(__p1
== __p2
); }
4006 #if _GLIBCXX_USE_C99_MATH_FUNCS
4007 double _M_d1
, _M_d2
, _M_s1
, _M_s2
, _M_c
,
4008 _M_a1
, _M_a123
, _M_s
, _M_lf
, _M_lp1p
;
4013 // constructors and member functions
4015 binomial_distribution() : binomial_distribution(1) { }
4018 binomial_distribution(_IntType __t
, double __p
= 0.5)
4019 : _M_param(__t
, __p
), _M_nd()
4023 binomial_distribution(const param_type
& __p
)
4024 : _M_param(__p
), _M_nd()
4028 * @brief Resets the distribution state.
4035 * @brief Returns the distribution @p t parameter.
4039 { return _M_param
.t(); }
4042 * @brief Returns the distribution @p p parameter.
4046 { return _M_param
.p(); }
4049 * @brief Returns the parameter set of the distribution.
4053 { return _M_param
; }
4056 * @brief Sets the parameter set of the distribution.
4057 * @param __param The new parameter set of the distribution.
4060 param(const param_type
& __param
)
4061 { _M_param
= __param
; }
4064 * @brief Returns the greatest lower bound value of the distribution.
4071 * @brief Returns the least upper bound value of the distribution.
4075 { return _M_param
.t(); }
4078 * @brief Generating functions.
4080 template<typename _UniformRandomNumberGenerator
>
4082 operator()(_UniformRandomNumberGenerator
& __urng
)
4083 { return this->operator()(__urng
, _M_param
); }
4085 template<typename _UniformRandomNumberGenerator
>
4087 operator()(_UniformRandomNumberGenerator
& __urng
,
4088 const param_type
& __p
);
4090 template<typename _ForwardIterator
,
4091 typename _UniformRandomNumberGenerator
>
4093 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4094 _UniformRandomNumberGenerator
& __urng
)
4095 { this->__generate(__f
, __t
, __urng
, _M_param
); }
4097 template<typename _ForwardIterator
,
4098 typename _UniformRandomNumberGenerator
>
4100 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4101 _UniformRandomNumberGenerator
& __urng
,
4102 const param_type
& __p
)
4103 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
4105 template<typename _UniformRandomNumberGenerator
>
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.
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
; }
4123 { return __d1
._M_param
== __d2
._M_param
; }
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
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
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
);
4159 template<typename _ForwardIterator
,
4160 typename _UniformRandomNumberGenerator
>
4162 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
4163 _UniformRandomNumberGenerator
& __urng
,
4164 const param_type
& __p
);
4166 template<typename _UniformRandomNumberGenerator
>
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
>
4183 operator!=(const std::binomial_distribution
<_IntType
>& __d1
,
4184 const std::binomial_distribution
<_IntType
>& __d2
)
4185 { return !(__d1
== __d2
); }
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
4195 * @headerfile random
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");
4205 /** The type of the range of the distribution. */
4206 typedef _IntType result_type
;
4208 /** Parameter type. */
4211 typedef geometric_distribution
<_IntType
> distribution_type
;
4212 friend class geometric_distribution
<_IntType
>;
4214 param_type() : param_type(0.5) { }
4217 param_type(double __p
)
4220 __glibcxx_assert((_M_p
> 0.0) && (_M_p
< 1.0));
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
4234 operator!=(const param_type
& __p1
, const param_type
& __p2
)
4235 { return !(__p1
== __p2
); }
4241 { _M_log_1_p
= std::log(1.0 - _M_p
); }
4248 // constructors and member functions
4250 geometric_distribution() : geometric_distribution(0.5) { }
4253 geometric_distribution(double __p
)
4258 geometric_distribution(const param_type
& __p
)
4263 * @brief Resets the distribution state.
4265 * Does nothing for the geometric distribution.
4271 * @brief Returns the distribution parameter @p p.
4275 { return _M_param
.p(); }
4278 * @brief Returns the parameter set of the distribution.
4282 { return _M_param
; }
4285 * @brief Sets the parameter set of the distribution.
4286 * @param __param The new parameter set of the distribution.
4289 param(const param_type
& __param
)
4290 { _M_param
= __param
; }
4293 * @brief Returns the greatest lower bound value of the distribution.
4300 * @brief Returns the least upper bound value of the distribution.
4304 { return std::numeric_limits
<result_type
>::max(); }
4307 * @brief Generating functions.
4309 template<typename _UniformRandomNumberGenerator
>
4311 operator()(_UniformRandomNumberGenerator
& __urng
)
4312 { return this->operator()(__urng
, _M_param
); }
4314 template<typename _UniformRandomNumberGenerator
>
4316 operator()(_UniformRandomNumberGenerator
& __urng
,
4317 const param_type
& __p
);
4319 template<typename _ForwardIterator
,
4320 typename _UniformRandomNumberGenerator
>
4322 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4323 _UniformRandomNumberGenerator
& __urng
)
4324 { this->__generate(__f
, __t
, __urng
, _M_param
); }
4326 template<typename _ForwardIterator
,
4327 typename _UniformRandomNumberGenerator
>
4329 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4330 _UniformRandomNumberGenerator
& __urng
,
4331 const param_type
& __p
)
4332 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
4334 template<typename _UniformRandomNumberGenerator
>
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.
4346 operator==(const geometric_distribution
& __d1
,
4347 const geometric_distribution
& __d2
)
4348 { return __d1
._M_param
== __d2
._M_param
; }
4351 template<typename _ForwardIterator
,
4352 typename _UniformRandomNumberGenerator
>
4354 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
4355 _UniformRandomNumberGenerator
& __urng
,
4356 const param_type
& __p
);
4358 param_type _M_param
;
4361 #if __cpp_impl_three_way_comparison < 201907L
4363 * @brief Return true if two geometric distributions have
4364 * different parameters.
4366 template<typename _IntType
>
4368 operator!=(const std::geometric_distribution
<_IntType
>& __d1
,
4369 const std::geometric_distribution
<_IntType
>& __d2
)
4370 { return !(__d1
== __d2
); }
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
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
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");
4422 /** The type of the range of the distribution. */
4423 typedef _IntType result_type
;
4425 /** Parameter type. */
4428 typedef negative_binomial_distribution
<_IntType
> distribution_type
;
4430 param_type() : param_type(1) { }
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));
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
4453 operator!=(const param_type
& __p1
, const param_type
& __p2
)
4454 { return !(__p1
== __p2
); }
4462 negative_binomial_distribution() : negative_binomial_distribution(1) { }
4465 negative_binomial_distribution(_IntType __k
, double __p
= 0.5)
4466 : _M_param(__k
, __p
), _M_gd(__k
, (1.0 - __p
) / __p
)
4470 negative_binomial_distribution(const param_type
& __p
)
4471 : _M_param(__p
), _M_gd(__p
.k(), (1.0 - __p
.p()) / __p
.p())
4475 * @brief Resets the distribution state.
4482 * @brief Return the @f$k@f$ parameter of the distribution.
4486 { return _M_param
.k(); }
4489 * @brief Return the @f$p@f$ parameter of the distribution.
4493 { return _M_param
.p(); }
4496 * @brief Returns the parameter set of the distribution.
4500 { return _M_param
; }
4503 * @brief Sets the parameter set of the distribution.
4504 * @param __param The new parameter set of the distribution.
4507 param(const param_type
& __param
)
4508 { _M_param
= __param
; }
4511 * @brief Returns the greatest lower bound value of the distribution.
4515 { return result_type(0); }
4518 * @brief Returns the least upper bound value of the distribution.
4522 { return std::numeric_limits
<result_type
>::max(); }
4525 * @brief Generating functions.
4527 template<typename _UniformRandomNumberGenerator
>
4529 operator()(_UniformRandomNumberGenerator
& __urng
);
4531 template<typename _UniformRandomNumberGenerator
>
4533 operator()(_UniformRandomNumberGenerator
& __urng
,
4534 const param_type
& __p
);
4536 template<typename _ForwardIterator
,
4537 typename _UniformRandomNumberGenerator
>
4539 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4540 _UniformRandomNumberGenerator
& __urng
)
4541 { this->__generate_impl(__f
, __t
, __urng
); }
4543 template<typename _ForwardIterator
,
4544 typename _UniformRandomNumberGenerator
>
4546 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4547 _UniformRandomNumberGenerator
& __urng
,
4548 const param_type
& __p
)
4549 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
4551 template<typename _UniformRandomNumberGenerator
>
4553 __generate(result_type
* __f
, result_type
* __t
,
4554 _UniformRandomNumberGenerator
& __urng
)
4555 { this->__generate_impl(__f
, __t
, __urng
); }
4557 template<typename _UniformRandomNumberGenerator
>
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.
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
4582 * @returns The output stream with the state of @p __x inserted or in
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
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
);
4606 template<typename _ForwardIterator
,
4607 typename _UniformRandomNumberGenerator
>
4609 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
4610 _UniformRandomNumberGenerator
& __urng
);
4611 template<typename _ForwardIterator
,
4612 typename _UniformRandomNumberGenerator
>
4614 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
4615 _UniformRandomNumberGenerator
& __urng
,
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
>
4629 operator!=(const std::negative_binomial_distribution
<_IntType
>& __d1
,
4630 const std::negative_binomial_distribution
<_IntType
>& __d2
)
4631 { return !(__d1
== __d2
); }
4634 /// @} group random_distributions_bernoulli
4637 * @addtogroup random_distributions_poisson Poisson Distributions
4638 * @ingroup random_distributions
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
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");
4659 /** The type of the range of the distribution. */
4660 typedef _IntType result_type
;
4662 /** Parameter type. */
4665 typedef poisson_distribution
<_IntType
> distribution_type
;
4666 friend class poisson_distribution
<_IntType
>;
4668 param_type() : param_type(1.0) { }
4671 param_type(double __mean
)
4674 __glibcxx_assert(_M_mean
> 0.0);
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
4688 operator!=(const param_type
& __p1
, const param_type
& __p2
)
4689 { return !(__p1
== __p2
); }
4693 // Hosts either log(mean) or the threshold of the simple method.
4700 #if _GLIBCXX_USE_C99_MATH_FUNCS
4701 double _M_lfm
, _M_sm
, _M_d
, _M_scx
, _M_1cx
, _M_c2b
, _M_cb
;
4705 // constructors and member functions
4707 poisson_distribution() : poisson_distribution(1.0) { }
4710 poisson_distribution(double __mean
)
4711 : _M_param(__mean
), _M_nd()
4715 poisson_distribution(const param_type
& __p
)
4716 : _M_param(__p
), _M_nd()
4720 * @brief Resets the distribution state.
4727 * @brief Returns the distribution parameter @p mean.
4731 { return _M_param
.mean(); }
4734 * @brief Returns the parameter set of the distribution.
4738 { return _M_param
; }
4741 * @brief Sets the parameter set of the distribution.
4742 * @param __param The new parameter set of the distribution.
4745 param(const param_type
& __param
)
4746 { _M_param
= __param
; }
4749 * @brief Returns the greatest lower bound value of the distribution.
4756 * @brief Returns the least upper bound value of the distribution.
4760 { return std::numeric_limits
<result_type
>::max(); }
4763 * @brief Generating functions.
4765 template<typename _UniformRandomNumberGenerator
>
4767 operator()(_UniformRandomNumberGenerator
& __urng
)
4768 { return this->operator()(__urng
, _M_param
); }
4770 template<typename _UniformRandomNumberGenerator
>
4772 operator()(_UniformRandomNumberGenerator
& __urng
,
4773 const param_type
& __p
);
4775 template<typename _ForwardIterator
,
4776 typename _UniformRandomNumberGenerator
>
4778 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4779 _UniformRandomNumberGenerator
& __urng
)
4780 { this->__generate(__f
, __t
, __urng
, _M_param
); }
4782 template<typename _ForwardIterator
,
4783 typename _UniformRandomNumberGenerator
>
4785 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
4786 _UniformRandomNumberGenerator
& __urng
,
4787 const param_type
& __p
)
4788 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
4790 template<typename _UniformRandomNumberGenerator
>
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
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
; }
4808 { return __d1
._M_param
== __d2
._M_param
; }
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
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
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
);
4842 template<typename _ForwardIterator
,
4843 typename _UniformRandomNumberGenerator
>
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
>
4861 operator!=(const std::poisson_distribution
<_IntType
>& __d1
,
4862 const std::poisson_distribution
<_IntType
>& __d2
)
4863 { return !(__d1
== __d2
); }
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>
4881 * @headerfile random
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");
4891 /** The type of the range of the distribution. */
4892 typedef _RealType result_type
;
4894 /** Parameter type. */
4897 typedef exponential_distribution
<_RealType
> distribution_type
;
4899 param_type() : param_type(1.0) { }
4902 param_type(_RealType __lambda
)
4903 : _M_lambda(__lambda
)
4905 __glibcxx_assert(_M_lambda
> _RealType(0));
4910 { return _M_lambda
; }
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
4918 operator!=(const param_type
& __p1
, const param_type
& __p2
)
4919 { return !(__p1
== __p2
); }
4923 _RealType _M_lambda
;
4928 * @brief Constructs an exponential distribution with inverse scale
4931 exponential_distribution() : exponential_distribution(1.0) { }
4934 * @brief Constructs an exponential distribution with inverse scale
4935 * parameter @f$\lambda@f$.
4938 exponential_distribution(_RealType __lambda
)
4939 : _M_param(__lambda
)
4943 exponential_distribution(const param_type
& __p
)
4948 * @brief Resets the distribution state.
4950 * Has no effect on exponential distributions.
4956 * @brief Returns the inverse scale parameter of the distribution.
4960 { return _M_param
.lambda(); }
4963 * @brief Returns the parameter set of the distribution.
4967 { return _M_param
; }
4970 * @brief Sets the parameter set of the distribution.
4971 * @param __param The new parameter set of the distribution.
4974 param(const param_type
& __param
)
4975 { _M_param
= __param
; }
4978 * @brief Returns the greatest lower bound value of the distribution.
4982 { return result_type(0); }
4985 * @brief Returns the least upper bound value of the distribution.
4989 { return std::numeric_limits
<result_type
>::max(); }
4992 * @brief Generating functions.
4994 template<typename _UniformRandomNumberGenerator
>
4996 operator()(_UniformRandomNumberGenerator
& __urng
)
4997 { return this->operator()(__urng
, _M_param
); }
4999 template<typename _UniformRandomNumberGenerator
>
5001 operator()(_UniformRandomNumberGenerator
& __urng
,
5002 const param_type
& __p
)
5004 __detail::_Adaptor
<_UniformRandomNumberGenerator
, result_type
>
5006 return -std::log(result_type(1) - __aurng()) / __p
.lambda();
5009 template<typename _ForwardIterator
,
5010 typename _UniformRandomNumberGenerator
>
5012 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5013 _UniformRandomNumberGenerator
& __urng
)
5014 { this->__generate(__f
, __t
, __urng
, _M_param
); }
5016 template<typename _ForwardIterator
,
5017 typename _UniformRandomNumberGenerator
>
5019 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5020 _UniformRandomNumberGenerator
& __urng
,
5021 const param_type
& __p
)
5022 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
5024 template<typename _UniformRandomNumberGenerator
>
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
5036 operator==(const exponential_distribution
& __d1
,
5037 const exponential_distribution
& __d2
)
5038 { return __d1
._M_param
== __d2
._M_param
; }
5041 template<typename _ForwardIterator
,
5042 typename _UniformRandomNumberGenerator
>
5044 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
5045 _UniformRandomNumberGenerator
& __urng
,
5046 const param_type
& __p
);
5048 param_type _M_param
;
5051 #if __cpp_impl_three_way_comparison < 201907L
5053 * @brief Return true if two exponential distributions have different
5056 template<typename _RealType
>
5058 operator!=(const std::exponential_distribution
<_RealType
>& __d1
,
5059 const std::exponential_distribution
<_RealType
>& __d2
)
5060 { return !(__d1
== __d2
); }
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
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
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:
5099 * p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
5100 * \exp{(-(\frac{x}{\beta})^\alpha)}
5103 * @headerfile random
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");
5113 /** The type of the range of the distribution. */
5114 typedef _RealType result_type
;
5116 /** Parameter type. */
5119 typedef weibull_distribution
<_RealType
> distribution_type
;
5121 param_type() : param_type(1.0) { }
5124 param_type(_RealType __a
, _RealType __b
= _RealType(1.0))
5125 : _M_a(__a
), _M_b(__b
)
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
5142 operator!=(const param_type
& __p1
, const param_type
& __p2
)
5143 { return !(__p1
== __p2
); }
5151 weibull_distribution() : weibull_distribution(1.0) { }
5154 weibull_distribution(_RealType __a
, _RealType __b
= _RealType(1))
5155 : _M_param(__a
, __b
)
5159 weibull_distribution(const param_type
& __p
)
5164 * @brief Resets the distribution state.
5171 * @brief Return the @f$a@f$ parameter of the distribution.
5175 { return _M_param
.a(); }
5178 * @brief Return the @f$b@f$ parameter of the distribution.
5182 { return _M_param
.b(); }
5185 * @brief Returns the parameter set of the distribution.
5189 { return _M_param
; }
5192 * @brief Sets the parameter set of the distribution.
5193 * @param __param The new parameter set of the distribution.
5196 param(const param_type
& __param
)
5197 { _M_param
= __param
; }
5200 * @brief Returns the greatest lower bound value of the distribution.
5204 { return result_type(0); }
5207 * @brief Returns the least upper bound value of the distribution.
5211 { return std::numeric_limits
<result_type
>::max(); }
5214 * @brief Generating functions.
5216 template<typename _UniformRandomNumberGenerator
>
5218 operator()(_UniformRandomNumberGenerator
& __urng
)
5219 { return this->operator()(__urng
, _M_param
); }
5221 template<typename _UniformRandomNumberGenerator
>
5223 operator()(_UniformRandomNumberGenerator
& __urng
,
5224 const param_type
& __p
);
5226 template<typename _ForwardIterator
,
5227 typename _UniformRandomNumberGenerator
>
5229 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5230 _UniformRandomNumberGenerator
& __urng
)
5231 { this->__generate(__f
, __t
, __urng
, _M_param
); }
5233 template<typename _ForwardIterator
,
5234 typename _UniformRandomNumberGenerator
>
5236 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5237 _UniformRandomNumberGenerator
& __urng
,
5238 const param_type
& __p
)
5239 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
5241 template<typename _UniformRandomNumberGenerator
>
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
5253 operator==(const weibull_distribution
& __d1
,
5254 const weibull_distribution
& __d2
)
5255 { return __d1
._M_param
== __d2
._M_param
; }
5258 template<typename _ForwardIterator
,
5259 typename _UniformRandomNumberGenerator
>
5261 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
5262 _UniformRandomNumberGenerator
& __urng
,
5263 const param_type
& __p
);
5265 param_type _M_param
;
5268 #if __cpp_impl_three_way_comparison < 201907L
5270 * @brief Return true if two Weibull distributions have different
5273 template<typename _RealType
>
5275 operator!=(const std::weibull_distribution
<_RealType
>& __d1
,
5276 const std::weibull_distribution
<_RealType
>& __d2
)
5277 { return !(__d1
== __d2
); }
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
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
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
5316 * p(x|a,b) = \frac{1}{b}
5317 * \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
5320 * @headerfile random
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");
5330 /** The type of the range of the distribution. */
5331 typedef _RealType result_type
;
5333 /** Parameter type. */
5336 typedef extreme_value_distribution
<_RealType
> distribution_type
;
5338 param_type() : param_type(0.0) { }
5341 param_type(_RealType __a
, _RealType __b
= _RealType(1.0))
5342 : _M_a(__a
), _M_b(__b
)
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
5359 operator!=(const param_type
& __p1
, const param_type
& __p2
)
5360 { return !(__p1
== __p2
); }
5368 extreme_value_distribution() : extreme_value_distribution(0.0) { }
5371 extreme_value_distribution(_RealType __a
, _RealType __b
= _RealType(1))
5372 : _M_param(__a
, __b
)
5376 extreme_value_distribution(const param_type
& __p
)
5381 * @brief Resets the distribution state.
5388 * @brief Return the @f$a@f$ parameter of the distribution.
5392 { return _M_param
.a(); }
5395 * @brief Return the @f$b@f$ parameter of the distribution.
5399 { return _M_param
.b(); }
5402 * @brief Returns the parameter set of the distribution.
5406 { return _M_param
; }
5409 * @brief Sets the parameter set of the distribution.
5410 * @param __param The new parameter set of the distribution.
5413 param(const param_type
& __param
)
5414 { _M_param
= __param
; }
5417 * @brief Returns the greatest lower bound value of the distribution.
5421 { return std::numeric_limits
<result_type
>::lowest(); }
5424 * @brief Returns the least upper bound value of the distribution.
5428 { return std::numeric_limits
<result_type
>::max(); }
5431 * @brief Generating functions.
5433 template<typename _UniformRandomNumberGenerator
>
5435 operator()(_UniformRandomNumberGenerator
& __urng
)
5436 { return this->operator()(__urng
, _M_param
); }
5438 template<typename _UniformRandomNumberGenerator
>
5440 operator()(_UniformRandomNumberGenerator
& __urng
,
5441 const param_type
& __p
);
5443 template<typename _ForwardIterator
,
5444 typename _UniformRandomNumberGenerator
>
5446 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5447 _UniformRandomNumberGenerator
& __urng
)
5448 { this->__generate(__f
, __t
, __urng
, _M_param
); }
5450 template<typename _ForwardIterator
,
5451 typename _UniformRandomNumberGenerator
>
5453 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5454 _UniformRandomNumberGenerator
& __urng
,
5455 const param_type
& __p
)
5456 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
5458 template<typename _UniformRandomNumberGenerator
>
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
5470 operator==(const extreme_value_distribution
& __d1
,
5471 const extreme_value_distribution
& __d2
)
5472 { return __d1
._M_param
== __d2
._M_param
; }
5475 template<typename _ForwardIterator
,
5476 typename _UniformRandomNumberGenerator
>
5478 __generate_impl(_ForwardIterator __f
, _ForwardIterator __t
,
5479 _UniformRandomNumberGenerator
& __urng
,
5480 const param_type
& __p
);
5482 param_type _M_param
;
5485 #if __cpp_impl_three_way_comparison < 201907L
5487 * @brief Return true if two extreme value distributions have different
5490 template<typename _RealType
>
5492 operator!=(const std::extreme_value_distribution
<_RealType
>& __d1
,
5493 const std::extreme_value_distribution
<_RealType
>& __d2
)
5494 { return !(__d1
== __d2
); }
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
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
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
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
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");
5552 /** The type of the range of the distribution. */
5553 typedef _IntType result_type
;
5555 /** Parameter type. */
5558 typedef discrete_distribution
<_IntType
> distribution_type
;
5559 friend class discrete_distribution
<_IntType
>;
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
,
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;
5584 probabilities() const
5585 { return _M_prob
.empty() ? std::vector
<double>(1, 1.0) : _M_prob
; }
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
5593 operator!=(const param_type
& __p1
, const param_type
& __p2
)
5594 { return !(__p1
== __p2
); }
5601 std::vector
<double> _M_prob
;
5602 std::vector
<double> _M_cp
;
5605 discrete_distribution()
5609 template<typename _InputIterator
>
5610 discrete_distribution(_InputIterator __wbegin
,
5611 _InputIterator __wend
)
5612 : _M_param(__wbegin
, __wend
)
5615 discrete_distribution(initializer_list
<double> __wl
)
5619 template<typename _Func
>
5620 discrete_distribution(size_t __nw
, double __xmin
, double __xmax
,
5622 : _M_param(__nw
, __xmin
, __xmax
, __fw
)
5626 discrete_distribution(const param_type
& __p
)
5631 * @brief Resets the distribution state.
5638 * @brief Returns the probabilities of the distribution.
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.
5652 { return _M_param
; }
5655 * @brief Sets the parameter set of the distribution.
5656 * @param __param The new parameter set of the distribution.
5659 param(const param_type
& __param
)
5660 { _M_param
= __param
; }
5663 * @brief Returns the greatest lower bound value of the distribution.
5667 { return result_type(0); }
5670 * @brief Returns the least upper bound value of the distribution.
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
>
5684 operator()(_UniformRandomNumberGenerator
& __urng
)
5685 { return this->operator()(__urng
, _M_param
); }
5687 template<typename _UniformRandomNumberGenerator
>
5689 operator()(_UniformRandomNumberGenerator
& __urng
,
5690 const param_type
& __p
);
5692 template<typename _ForwardIterator
,
5693 typename _UniformRandomNumberGenerator
>
5695 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5696 _UniformRandomNumberGenerator
& __urng
)
5697 { this->__generate(__f
, __t
, __urng
, _M_param
); }
5699 template<typename _ForwardIterator
,
5700 typename _UniformRandomNumberGenerator
>
5702 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5703 _UniformRandomNumberGenerator
& __urng
,
5704 const param_type
& __p
)
5705 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
5707 template<typename _UniformRandomNumberGenerator
>
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
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
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
5746 * @returns The input stream with @p __x extracted or in an error
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
);
5755 template<typename _ForwardIterator
,
5756 typename _UniformRandomNumberGenerator
>
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
5770 template<typename _IntType
>
5772 operator!=(const std::discrete_distribution
<_IntType
>& __d1
,
5773 const std::discrete_distribution
<_IntType
>& __d2
)
5774 { return !(__d1
== __d2
); }
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
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}
5788 * for @f$ b_i \leq x < b_{i+1} @f$.
5790 * @headerfile random
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");
5800 /** The type of the range of the distribution. */
5801 typedef _RealType result_type
;
5803 /** Parameter type. */
5806 typedef piecewise_constant_distribution
<_RealType
> distribution_type
;
5807 friend class piecewise_constant_distribution
<_RealType
>;
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
,
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
>
5834 std::vector
<_RealType
> __tmp(2);
5835 __tmp
[1] = _RealType(1);
5844 { return _M_den
.empty() ? std::vector
<double>(1, 1.0) : _M_den
; }
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
5852 operator!=(const param_type
& __p1
, const param_type
& __p2
)
5853 { return !(__p1
== __p2
); }
5860 std::vector
<_RealType
> _M_int
;
5861 std::vector
<double> _M_den
;
5862 std::vector
<double> _M_cp
;
5865 piecewise_constant_distribution()
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
,
5879 : _M_param(__bl
, __fw
)
5882 template<typename _Func
>
5883 piecewise_constant_distribution(size_t __nw
,
5884 _RealType __xmin
, _RealType __xmax
,
5886 : _M_param(__nw
, __xmin
, __xmax
, __fw
)
5890 piecewise_constant_distribution(const param_type
& __p
)
5895 * @brief Resets the distribution state.
5902 * @brief Returns a vector of the intervals.
5904 std::vector
<_RealType
>
5907 if (_M_param
._M_int
.empty())
5909 std::vector
<_RealType
> __tmp(2);
5910 __tmp
[1] = _RealType(1);
5914 return _M_param
._M_int
;
5918 * @brief Returns a vector of the probability densities.
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.
5932 { return _M_param
; }
5935 * @brief Sets the parameter set of the distribution.
5936 * @param __param The new parameter set of the distribution.
5939 param(const param_type
& __param
)
5940 { _M_param
= __param
; }
5943 * @brief Returns the greatest lower bound value of the distribution.
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.
5958 return _M_param
._M_int
.empty()
5959 ? result_type(1) : _M_param
._M_int
.back();
5963 * @brief Generating functions.
5965 template<typename _UniformRandomNumberGenerator
>
5967 operator()(_UniformRandomNumberGenerator
& __urng
)
5968 { return this->operator()(__urng
, _M_param
); }
5970 template<typename _UniformRandomNumberGenerator
>
5972 operator()(_UniformRandomNumberGenerator
& __urng
,
5973 const param_type
& __p
);
5975 template<typename _ForwardIterator
,
5976 typename _UniformRandomNumberGenerator
>
5978 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5979 _UniformRandomNumberGenerator
& __urng
)
5980 { this->__generate(__f
, __t
, __urng
, _M_param
); }
5982 template<typename _ForwardIterator
,
5983 typename _UniformRandomNumberGenerator
>
5985 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
5986 _UniformRandomNumberGenerator
& __urng
,
5987 const param_type
& __p
)
5988 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
5990 template<typename _UniformRandomNumberGenerator
>
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
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
6014 * @returns The output stream with the state of @p __x inserted or in
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
6030 * @returns The input stream with @p __x extracted or in an error
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
);
6039 template<typename _ForwardIterator
,
6040 typename _UniformRandomNumberGenerator
>
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
>
6056 operator!=(const std::piecewise_constant_distribution
<_RealType
>& __d1
,
6057 const std::piecewise_constant_distribution
<_RealType
>& __d2
)
6058 { return !(__d1
== __d2
); }
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
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");
6080 /** The type of the range of the distribution. */
6081 typedef _RealType result_type
;
6083 /** Parameter type. */
6086 typedef piecewise_linear_distribution
<_RealType
> distribution_type
;
6087 friend class piecewise_linear_distribution
<_RealType
>;
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
,
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
>
6114 std::vector
<_RealType
> __tmp(2);
6115 __tmp
[1] = _RealType(1);
6124 { return _M_den
.empty() ? std::vector
<double>(2, 1.0) : _M_den
; }
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
6132 operator!=(const param_type
& __p1
, const param_type
& __p2
)
6133 { return !(__p1
== __p2
); }
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()
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
,
6160 : _M_param(__bl
, __fw
)
6163 template<typename _Func
>
6164 piecewise_linear_distribution(size_t __nw
,
6165 _RealType __xmin
, _RealType __xmax
,
6167 : _M_param(__nw
, __xmin
, __xmax
, __fw
)
6171 piecewise_linear_distribution(const param_type
& __p
)
6176 * Resets the distribution state.
6183 * @brief Return the intervals of the distribution.
6185 std::vector
<_RealType
>
6188 if (_M_param
._M_int
.empty())
6190 std::vector
<_RealType
> __tmp(2);
6191 __tmp
[1] = _RealType(1);
6195 return _M_param
._M_int
;
6199 * @brief Return a vector of the probability densities of the
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.
6214 { return _M_param
; }
6217 * @brief Sets the parameter set of the distribution.
6218 * @param __param The new parameter set of the distribution.
6221 param(const param_type
& __param
)
6222 { _M_param
= __param
; }
6225 * @brief Returns the greatest lower bound value of the distribution.
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.
6240 return _M_param
._M_int
.empty()
6241 ? result_type(1) : _M_param
._M_int
.back();
6245 * @brief Generating functions.
6247 template<typename _UniformRandomNumberGenerator
>
6249 operator()(_UniformRandomNumberGenerator
& __urng
)
6250 { return this->operator()(__urng
, _M_param
); }
6252 template<typename _UniformRandomNumberGenerator
>
6254 operator()(_UniformRandomNumberGenerator
& __urng
,
6255 const param_type
& __p
);
6257 template<typename _ForwardIterator
,
6258 typename _UniformRandomNumberGenerator
>
6260 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
6261 _UniformRandomNumberGenerator
& __urng
)
6262 { this->__generate(__f
, __t
, __urng
, _M_param
); }
6264 template<typename _ForwardIterator
,
6265 typename _UniformRandomNumberGenerator
>
6267 __generate(_ForwardIterator __f
, _ForwardIterator __t
,
6268 _UniformRandomNumberGenerator
& __urng
,
6269 const param_type
& __p
)
6270 { this->__generate_impl(__f
, __t
, __urng
, __p
); }
6272 template<typename _UniformRandomNumberGenerator
>
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
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
6296 * @returns The output stream with the state of @p __x inserted or in
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
6312 * @returns The input stream with @p __x extracted or in an error
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
);
6321 template<typename _ForwardIterator
,
6322 typename _UniformRandomNumberGenerator
>
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
>
6338 operator!=(const std::piecewise_linear_distribution
<_RealType
>& __d1
,
6339 const std::piecewise_linear_distribution
<_RealType
>& __d2
)
6340 { return !(__d1
== __d2
); }
6343 /// @} group random_distributions_sampling
6345 /// @} *group random_distributions
6348 * @addtogroup random_utilities Random Number Utilities
6354 * @brief The seed_seq class generates sequences of seeds for random
6355 * number generators.
6357 * @headerfile random
6363 /** The type of the seed vales. */
6364 typedef uint_least32_t result_type
;
6366 /** Default constructor. */
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
>
6380 generate(_RandomAccessIterator __begin
, _RandomAccessIterator __end
);
6382 // property functions
6383 size_t size() const noexcept
6384 { return _M_v
.size(); }
6386 template<typename _OutputIterator
>
6388 param(_OutputIterator __dest
) const
6389 { std::copy(_M_v
.begin(), _M_v
.end(), __dest
); }
6391 // no copy functions
6392 seed_seq(const seed_seq
&) = delete;
6393 seed_seq
& operator=(const seed_seq
&) = delete;
6396 std::vector
<result_type
> _M_v
;
6399 /// @} group random_utilities
6403 _GLIBCXX_END_NAMESPACE_VERSION