Line data Source code
1 : // random number generation -*- C++ -*-
2 :
3 : // Copyright (C) 2009-2023 Free Software Foundation, Inc.
4 : //
5 : // This file is part of the GNU ISO C++ Library. This library is free
6 : // software; you can redistribute it and/or modify it under the
7 : // terms of the GNU General Public License as published by the
8 : // Free Software Foundation; either version 3, or (at your option)
9 : // any later version.
10 :
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.
15 :
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.
19 :
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/>.
24 :
25 : /**
26 : * @file bits/random.h
27 : * This is an internal header file, included by other library headers.
28 : * Do not attempt to use it directly. @headername{random}
29 : */
30 :
31 : #ifndef _RANDOM_H
32 : #define _RANDOM_H 1
33 :
34 : #include <vector>
35 : #include <bits/uniform_int_dist.h>
36 :
37 : namespace std _GLIBCXX_VISIBILITY(default)
38 : {
39 : _GLIBCXX_BEGIN_NAMESPACE_VERSION
40 :
41 : // [26.4] Random number generation
42 :
43 : /**
44 : * @defgroup random Random Number Generation
45 : * @ingroup numerics
46 : *
47 : * A facility for generating random numbers on selected distributions.
48 : * @{
49 : */
50 :
51 : // std::uniform_random_bit_generator is defined in <bits/uniform_int_dist.h>
52 :
53 : /**
54 : * @brief A function template for converting the output of a (integral)
55 : * uniform random number generator to a floatng point result in the range
56 : * [0-1).
57 : */
58 : template<typename _RealType, size_t __bits,
59 : typename _UniformRandomNumberGenerator>
60 : _RealType
61 : generate_canonical(_UniformRandomNumberGenerator& __g);
62 :
63 : /// @cond undocumented
64 : // Implementation-space details.
65 : namespace __detail
66 : {
67 : template<typename _UIntType, size_t __w,
68 : bool = __w < static_cast<size_t>
69 : (std::numeric_limits<_UIntType>::digits)>
70 : struct _Shift
71 : { static constexpr _UIntType __value = 0; };
72 :
73 : template<typename _UIntType, size_t __w>
74 : struct _Shift<_UIntType, __w, true>
75 : { static constexpr _UIntType __value = _UIntType(1) << __w; };
76 :
77 : template<int __s,
78 : int __which = ((__s <= __CHAR_BIT__ * sizeof (int))
79 : + (__s <= __CHAR_BIT__ * sizeof (long))
80 : + (__s <= __CHAR_BIT__ * sizeof (long long))
81 : /* assume long long no bigger than __int128 */
82 : + (__s <= 128))>
83 : struct _Select_uint_least_t
84 : {
85 : static_assert(__which < 0, /* needs to be dependent */
86 : "sorry, would be too much trouble for a slow result");
87 : };
88 :
89 : template<int __s>
90 : struct _Select_uint_least_t<__s, 4>
91 : { using type = unsigned int; };
92 :
93 : template<int __s>
94 : struct _Select_uint_least_t<__s, 3>
95 : { using type = unsigned long; };
96 :
97 : template<int __s>
98 : struct _Select_uint_least_t<__s, 2>
99 : { using type = unsigned long long; };
100 :
101 : #if __SIZEOF_INT128__ > __SIZEOF_LONG_LONG__
102 : template<int __s>
103 : struct _Select_uint_least_t<__s, 1>
104 : { __extension__ using type = unsigned __int128; };
105 : #endif
106 :
107 : // Assume a != 0, a < m, c < m, x < m.
108 : template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
109 : bool __big_enough = (!(__m & (__m - 1))
110 : || (_Tp(-1) - __c) / __a >= __m - 1),
111 : bool __schrage_ok = __m % __a < __m / __a>
112 : struct _Mod
113 : {
114 : static _Tp
115 : __calc(_Tp __x)
116 : {
117 : using _Tp2
118 : = typename _Select_uint_least_t<std::__lg(__a)
119 : + std::__lg(__m) + 2>::type;
120 : return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m);
121 : }
122 : };
123 :
124 : // Schrage.
125 : template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
126 : struct _Mod<_Tp, __m, __a, __c, false, true>
127 : {
128 : static _Tp
129 : __calc(_Tp __x);
130 : };
131 :
132 : // Special cases:
133 : // - for m == 2^n or m == 0, unsigned integer overflow is safe.
134 : // - a * (m - 1) + c fits in _Tp, there is no overflow.
135 : template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
136 : struct _Mod<_Tp, __m, __a, __c, true, __s>
137 : {
138 : static _Tp
139 675874 : __calc(_Tp __x)
140 : {
141 675874 : _Tp __res = __a * __x + __c;
142 : if (__m)
143 675874 : __res %= __m;
144 675874 : return __res;
145 : }
146 : };
147 :
148 : template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
149 : inline _Tp
150 675874 : __mod(_Tp __x)
151 : {
152 : if _GLIBCXX17_CONSTEXPR (__a == 0)
153 : return __c;
154 : else
155 : {
156 : // _Mod must not be instantiated with a == 0
157 675874 : constexpr _Tp __a1 = __a ? __a : 1;
158 675874 : return _Mod<_Tp, __m, __a1, __c>::__calc(__x);
159 : }
160 : }
161 :
162 : /*
163 : * An adaptor class for converting the output of any Generator into
164 : * the input for a specific Distribution.
165 : */
166 : template<typename _Engine, typename _DInputType>
167 : struct _Adaptor
168 : {
169 : static_assert(std::is_floating_point<_DInputType>::value,
170 : "template argument must be a floating point type");
171 :
172 : public:
173 : _Adaptor(_Engine& __g)
174 : : _M_g(__g) { }
175 :
176 : _DInputType
177 : min() const
178 : { return _DInputType(0); }
179 :
180 : _DInputType
181 : max() const
182 : { return _DInputType(1); }
183 :
184 : /*
185 : * Converts a value generated by the adapted random number generator
186 : * into a value in the input domain for the dependent random number
187 : * distribution.
188 : */
189 : _DInputType
190 : operator()()
191 : {
192 : return std::generate_canonical<_DInputType,
193 : std::numeric_limits<_DInputType>::digits,
194 : _Engine>(_M_g);
195 : }
196 :
197 : private:
198 : _Engine& _M_g;
199 : };
200 :
201 : // Detect whether a template argument _Sseq is a valid seed sequence for
202 : // a random number engine _Engine with result type _Res.
203 : // Used to constrain _Engine::_Engine(_Sseq&) and _Engine::seed(_Sseq&)
204 : // as required by [rand.eng.general].
205 :
206 : template<typename _Sseq>
207 : using __seed_seq_generate_t = decltype(
208 : std::declval<_Sseq&>().generate(std::declval<uint_least32_t*>(),
209 : std::declval<uint_least32_t*>()));
210 :
211 : template<typename _Sseq, typename _Engine, typename _Res,
212 : typename _GenerateCheck = __seed_seq_generate_t<_Sseq>>
213 : using _If_seed_seq_for = _Require<
214 : __not_<is_same<__remove_cvref_t<_Sseq>, _Engine>>,
215 : is_unsigned<typename _Sseq::result_type>,
216 : __not_<is_convertible<_Sseq, _Res>>
217 : >;
218 :
219 : } // namespace __detail
220 : /// @endcond
221 :
222 : /**
223 : * @addtogroup random_generators Random Number Generators
224 : * @ingroup random
225 : *
226 : * These classes define objects which provide random or pseudorandom
227 : * numbers, either from a discrete or a continuous interval. The
228 : * random number generator supplied as a part of this library are
229 : * all uniform random number generators which provide a sequence of
230 : * random number uniformly distributed over their range.
231 : *
232 : * A number generator is a function object with an operator() that
233 : * takes zero arguments and returns a number.
234 : *
235 : * A compliant random number generator must satisfy the following
236 : * requirements. <table border=1 cellpadding=10 cellspacing=0>
237 : * <caption align=top>Random Number Generator Requirements</caption>
238 : * <tr><td>To be documented.</td></tr> </table>
239 : *
240 : * @{
241 : */
242 :
243 : /**
244 : * @brief A model of a linear congruential random number generator.
245 : *
246 : * A random number generator that produces pseudorandom numbers via
247 : * linear function:
248 : * @f[
249 : * x_{i+1}\leftarrow(ax_{i} + c) \bmod m
250 : * @f]
251 : *
252 : * The template parameter @p _UIntType must be an unsigned integral type
253 : * large enough to store values up to (__m-1). If the template parameter
254 : * @p __m is 0, the modulus @p __m used is
255 : * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
256 : * parameters @p __a and @p __c must be less than @p __m.
257 : *
258 : * The size of the state is @f$1@f$.
259 : *
260 : * @headerfile random
261 : * @since C++11
262 : */
263 : template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
264 : class linear_congruential_engine
265 : {
266 : static_assert(std::is_unsigned<_UIntType>::value,
267 : "result_type must be an unsigned integral type");
268 : static_assert(__m == 0u || (__a < __m && __c < __m),
269 : "template argument substituting __m out of bounds");
270 :
271 : template<typename _Sseq>
272 : using _If_seed_seq
273 : = __detail::_If_seed_seq_for<_Sseq, linear_congruential_engine,
274 : _UIntType>;
275 :
276 : public:
277 : /** The type of the generated random value. */
278 : typedef _UIntType result_type;
279 :
280 : /** The multiplier. */
281 : static constexpr result_type multiplier = __a;
282 : /** An increment. */
283 : static constexpr result_type increment = __c;
284 : /** The modulus. */
285 : static constexpr result_type modulus = __m;
286 : static constexpr result_type default_seed = 1u;
287 :
288 : /**
289 : * @brief Constructs a %linear_congruential_engine random number
290 : * generator engine with seed 1.
291 : */
292 : linear_congruential_engine() : linear_congruential_engine(default_seed)
293 : { }
294 :
295 : /**
296 : * @brief Constructs a %linear_congruential_engine random number
297 : * generator engine with seed @p __s. The default seed value
298 : * is 1.
299 : *
300 : * @param __s The initial seed value.
301 : */
302 : explicit
303 : linear_congruential_engine(result_type __s)
304 : { seed(__s); }
305 :
306 : /**
307 : * @brief Constructs a %linear_congruential_engine random number
308 : * generator engine seeded from the seed sequence @p __q.
309 : *
310 : * @param __q the seed sequence.
311 : */
312 : template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
313 : explicit
314 : linear_congruential_engine(_Sseq& __q)
315 : { seed(__q); }
316 :
317 : /**
318 : * @brief Reseeds the %linear_congruential_engine random number generator
319 : * engine sequence to the seed @p __s.
320 : *
321 : * @param __s The new seed.
322 : */
323 : void
324 : seed(result_type __s = default_seed);
325 :
326 : /**
327 : * @brief Reseeds the %linear_congruential_engine random number generator
328 : * engine
329 : * sequence using values from the seed sequence @p __q.
330 : *
331 : * @param __q the seed sequence.
332 : */
333 : template<typename _Sseq>
334 : _If_seed_seq<_Sseq>
335 : seed(_Sseq& __q);
336 :
337 : /**
338 : * @brief Gets the smallest possible value in the output range.
339 : *
340 : * The minimum depends on the @p __c parameter: if it is zero, the
341 : * minimum generated must be > 0, otherwise 0 is allowed.
342 : */
343 : static constexpr result_type
344 : min()
345 : { return __c == 0u ? 1u : 0u; }
346 :
347 : /**
348 : * @brief Gets the largest possible value in the output range.
349 : */
350 : static constexpr result_type
351 : max()
352 : { return __m - 1u; }
353 :
354 : /**
355 : * @brief Discard a sequence of random numbers.
356 : */
357 : void
358 : discard(unsigned long long __z)
359 : {
360 : for (; __z != 0ULL; --__z)
361 : (*this)();
362 : }
363 :
364 : /**
365 : * @brief Gets the next random number in the sequence.
366 : */
367 : result_type
368 : operator()()
369 : {
370 : _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
371 : return _M_x;
372 : }
373 :
374 : /**
375 : * @brief Compares two linear congruential random number generator
376 : * objects of the same type for equality.
377 : *
378 : * @param __lhs A linear congruential random number generator object.
379 : * @param __rhs Another linear congruential random number generator
380 : * object.
381 : *
382 : * @returns true if the infinite sequences of generated values
383 : * would be equal, false otherwise.
384 : */
385 : friend bool
386 : operator==(const linear_congruential_engine& __lhs,
387 : const linear_congruential_engine& __rhs)
388 : { return __lhs._M_x == __rhs._M_x; }
389 :
390 : /**
391 : * @brief Writes the textual representation of the state x(i) of x to
392 : * @p __os.
393 : *
394 : * @param __os The output stream.
395 : * @param __lcr A % linear_congruential_engine random number generator.
396 : * @returns __os.
397 : */
398 : template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
399 : _UIntType1 __m1, typename _CharT, typename _Traits>
400 : friend std::basic_ostream<_CharT, _Traits>&
401 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
402 : const std::linear_congruential_engine<_UIntType1,
403 : __a1, __c1, __m1>& __lcr);
404 :
405 : /**
406 : * @brief Sets the state of the engine by reading its textual
407 : * representation from @p __is.
408 : *
409 : * The textual representation must have been previously written using
410 : * an output stream whose imbued locale and whose type's template
411 : * specialization arguments _CharT and _Traits were the same as those
412 : * of @p __is.
413 : *
414 : * @param __is The input stream.
415 : * @param __lcr A % linear_congruential_engine random number generator.
416 : * @returns __is.
417 : */
418 : template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
419 : _UIntType1 __m1, typename _CharT, typename _Traits>
420 : friend std::basic_istream<_CharT, _Traits>&
421 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
422 : std::linear_congruential_engine<_UIntType1, __a1,
423 : __c1, __m1>& __lcr);
424 :
425 : private:
426 : _UIntType _M_x;
427 : };
428 :
429 : #if __cpp_impl_three_way_comparison < 201907L
430 : /**
431 : * @brief Compares two linear congruential random number generator
432 : * objects of the same type for inequality.
433 : *
434 : * @param __lhs A linear congruential random number generator object.
435 : * @param __rhs Another linear congruential random number generator
436 : * object.
437 : *
438 : * @returns true if the infinite sequences of generated values
439 : * would be different, false otherwise.
440 : */
441 : template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
442 : inline bool
443 : operator!=(const std::linear_congruential_engine<_UIntType, __a,
444 : __c, __m>& __lhs,
445 : const std::linear_congruential_engine<_UIntType, __a,
446 : __c, __m>& __rhs)
447 : { return !(__lhs == __rhs); }
448 : #endif
449 :
450 : /**
451 : * A generalized feedback shift register discrete random number generator.
452 : *
453 : * This algorithm avoids multiplication and division and is designed to be
454 : * friendly to a pipelined architecture. If the parameters are chosen
455 : * correctly, this generator will produce numbers with a very long period and
456 : * fairly good apparent entropy, although still not cryptographically strong.
457 : *
458 : * The best way to use this generator is with the predefined mt19937 class.
459 : *
460 : * This algorithm was originally invented by Makoto Matsumoto and
461 : * Takuji Nishimura.
462 : *
463 : * @tparam __w Word size, the number of bits in each element of
464 : * the state vector.
465 : * @tparam __n The degree of recursion.
466 : * @tparam __m The period parameter.
467 : * @tparam __r The separation point bit index.
468 : * @tparam __a The last row of the twist matrix.
469 : * @tparam __u The first right-shift tempering matrix parameter.
470 : * @tparam __d The first right-shift tempering matrix mask.
471 : * @tparam __s The first left-shift tempering matrix parameter.
472 : * @tparam __b The first left-shift tempering matrix mask.
473 : * @tparam __t The second left-shift tempering matrix parameter.
474 : * @tparam __c The second left-shift tempering matrix mask.
475 : * @tparam __l The second right-shift tempering matrix parameter.
476 : * @tparam __f Initialization multiplier.
477 : *
478 : * @headerfile random
479 : * @since C++11
480 : */
481 : template<typename _UIntType, size_t __w,
482 : size_t __n, size_t __m, size_t __r,
483 : _UIntType __a, size_t __u, _UIntType __d, size_t __s,
484 : _UIntType __b, size_t __t,
485 : _UIntType __c, size_t __l, _UIntType __f>
486 : class mersenne_twister_engine
487 : {
488 : static_assert(std::is_unsigned<_UIntType>::value,
489 : "result_type must be an unsigned integral type");
490 : static_assert(1u <= __m && __m <= __n,
491 : "template argument substituting __m out of bounds");
492 : static_assert(__r <= __w, "template argument substituting "
493 : "__r out of bound");
494 : static_assert(__u <= __w, "template argument substituting "
495 : "__u out of bound");
496 : static_assert(__s <= __w, "template argument substituting "
497 : "__s out of bound");
498 : static_assert(__t <= __w, "template argument substituting "
499 : "__t out of bound");
500 : static_assert(__l <= __w, "template argument substituting "
501 : "__l out of bound");
502 : static_assert(__w <= std::numeric_limits<_UIntType>::digits,
503 : "template argument substituting __w out of bound");
504 : static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
505 : "template argument substituting __a out of bound");
506 : static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
507 : "template argument substituting __b out of bound");
508 : static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
509 : "template argument substituting __c out of bound");
510 : static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
511 : "template argument substituting __d out of bound");
512 : static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
513 : "template argument substituting __f out of bound");
514 :
515 : template<typename _Sseq>
516 : using _If_seed_seq
517 : = __detail::_If_seed_seq_for<_Sseq, mersenne_twister_engine,
518 : _UIntType>;
519 :
520 : public:
521 : /** The type of the generated random value. */
522 : typedef _UIntType result_type;
523 :
524 : // parameter values
525 : static constexpr size_t word_size = __w;
526 : static constexpr size_t state_size = __n;
527 : static constexpr size_t shift_size = __m;
528 : static constexpr size_t mask_bits = __r;
529 : static constexpr result_type xor_mask = __a;
530 : static constexpr size_t tempering_u = __u;
531 : static constexpr result_type tempering_d = __d;
532 : static constexpr size_t tempering_s = __s;
533 : static constexpr result_type tempering_b = __b;
534 : static constexpr size_t tempering_t = __t;
535 : static constexpr result_type tempering_c = __c;
536 : static constexpr size_t tempering_l = __l;
537 : static constexpr result_type initialization_multiplier = __f;
538 : static constexpr result_type default_seed = 5489u;
539 :
540 : // constructors and member functions
541 :
542 250 : mersenne_twister_engine() : mersenne_twister_engine(default_seed) { }
543 :
544 : explicit
545 542 : mersenne_twister_engine(result_type __sd)
546 542 : { seed(__sd); }
547 :
548 : /**
549 : * @brief Constructs a %mersenne_twister_engine random number generator
550 : * engine seeded from the seed sequence @p __q.
551 : *
552 : * @param __q the seed sequence.
553 : */
554 : template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
555 : explicit
556 : mersenne_twister_engine(_Sseq& __q)
557 : { seed(__q); }
558 :
559 : void
560 : seed(result_type __sd = default_seed);
561 :
562 : template<typename _Sseq>
563 : _If_seed_seq<_Sseq>
564 : seed(_Sseq& __q);
565 :
566 : /**
567 : * @brief Gets the smallest possible value in the output range.
568 : */
569 : static constexpr result_type
570 : min()
571 : { return 0; }
572 :
573 : /**
574 : * @brief Gets the largest possible value in the output range.
575 : */
576 : static constexpr result_type
577 : max()
578 : { return __detail::_Shift<_UIntType, __w>::__value - 1; }
579 :
580 : /**
581 : * @brief Discard a sequence of random numbers.
582 : */
583 : void
584 : discard(unsigned long long __z);
585 :
586 : result_type
587 : operator()();
588 :
589 : /**
590 : * @brief Compares two % mersenne_twister_engine random number generator
591 : * objects of the same type for equality.
592 : *
593 : * @param __lhs A % mersenne_twister_engine random number generator
594 : * object.
595 : * @param __rhs Another % mersenne_twister_engine random number
596 : * generator object.
597 : *
598 : * @returns true if the infinite sequences of generated values
599 : * would be equal, false otherwise.
600 : */
601 : friend bool
602 : operator==(const mersenne_twister_engine& __lhs,
603 : const mersenne_twister_engine& __rhs)
604 : { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
605 : && __lhs._M_p == __rhs._M_p); }
606 :
607 : /**
608 : * @brief Inserts the current state of a % mersenne_twister_engine
609 : * random number generator engine @p __x into the output stream
610 : * @p __os.
611 : *
612 : * @param __os An output stream.
613 : * @param __x A % mersenne_twister_engine random number generator
614 : * engine.
615 : *
616 : * @returns The output stream with the state of @p __x inserted or in
617 : * an error state.
618 : */
619 : template<typename _UIntType1,
620 : size_t __w1, size_t __n1,
621 : size_t __m1, size_t __r1,
622 : _UIntType1 __a1, size_t __u1,
623 : _UIntType1 __d1, size_t __s1,
624 : _UIntType1 __b1, size_t __t1,
625 : _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
626 : typename _CharT, typename _Traits>
627 : friend std::basic_ostream<_CharT, _Traits>&
628 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
629 : const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
630 : __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
631 : __l1, __f1>& __x);
632 :
633 : /**
634 : * @brief Extracts the current state of a % mersenne_twister_engine
635 : * random number generator engine @p __x from the input stream
636 : * @p __is.
637 : *
638 : * @param __is An input stream.
639 : * @param __x A % mersenne_twister_engine random number generator
640 : * engine.
641 : *
642 : * @returns The input stream with the state of @p __x extracted or in
643 : * an error state.
644 : */
645 : template<typename _UIntType1,
646 : size_t __w1, size_t __n1,
647 : size_t __m1, size_t __r1,
648 : _UIntType1 __a1, size_t __u1,
649 : _UIntType1 __d1, size_t __s1,
650 : _UIntType1 __b1, size_t __t1,
651 : _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
652 : typename _CharT, typename _Traits>
653 : friend std::basic_istream<_CharT, _Traits>&
654 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
655 : std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
656 : __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
657 : __l1, __f1>& __x);
658 :
659 : private:
660 : void _M_gen_rand();
661 :
662 : _UIntType _M_x[state_size];
663 : size_t _M_p;
664 : };
665 :
666 : #if __cpp_impl_three_way_comparison < 201907L
667 : /**
668 : * @brief Compares two % mersenne_twister_engine random number generator
669 : * objects of the same type for inequality.
670 : *
671 : * @param __lhs A % mersenne_twister_engine random number generator
672 : * object.
673 : * @param __rhs Another % mersenne_twister_engine random number
674 : * generator object.
675 : *
676 : * @returns true if the infinite sequences of generated values
677 : * would be different, false otherwise.
678 : */
679 : template<typename _UIntType, size_t __w,
680 : size_t __n, size_t __m, size_t __r,
681 : _UIntType __a, size_t __u, _UIntType __d, size_t __s,
682 : _UIntType __b, size_t __t,
683 : _UIntType __c, size_t __l, _UIntType __f>
684 : inline bool
685 : operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
686 : __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
687 : const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
688 : __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
689 : { return !(__lhs == __rhs); }
690 : #endif
691 :
692 : /**
693 : * @brief The Marsaglia-Zaman generator.
694 : *
695 : * This is a model of a Generalized Fibonacci discrete random number
696 : * generator, sometimes referred to as the SWC generator.
697 : *
698 : * A discrete random number generator that produces pseudorandom
699 : * numbers using:
700 : * @f[
701 : * x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m
702 : * @f]
703 : *
704 : * The size of the state is @f$r@f$
705 : * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
706 : *
707 : * @headerfile random
708 : * @since C++11
709 : */
710 : template<typename _UIntType, size_t __w, size_t __s, size_t __r>
711 : class subtract_with_carry_engine
712 : {
713 : static_assert(std::is_unsigned<_UIntType>::value,
714 : "result_type must be an unsigned integral type");
715 : static_assert(0u < __s && __s < __r,
716 : "0 < s < r");
717 : static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
718 : "template argument substituting __w out of bounds");
719 :
720 : template<typename _Sseq>
721 : using _If_seed_seq
722 : = __detail::_If_seed_seq_for<_Sseq, subtract_with_carry_engine,
723 : _UIntType>;
724 :
725 : public:
726 : /** The type of the generated random value. */
727 : typedef _UIntType result_type;
728 :
729 : // parameter values
730 : static constexpr size_t word_size = __w;
731 : static constexpr size_t short_lag = __s;
732 : static constexpr size_t long_lag = __r;
733 : static constexpr uint_least32_t default_seed = 19780503u;
734 :
735 : subtract_with_carry_engine() : subtract_with_carry_engine(0u)
736 : { }
737 :
738 : /**
739 : * @brief Constructs an explicitly seeded %subtract_with_carry_engine
740 : * random number generator.
741 : */
742 : explicit
743 : subtract_with_carry_engine(result_type __sd)
744 : { seed(__sd); }
745 :
746 : /**
747 : * @brief Constructs a %subtract_with_carry_engine random number engine
748 : * seeded from the seed sequence @p __q.
749 : *
750 : * @param __q the seed sequence.
751 : */
752 : template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
753 : explicit
754 : subtract_with_carry_engine(_Sseq& __q)
755 : { seed(__q); }
756 :
757 : /**
758 : * @brief Seeds the initial state @f$x_0@f$ of the random number
759 : * generator.
760 : *
761 : * N1688[4.19] modifies this as follows. If @p __value == 0,
762 : * sets value to 19780503. In any case, with a linear
763 : * congruential generator lcg(i) having parameters @f$ m_{lcg} =
764 : * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
765 : * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
766 : * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$
767 : * set carry to 1, otherwise sets carry to 0.
768 : */
769 : void
770 : seed(result_type __sd = 0u);
771 :
772 : /**
773 : * @brief Seeds the initial state @f$x_0@f$ of the
774 : * % subtract_with_carry_engine random number generator.
775 : */
776 : template<typename _Sseq>
777 : _If_seed_seq<_Sseq>
778 : seed(_Sseq& __q);
779 :
780 : /**
781 : * @brief Gets the inclusive minimum value of the range of random
782 : * integers returned by this generator.
783 : */
784 : static constexpr result_type
785 : min()
786 : { return 0; }
787 :
788 : /**
789 : * @brief Gets the inclusive maximum value of the range of random
790 : * integers returned by this generator.
791 : */
792 : static constexpr result_type
793 : max()
794 : { return __detail::_Shift<_UIntType, __w>::__value - 1; }
795 :
796 : /**
797 : * @brief Discard a sequence of random numbers.
798 : */
799 : void
800 : discard(unsigned long long __z)
801 : {
802 : for (; __z != 0ULL; --__z)
803 : (*this)();
804 : }
805 :
806 : /**
807 : * @brief Gets the next random number in the sequence.
808 : */
809 : result_type
810 : operator()();
811 :
812 : /**
813 : * @brief Compares two % subtract_with_carry_engine random number
814 : * generator objects of the same type for equality.
815 : *
816 : * @param __lhs A % subtract_with_carry_engine random number generator
817 : * object.
818 : * @param __rhs Another % subtract_with_carry_engine random number
819 : * generator object.
820 : *
821 : * @returns true if the infinite sequences of generated values
822 : * would be equal, false otherwise.
823 : */
824 : friend bool
825 : operator==(const subtract_with_carry_engine& __lhs,
826 : const subtract_with_carry_engine& __rhs)
827 : { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
828 : && __lhs._M_carry == __rhs._M_carry
829 : && __lhs._M_p == __rhs._M_p); }
830 :
831 : /**
832 : * @brief Inserts the current state of a % subtract_with_carry_engine
833 : * random number generator engine @p __x into the output stream
834 : * @p __os.
835 : *
836 : * @param __os An output stream.
837 : * @param __x A % subtract_with_carry_engine random number generator
838 : * engine.
839 : *
840 : * @returns The output stream with the state of @p __x inserted or in
841 : * an error state.
842 : */
843 : template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
844 : typename _CharT, typename _Traits>
845 : friend std::basic_ostream<_CharT, _Traits>&
846 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
847 : const std::subtract_with_carry_engine<_UIntType1, __w1,
848 : __s1, __r1>& __x);
849 :
850 : /**
851 : * @brief Extracts the current state of a % subtract_with_carry_engine
852 : * random number generator engine @p __x from the input stream
853 : * @p __is.
854 : *
855 : * @param __is An input stream.
856 : * @param __x A % subtract_with_carry_engine random number generator
857 : * engine.
858 : *
859 : * @returns The input stream with the state of @p __x extracted or in
860 : * an error state.
861 : */
862 : template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
863 : typename _CharT, typename _Traits>
864 : friend std::basic_istream<_CharT, _Traits>&
865 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
866 : std::subtract_with_carry_engine<_UIntType1, __w1,
867 : __s1, __r1>& __x);
868 :
869 : private:
870 : /// The state of the generator. This is a ring buffer.
871 : _UIntType _M_x[long_lag];
872 : _UIntType _M_carry; ///< The carry
873 : size_t _M_p; ///< Current index of x(i - r).
874 : };
875 :
876 : #if __cpp_impl_three_way_comparison < 201907L
877 : /**
878 : * @brief Compares two % subtract_with_carry_engine random number
879 : * generator objects of the same type for inequality.
880 : *
881 : * @param __lhs A % subtract_with_carry_engine random number generator
882 : * object.
883 : * @param __rhs Another % subtract_with_carry_engine random number
884 : * generator object.
885 : *
886 : * @returns true if the infinite sequences of generated values
887 : * would be different, false otherwise.
888 : */
889 : template<typename _UIntType, size_t __w, size_t __s, size_t __r>
890 : inline bool
891 : operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
892 : __s, __r>& __lhs,
893 : const std::subtract_with_carry_engine<_UIntType, __w,
894 : __s, __r>& __rhs)
895 : { return !(__lhs == __rhs); }
896 : #endif
897 :
898 : /**
899 : * Produces random numbers from some base engine by discarding blocks of
900 : * data.
901 : *
902 : * @pre @f$ 0 \leq r \leq p @f$
903 : *
904 : * @headerfile random
905 : * @since C++11
906 : */
907 : template<typename _RandomNumberEngine, size_t __p, size_t __r>
908 : class discard_block_engine
909 : {
910 : static_assert(1 <= __r && __r <= __p,
911 : "template argument substituting __r out of bounds");
912 :
913 : public:
914 : /** The type of the generated random value. */
915 : typedef typename _RandomNumberEngine::result_type result_type;
916 :
917 : template<typename _Sseq>
918 : using _If_seed_seq
919 : = __detail::_If_seed_seq_for<_Sseq, discard_block_engine,
920 : result_type>;
921 :
922 : // parameter values
923 : static constexpr size_t block_size = __p;
924 : static constexpr size_t used_block = __r;
925 :
926 : /**
927 : * @brief Constructs a default %discard_block_engine engine.
928 : *
929 : * The underlying engine is default constructed as well.
930 : */
931 : discard_block_engine()
932 : : _M_b(), _M_n(0) { }
933 :
934 : /**
935 : * @brief Copy constructs a %discard_block_engine engine.
936 : *
937 : * Copies an existing base class random number generator.
938 : * @param __rng An existing (base class) engine object.
939 : */
940 : explicit
941 : discard_block_engine(const _RandomNumberEngine& __rng)
942 : : _M_b(__rng), _M_n(0) { }
943 :
944 : /**
945 : * @brief Move constructs a %discard_block_engine engine.
946 : *
947 : * Copies an existing base class random number generator.
948 : * @param __rng An existing (base class) engine object.
949 : */
950 : explicit
951 : discard_block_engine(_RandomNumberEngine&& __rng)
952 : : _M_b(std::move(__rng)), _M_n(0) { }
953 :
954 : /**
955 : * @brief Seed constructs a %discard_block_engine engine.
956 : *
957 : * Constructs the underlying generator engine seeded with @p __s.
958 : * @param __s A seed value for the base class engine.
959 : */
960 : explicit
961 : discard_block_engine(result_type __s)
962 : : _M_b(__s), _M_n(0) { }
963 :
964 : /**
965 : * @brief Generator construct a %discard_block_engine engine.
966 : *
967 : * @param __q A seed sequence.
968 : */
969 : template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
970 : explicit
971 : discard_block_engine(_Sseq& __q)
972 : : _M_b(__q), _M_n(0)
973 : { }
974 :
975 : /**
976 : * @brief Reseeds the %discard_block_engine object with the default
977 : * seed for the underlying base class generator engine.
978 : */
979 : void
980 : seed()
981 : {
982 : _M_b.seed();
983 : _M_n = 0;
984 : }
985 :
986 : /**
987 : * @brief Reseeds the %discard_block_engine object with the default
988 : * seed for the underlying base class generator engine.
989 : */
990 : void
991 : seed(result_type __s)
992 : {
993 : _M_b.seed(__s);
994 : _M_n = 0;
995 : }
996 :
997 : /**
998 : * @brief Reseeds the %discard_block_engine object with the given seed
999 : * sequence.
1000 : * @param __q A seed generator function.
1001 : */
1002 : template<typename _Sseq>
1003 : _If_seed_seq<_Sseq>
1004 : seed(_Sseq& __q)
1005 : {
1006 : _M_b.seed(__q);
1007 : _M_n = 0;
1008 : }
1009 :
1010 : /**
1011 : * @brief Gets a const reference to the underlying generator engine
1012 : * object.
1013 : */
1014 : const _RandomNumberEngine&
1015 : base() const noexcept
1016 : { return _M_b; }
1017 :
1018 : /**
1019 : * @brief Gets the minimum value in the generated random number range.
1020 : */
1021 : static constexpr result_type
1022 : min()
1023 : { return _RandomNumberEngine::min(); }
1024 :
1025 : /**
1026 : * @brief Gets the maximum value in the generated random number range.
1027 : */
1028 : static constexpr result_type
1029 : max()
1030 : { return _RandomNumberEngine::max(); }
1031 :
1032 : /**
1033 : * @brief Discard a sequence of random numbers.
1034 : */
1035 : void
1036 : discard(unsigned long long __z)
1037 : {
1038 : for (; __z != 0ULL; --__z)
1039 : (*this)();
1040 : }
1041 :
1042 : /**
1043 : * @brief Gets the next value in the generated random number sequence.
1044 : */
1045 : result_type
1046 : operator()();
1047 :
1048 : /**
1049 : * @brief Compares two %discard_block_engine random number generator
1050 : * objects of the same type for equality.
1051 : *
1052 : * @param __lhs A %discard_block_engine random number generator object.
1053 : * @param __rhs Another %discard_block_engine random number generator
1054 : * object.
1055 : *
1056 : * @returns true if the infinite sequences of generated values
1057 : * would be equal, false otherwise.
1058 : */
1059 : friend bool
1060 : operator==(const discard_block_engine& __lhs,
1061 : const discard_block_engine& __rhs)
1062 : { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
1063 :
1064 : /**
1065 : * @brief Inserts the current state of a %discard_block_engine random
1066 : * number generator engine @p __x into the output stream
1067 : * @p __os.
1068 : *
1069 : * @param __os An output stream.
1070 : * @param __x A %discard_block_engine random number generator engine.
1071 : *
1072 : * @returns The output stream with the state of @p __x inserted or in
1073 : * an error state.
1074 : */
1075 : template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
1076 : typename _CharT, typename _Traits>
1077 : friend std::basic_ostream<_CharT, _Traits>&
1078 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1079 : const std::discard_block_engine<_RandomNumberEngine1,
1080 : __p1, __r1>& __x);
1081 :
1082 : /**
1083 : * @brief Extracts the current state of a % subtract_with_carry_engine
1084 : * random number generator engine @p __x from the input stream
1085 : * @p __is.
1086 : *
1087 : * @param __is An input stream.
1088 : * @param __x A %discard_block_engine random number generator engine.
1089 : *
1090 : * @returns The input stream with the state of @p __x extracted or in
1091 : * an error state.
1092 : */
1093 : template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
1094 : typename _CharT, typename _Traits>
1095 : friend std::basic_istream<_CharT, _Traits>&
1096 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
1097 : std::discard_block_engine<_RandomNumberEngine1,
1098 : __p1, __r1>& __x);
1099 :
1100 : private:
1101 : _RandomNumberEngine _M_b;
1102 : size_t _M_n;
1103 : };
1104 :
1105 : #if __cpp_impl_three_way_comparison < 201907L
1106 : /**
1107 : * @brief Compares two %discard_block_engine random number generator
1108 : * objects of the same type for inequality.
1109 : *
1110 : * @param __lhs A %discard_block_engine random number generator object.
1111 : * @param __rhs Another %discard_block_engine random number generator
1112 : * object.
1113 : *
1114 : * @returns true if the infinite sequences of generated values
1115 : * would be different, false otherwise.
1116 : */
1117 : template<typename _RandomNumberEngine, size_t __p, size_t __r>
1118 : inline bool
1119 : operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
1120 : __r>& __lhs,
1121 : const std::discard_block_engine<_RandomNumberEngine, __p,
1122 : __r>& __rhs)
1123 : { return !(__lhs == __rhs); }
1124 : #endif
1125 :
1126 : /**
1127 : * Produces random numbers by combining random numbers from some base
1128 : * engine to produce random numbers with a specified number of bits @p __w.
1129 : *
1130 : * @headerfile random
1131 : * @since C++11
1132 : */
1133 : template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
1134 : class independent_bits_engine
1135 : {
1136 : static_assert(std::is_unsigned<_UIntType>::value,
1137 : "result_type must be an unsigned integral type");
1138 : static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
1139 : "template argument substituting __w out of bounds");
1140 :
1141 : template<typename _Sseq>
1142 : using _If_seed_seq
1143 : = __detail::_If_seed_seq_for<_Sseq, independent_bits_engine,
1144 : _UIntType>;
1145 :
1146 : public:
1147 : /** The type of the generated random value. */
1148 : typedef _UIntType result_type;
1149 :
1150 : /**
1151 : * @brief Constructs a default %independent_bits_engine engine.
1152 : *
1153 : * The underlying engine is default constructed as well.
1154 : */
1155 : independent_bits_engine()
1156 : : _M_b() { }
1157 :
1158 : /**
1159 : * @brief Copy constructs a %independent_bits_engine engine.
1160 : *
1161 : * Copies an existing base class random number generator.
1162 : * @param __rng An existing (base class) engine object.
1163 : */
1164 : explicit
1165 : independent_bits_engine(const _RandomNumberEngine& __rng)
1166 : : _M_b(__rng) { }
1167 :
1168 : /**
1169 : * @brief Move constructs a %independent_bits_engine engine.
1170 : *
1171 : * Copies an existing base class random number generator.
1172 : * @param __rng An existing (base class) engine object.
1173 : */
1174 : explicit
1175 : independent_bits_engine(_RandomNumberEngine&& __rng)
1176 : : _M_b(std::move(__rng)) { }
1177 :
1178 : /**
1179 : * @brief Seed constructs a %independent_bits_engine engine.
1180 : *
1181 : * Constructs the underlying generator engine seeded with @p __s.
1182 : * @param __s A seed value for the base class engine.
1183 : */
1184 : explicit
1185 : independent_bits_engine(result_type __s)
1186 : : _M_b(__s) { }
1187 :
1188 : /**
1189 : * @brief Generator construct a %independent_bits_engine engine.
1190 : *
1191 : * @param __q A seed sequence.
1192 : */
1193 : template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
1194 : explicit
1195 : independent_bits_engine(_Sseq& __q)
1196 : : _M_b(__q)
1197 : { }
1198 :
1199 : /**
1200 : * @brief Reseeds the %independent_bits_engine object with the default
1201 : * seed for the underlying base class generator engine.
1202 : */
1203 : void
1204 : seed()
1205 : { _M_b.seed(); }
1206 :
1207 : /**
1208 : * @brief Reseeds the %independent_bits_engine object with the default
1209 : * seed for the underlying base class generator engine.
1210 : */
1211 : void
1212 : seed(result_type __s)
1213 : { _M_b.seed(__s); }
1214 :
1215 : /**
1216 : * @brief Reseeds the %independent_bits_engine object with the given
1217 : * seed sequence.
1218 : * @param __q A seed generator function.
1219 : */
1220 : template<typename _Sseq>
1221 : _If_seed_seq<_Sseq>
1222 : seed(_Sseq& __q)
1223 : { _M_b.seed(__q); }
1224 :
1225 : /**
1226 : * @brief Gets a const reference to the underlying generator engine
1227 : * object.
1228 : */
1229 : const _RandomNumberEngine&
1230 : base() const noexcept
1231 : { return _M_b; }
1232 :
1233 : /**
1234 : * @brief Gets the minimum value in the generated random number range.
1235 : */
1236 : static constexpr result_type
1237 : min()
1238 : { return 0U; }
1239 :
1240 : /**
1241 : * @brief Gets the maximum value in the generated random number range.
1242 : */
1243 : static constexpr result_type
1244 : max()
1245 : { return __detail::_Shift<_UIntType, __w>::__value - 1; }
1246 :
1247 : /**
1248 : * @brief Discard a sequence of random numbers.
1249 : */
1250 : void
1251 : discard(unsigned long long __z)
1252 : {
1253 : for (; __z != 0ULL; --__z)
1254 : (*this)();
1255 : }
1256 :
1257 : /**
1258 : * @brief Gets the next value in the generated random number sequence.
1259 : */
1260 : result_type
1261 : operator()();
1262 :
1263 : /**
1264 : * @brief Compares two %independent_bits_engine random number generator
1265 : * objects of the same type for equality.
1266 : *
1267 : * @param __lhs A %independent_bits_engine random number generator
1268 : * object.
1269 : * @param __rhs Another %independent_bits_engine random number generator
1270 : * object.
1271 : *
1272 : * @returns true if the infinite sequences of generated values
1273 : * would be equal, false otherwise.
1274 : */
1275 : friend bool
1276 : operator==(const independent_bits_engine& __lhs,
1277 : const independent_bits_engine& __rhs)
1278 : { return __lhs._M_b == __rhs._M_b; }
1279 :
1280 : /**
1281 : * @brief Extracts the current state of a % subtract_with_carry_engine
1282 : * random number generator engine @p __x from the input stream
1283 : * @p __is.
1284 : *
1285 : * @param __is An input stream.
1286 : * @param __x A %independent_bits_engine random number generator
1287 : * engine.
1288 : *
1289 : * @returns The input stream with the state of @p __x extracted or in
1290 : * an error state.
1291 : */
1292 : template<typename _CharT, typename _Traits>
1293 : friend std::basic_istream<_CharT, _Traits>&
1294 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
1295 : std::independent_bits_engine<_RandomNumberEngine,
1296 : __w, _UIntType>& __x)
1297 : {
1298 : __is >> __x._M_b;
1299 : return __is;
1300 : }
1301 :
1302 : private:
1303 : _RandomNumberEngine _M_b;
1304 : };
1305 :
1306 : #if __cpp_impl_three_way_comparison < 201907L
1307 : /**
1308 : * @brief Compares two %independent_bits_engine random number generator
1309 : * objects of the same type for inequality.
1310 : *
1311 : * @param __lhs A %independent_bits_engine random number generator
1312 : * object.
1313 : * @param __rhs Another %independent_bits_engine random number generator
1314 : * object.
1315 : *
1316 : * @returns true if the infinite sequences of generated values
1317 : * would be different, false otherwise.
1318 : */
1319 : template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
1320 : inline bool
1321 : operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
1322 : _UIntType>& __lhs,
1323 : const std::independent_bits_engine<_RandomNumberEngine, __w,
1324 : _UIntType>& __rhs)
1325 : { return !(__lhs == __rhs); }
1326 : #endif
1327 :
1328 : /**
1329 : * @brief Inserts the current state of a %independent_bits_engine random
1330 : * number generator engine @p __x into the output stream @p __os.
1331 : *
1332 : * @param __os An output stream.
1333 : * @param __x A %independent_bits_engine random number generator engine.
1334 : *
1335 : * @returns The output stream with the state of @p __x inserted or in
1336 : * an error state.
1337 : */
1338 : template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
1339 : typename _CharT, typename _Traits>
1340 : std::basic_ostream<_CharT, _Traits>&
1341 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1342 : const std::independent_bits_engine<_RandomNumberEngine,
1343 : __w, _UIntType>& __x)
1344 : {
1345 : __os << __x.base();
1346 : return __os;
1347 : }
1348 :
1349 :
1350 : /**
1351 : * @brief Produces random numbers by reordering random numbers from some
1352 : * base engine.
1353 : *
1354 : * The values from the base engine are stored in a sequence of size @p __k
1355 : * and shuffled by an algorithm that depends on those values.
1356 : *
1357 : * @headerfile random
1358 : * @since C++11
1359 : */
1360 : template<typename _RandomNumberEngine, size_t __k>
1361 : class shuffle_order_engine
1362 : {
1363 : static_assert(1u <= __k, "template argument substituting "
1364 : "__k out of bound");
1365 :
1366 : public:
1367 : /** The type of the generated random value. */
1368 : typedef typename _RandomNumberEngine::result_type result_type;
1369 :
1370 : template<typename _Sseq>
1371 : using _If_seed_seq
1372 : = __detail::_If_seed_seq_for<_Sseq, shuffle_order_engine,
1373 : result_type>;
1374 :
1375 : static constexpr size_t table_size = __k;
1376 :
1377 : /**
1378 : * @brief Constructs a default %shuffle_order_engine engine.
1379 : *
1380 : * The underlying engine is default constructed as well.
1381 : */
1382 : shuffle_order_engine()
1383 : : _M_b()
1384 : { _M_initialize(); }
1385 :
1386 : /**
1387 : * @brief Copy constructs a %shuffle_order_engine engine.
1388 : *
1389 : * Copies an existing base class random number generator.
1390 : * @param __rng An existing (base class) engine object.
1391 : */
1392 : explicit
1393 : shuffle_order_engine(const _RandomNumberEngine& __rng)
1394 : : _M_b(__rng)
1395 : { _M_initialize(); }
1396 :
1397 : /**
1398 : * @brief Move constructs a %shuffle_order_engine engine.
1399 : *
1400 : * Copies an existing base class random number generator.
1401 : * @param __rng An existing (base class) engine object.
1402 : */
1403 : explicit
1404 : shuffle_order_engine(_RandomNumberEngine&& __rng)
1405 : : _M_b(std::move(__rng))
1406 : { _M_initialize(); }
1407 :
1408 : /**
1409 : * @brief Seed constructs a %shuffle_order_engine engine.
1410 : *
1411 : * Constructs the underlying generator engine seeded with @p __s.
1412 : * @param __s A seed value for the base class engine.
1413 : */
1414 : explicit
1415 : shuffle_order_engine(result_type __s)
1416 : : _M_b(__s)
1417 : { _M_initialize(); }
1418 :
1419 : /**
1420 : * @brief Generator construct a %shuffle_order_engine engine.
1421 : *
1422 : * @param __q A seed sequence.
1423 : */
1424 : template<typename _Sseq, typename = _If_seed_seq<_Sseq>>
1425 : explicit
1426 : shuffle_order_engine(_Sseq& __q)
1427 : : _M_b(__q)
1428 : { _M_initialize(); }
1429 :
1430 : /**
1431 : * @brief Reseeds the %shuffle_order_engine object with the default seed
1432 : for the underlying base class generator engine.
1433 : */
1434 : void
1435 : seed()
1436 : {
1437 : _M_b.seed();
1438 : _M_initialize();
1439 : }
1440 :
1441 : /**
1442 : * @brief Reseeds the %shuffle_order_engine object with the default seed
1443 : * for the underlying base class generator engine.
1444 : */
1445 : void
1446 : seed(result_type __s)
1447 : {
1448 : _M_b.seed(__s);
1449 : _M_initialize();
1450 : }
1451 :
1452 : /**
1453 : * @brief Reseeds the %shuffle_order_engine object with the given seed
1454 : * sequence.
1455 : * @param __q A seed generator function.
1456 : */
1457 : template<typename _Sseq>
1458 : _If_seed_seq<_Sseq>
1459 : seed(_Sseq& __q)
1460 : {
1461 : _M_b.seed(__q);
1462 : _M_initialize();
1463 : }
1464 :
1465 : /**
1466 : * Gets a const reference to the underlying generator engine object.
1467 : */
1468 : const _RandomNumberEngine&
1469 : base() const noexcept
1470 : { return _M_b; }
1471 :
1472 : /**
1473 : * Gets the minimum value in the generated random number range.
1474 : */
1475 : static constexpr result_type
1476 : min()
1477 : { return _RandomNumberEngine::min(); }
1478 :
1479 : /**
1480 : * Gets the maximum value in the generated random number range.
1481 : */
1482 : static constexpr result_type
1483 : max()
1484 : { return _RandomNumberEngine::max(); }
1485 :
1486 : /**
1487 : * Discard a sequence of random numbers.
1488 : */
1489 : void
1490 : discard(unsigned long long __z)
1491 : {
1492 : for (; __z != 0ULL; --__z)
1493 : (*this)();
1494 : }
1495 :
1496 : /**
1497 : * Gets the next value in the generated random number sequence.
1498 : */
1499 : result_type
1500 : operator()();
1501 :
1502 : /**
1503 : * Compares two %shuffle_order_engine random number generator objects
1504 : * of the same type for equality.
1505 : *
1506 : * @param __lhs A %shuffle_order_engine random number generator object.
1507 : * @param __rhs Another %shuffle_order_engine random number generator
1508 : * object.
1509 : *
1510 : * @returns true if the infinite sequences of generated values
1511 : * would be equal, false otherwise.
1512 : */
1513 : friend bool
1514 : operator==(const shuffle_order_engine& __lhs,
1515 : const shuffle_order_engine& __rhs)
1516 : { return (__lhs._M_b == __rhs._M_b
1517 : && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
1518 : && __lhs._M_y == __rhs._M_y); }
1519 :
1520 : /**
1521 : * @brief Inserts the current state of a %shuffle_order_engine random
1522 : * number generator engine @p __x into the output stream
1523 : @p __os.
1524 : *
1525 : * @param __os An output stream.
1526 : * @param __x A %shuffle_order_engine random number generator engine.
1527 : *
1528 : * @returns The output stream with the state of @p __x inserted or in
1529 : * an error state.
1530 : */
1531 : template<typename _RandomNumberEngine1, size_t __k1,
1532 : typename _CharT, typename _Traits>
1533 : friend std::basic_ostream<_CharT, _Traits>&
1534 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1535 : const std::shuffle_order_engine<_RandomNumberEngine1,
1536 : __k1>& __x);
1537 :
1538 : /**
1539 : * @brief Extracts the current state of a % subtract_with_carry_engine
1540 : * random number generator engine @p __x from the input stream
1541 : * @p __is.
1542 : *
1543 : * @param __is An input stream.
1544 : * @param __x A %shuffle_order_engine random number generator engine.
1545 : *
1546 : * @returns The input stream with the state of @p __x extracted or in
1547 : * an error state.
1548 : */
1549 : template<typename _RandomNumberEngine1, size_t __k1,
1550 : typename _CharT, typename _Traits>
1551 : friend std::basic_istream<_CharT, _Traits>&
1552 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
1553 : std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
1554 :
1555 : private:
1556 : void _M_initialize()
1557 : {
1558 : for (size_t __i = 0; __i < __k; ++__i)
1559 : _M_v[__i] = _M_b();
1560 : _M_y = _M_b();
1561 : }
1562 :
1563 : _RandomNumberEngine _M_b;
1564 : result_type _M_v[__k];
1565 : result_type _M_y;
1566 : };
1567 :
1568 : #if __cpp_impl_three_way_comparison < 201907L
1569 : /**
1570 : * Compares two %shuffle_order_engine random number generator objects
1571 : * of the same type for inequality.
1572 : *
1573 : * @param __lhs A %shuffle_order_engine random number generator object.
1574 : * @param __rhs Another %shuffle_order_engine random number generator
1575 : * object.
1576 : *
1577 : * @returns true if the infinite sequences of generated values
1578 : * would be different, false otherwise.
1579 : */
1580 : template<typename _RandomNumberEngine, size_t __k>
1581 : inline bool
1582 : operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
1583 : __k>& __lhs,
1584 : const std::shuffle_order_engine<_RandomNumberEngine,
1585 : __k>& __rhs)
1586 : { return !(__lhs == __rhs); }
1587 : #endif
1588 :
1589 : /**
1590 : * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
1591 : */
1592 : typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
1593 : minstd_rand0;
1594 :
1595 : /**
1596 : * An alternative LCR (Lehmer Generator function).
1597 : */
1598 : typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
1599 : minstd_rand;
1600 :
1601 : /**
1602 : * The classic Mersenne Twister.
1603 : *
1604 : * Reference:
1605 : * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
1606 : * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
1607 : * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
1608 : */
1609 : typedef mersenne_twister_engine<
1610 : uint_fast32_t,
1611 : 32, 624, 397, 31,
1612 : 0x9908b0dfUL, 11,
1613 : 0xffffffffUL, 7,
1614 : 0x9d2c5680UL, 15,
1615 : 0xefc60000UL, 18, 1812433253UL> mt19937;
1616 :
1617 : /**
1618 : * An alternative Mersenne Twister.
1619 : */
1620 : typedef mersenne_twister_engine<
1621 : uint_fast64_t,
1622 : 64, 312, 156, 31,
1623 : 0xb5026f5aa96619e9ULL, 29,
1624 : 0x5555555555555555ULL, 17,
1625 : 0x71d67fffeda60000ULL, 37,
1626 : 0xfff7eee000000000ULL, 43,
1627 : 6364136223846793005ULL> mt19937_64;
1628 :
1629 : typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
1630 : ranlux24_base;
1631 :
1632 : typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
1633 : ranlux48_base;
1634 :
1635 : typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
1636 :
1637 : typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
1638 :
1639 : typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
1640 :
1641 : typedef minstd_rand0 default_random_engine;
1642 :
1643 : /**
1644 : * A standard interface to a platform-specific non-deterministic
1645 : * random number generator (if any are available).
1646 : *
1647 : * @headerfile random
1648 : * @since C++11
1649 : */
1650 : class random_device
1651 : {
1652 : public:
1653 : /** The type of the generated random value. */
1654 : typedef unsigned int result_type;
1655 :
1656 : // constructors, destructors and member functions
1657 :
1658 756 : random_device() { _M_init("default"); }
1659 :
1660 : explicit
1661 : random_device(const std::string& __token) { _M_init(__token); }
1662 :
1663 252 : ~random_device()
1664 252 : { _M_fini(); }
1665 :
1666 : static constexpr result_type
1667 : min()
1668 : { return std::numeric_limits<result_type>::min(); }
1669 :
1670 : static constexpr result_type
1671 : max()
1672 : { return std::numeric_limits<result_type>::max(); }
1673 :
1674 : double
1675 : entropy() const noexcept
1676 : { return this->_M_getentropy(); }
1677 :
1678 : result_type
1679 2 : operator()()
1680 2 : { return this->_M_getval(); }
1681 :
1682 : // No copy functions.
1683 : random_device(const random_device&) = delete;
1684 : void operator=(const random_device&) = delete;
1685 :
1686 : private:
1687 :
1688 : void _M_init(const std::string& __token);
1689 : void _M_init_pretr1(const std::string& __token);
1690 : void _M_fini();
1691 :
1692 : result_type _M_getval();
1693 : result_type _M_getval_pretr1();
1694 : double _M_getentropy() const noexcept;
1695 :
1696 : void _M_init(const char*, size_t); // not exported from the shared library
1697 :
1698 : __extension__ union
1699 : {
1700 : struct
1701 : {
1702 : void* _M_file;
1703 : result_type (*_M_func)(void*);
1704 : int _M_fd;
1705 : };
1706 : mt19937 _M_mt;
1707 : };
1708 : };
1709 :
1710 : /// @} group random_generators
1711 :
1712 : /**
1713 : * @addtogroup random_distributions Random Number Distributions
1714 : * @ingroup random
1715 : * @{
1716 : */
1717 :
1718 : /**
1719 : * @addtogroup random_distributions_uniform Uniform Distributions
1720 : * @ingroup random_distributions
1721 : * @{
1722 : */
1723 :
1724 : // std::uniform_int_distribution is defined in <bits/uniform_int_dist.h>
1725 :
1726 : #if __cpp_impl_three_way_comparison < 201907L
1727 : /**
1728 : * @brief Return true if two uniform integer distributions have
1729 : * different parameters.
1730 : */
1731 : template<typename _IntType>
1732 : inline bool
1733 : operator!=(const std::uniform_int_distribution<_IntType>& __d1,
1734 : const std::uniform_int_distribution<_IntType>& __d2)
1735 : { return !(__d1 == __d2); }
1736 : #endif
1737 :
1738 : /**
1739 : * @brief Inserts a %uniform_int_distribution random number
1740 : * distribution @p __x into the output stream @p os.
1741 : *
1742 : * @param __os An output stream.
1743 : * @param __x A %uniform_int_distribution random number distribution.
1744 : *
1745 : * @returns The output stream with the state of @p __x inserted or in
1746 : * an error state.
1747 : */
1748 : template<typename _IntType, typename _CharT, typename _Traits>
1749 : std::basic_ostream<_CharT, _Traits>&
1750 : operator<<(std::basic_ostream<_CharT, _Traits>&,
1751 : const std::uniform_int_distribution<_IntType>&);
1752 :
1753 : /**
1754 : * @brief Extracts a %uniform_int_distribution random number distribution
1755 : * @p __x from the input stream @p __is.
1756 : *
1757 : * @param __is An input stream.
1758 : * @param __x A %uniform_int_distribution random number generator engine.
1759 : *
1760 : * @returns The input stream with @p __x extracted or in an error state.
1761 : */
1762 : template<typename _IntType, typename _CharT, typename _Traits>
1763 : std::basic_istream<_CharT, _Traits>&
1764 : operator>>(std::basic_istream<_CharT, _Traits>&,
1765 : std::uniform_int_distribution<_IntType>&);
1766 :
1767 :
1768 : /**
1769 : * @brief Uniform continuous distribution for random numbers.
1770 : *
1771 : * A continuous random distribution on the range [min, max) with equal
1772 : * probability throughout the range. The URNG should be real-valued and
1773 : * deliver number in the range [0, 1).
1774 : *
1775 : * @headerfile random
1776 : * @since C++11
1777 : */
1778 : template<typename _RealType = double>
1779 : class uniform_real_distribution
1780 : {
1781 : static_assert(std::is_floating_point<_RealType>::value,
1782 : "result_type must be a floating point type");
1783 :
1784 : public:
1785 : /** The type of the range of the distribution. */
1786 : typedef _RealType result_type;
1787 :
1788 : /** Parameter type. */
1789 : struct param_type
1790 : {
1791 : typedef uniform_real_distribution<_RealType> distribution_type;
1792 :
1793 : param_type() : param_type(0) { }
1794 :
1795 : explicit
1796 : param_type(_RealType __a, _RealType __b = _RealType(1))
1797 : : _M_a(__a), _M_b(__b)
1798 : {
1799 : __glibcxx_assert(_M_a <= _M_b);
1800 : }
1801 :
1802 : result_type
1803 : a() const
1804 : { return _M_a; }
1805 :
1806 : result_type
1807 : b() const
1808 : { return _M_b; }
1809 :
1810 : friend bool
1811 : operator==(const param_type& __p1, const param_type& __p2)
1812 : { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
1813 :
1814 : #if __cpp_impl_three_way_comparison < 201907L
1815 : friend bool
1816 : operator!=(const param_type& __p1, const param_type& __p2)
1817 : { return !(__p1 == __p2); }
1818 : #endif
1819 :
1820 : private:
1821 : _RealType _M_a;
1822 : _RealType _M_b;
1823 : };
1824 :
1825 : public:
1826 : /**
1827 : * @brief Constructs a uniform_real_distribution object.
1828 : *
1829 : * The lower bound is set to 0.0 and the upper bound to 1.0
1830 : */
1831 : uniform_real_distribution() : uniform_real_distribution(0.0) { }
1832 :
1833 : /**
1834 : * @brief Constructs a uniform_real_distribution object.
1835 : *
1836 : * @param __a [IN] The lower bound of the distribution.
1837 : * @param __b [IN] The upper bound of the distribution.
1838 : */
1839 : explicit
1840 : uniform_real_distribution(_RealType __a, _RealType __b = _RealType(1))
1841 : : _M_param(__a, __b)
1842 : { }
1843 :
1844 : explicit
1845 : uniform_real_distribution(const param_type& __p)
1846 : : _M_param(__p)
1847 : { }
1848 :
1849 : /**
1850 : * @brief Resets the distribution state.
1851 : *
1852 : * Does nothing for the uniform real distribution.
1853 : */
1854 : void
1855 : reset() { }
1856 :
1857 : result_type
1858 : a() const
1859 : { return _M_param.a(); }
1860 :
1861 : result_type
1862 : b() const
1863 : { return _M_param.b(); }
1864 :
1865 : /**
1866 : * @brief Returns the parameter set of the distribution.
1867 : */
1868 : param_type
1869 : param() const
1870 : { return _M_param; }
1871 :
1872 : /**
1873 : * @brief Sets the parameter set of the distribution.
1874 : * @param __param The new parameter set of the distribution.
1875 : */
1876 : void
1877 : param(const param_type& __param)
1878 : { _M_param = __param; }
1879 :
1880 : /**
1881 : * @brief Returns the inclusive lower bound of the distribution range.
1882 : */
1883 : result_type
1884 : min() const
1885 : { return this->a(); }
1886 :
1887 : /**
1888 : * @brief Returns the inclusive upper bound of the distribution range.
1889 : */
1890 : result_type
1891 : max() const
1892 : { return this->b(); }
1893 :
1894 : /**
1895 : * @brief Generating functions.
1896 : */
1897 : template<typename _UniformRandomNumberGenerator>
1898 : result_type
1899 : operator()(_UniformRandomNumberGenerator& __urng)
1900 : { return this->operator()(__urng, _M_param); }
1901 :
1902 : template<typename _UniformRandomNumberGenerator>
1903 : result_type
1904 : operator()(_UniformRandomNumberGenerator& __urng,
1905 : const param_type& __p)
1906 : {
1907 : __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1908 : __aurng(__urng);
1909 : return (__aurng() * (__p.b() - __p.a())) + __p.a();
1910 : }
1911 :
1912 : template<typename _ForwardIterator,
1913 : typename _UniformRandomNumberGenerator>
1914 : void
1915 : __generate(_ForwardIterator __f, _ForwardIterator __t,
1916 : _UniformRandomNumberGenerator& __urng)
1917 : { this->__generate(__f, __t, __urng, _M_param); }
1918 :
1919 : template<typename _ForwardIterator,
1920 : typename _UniformRandomNumberGenerator>
1921 : void
1922 : __generate(_ForwardIterator __f, _ForwardIterator __t,
1923 : _UniformRandomNumberGenerator& __urng,
1924 : const param_type& __p)
1925 : { this->__generate_impl(__f, __t, __urng, __p); }
1926 :
1927 : template<typename _UniformRandomNumberGenerator>
1928 : void
1929 : __generate(result_type* __f, result_type* __t,
1930 : _UniformRandomNumberGenerator& __urng,
1931 : const param_type& __p)
1932 : { this->__generate_impl(__f, __t, __urng, __p); }
1933 :
1934 : /**
1935 : * @brief Return true if two uniform real distributions have
1936 : * the same parameters.
1937 : */
1938 : friend bool
1939 : operator==(const uniform_real_distribution& __d1,
1940 : const uniform_real_distribution& __d2)
1941 : { return __d1._M_param == __d2._M_param; }
1942 :
1943 : private:
1944 : template<typename _ForwardIterator,
1945 : typename _UniformRandomNumberGenerator>
1946 : void
1947 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1948 : _UniformRandomNumberGenerator& __urng,
1949 : const param_type& __p);
1950 :
1951 : param_type _M_param;
1952 : };
1953 :
1954 : #if __cpp_impl_three_way_comparison < 201907L
1955 : /**
1956 : * @brief Return true if two uniform real distributions have
1957 : * different parameters.
1958 : */
1959 : template<typename _IntType>
1960 : inline bool
1961 : operator!=(const std::uniform_real_distribution<_IntType>& __d1,
1962 : const std::uniform_real_distribution<_IntType>& __d2)
1963 : { return !(__d1 == __d2); }
1964 : #endif
1965 :
1966 : /**
1967 : * @brief Inserts a %uniform_real_distribution random number
1968 : * distribution @p __x into the output stream @p __os.
1969 : *
1970 : * @param __os An output stream.
1971 : * @param __x A %uniform_real_distribution random number distribution.
1972 : *
1973 : * @returns The output stream with the state of @p __x inserted or in
1974 : * an error state.
1975 : */
1976 : template<typename _RealType, typename _CharT, typename _Traits>
1977 : std::basic_ostream<_CharT, _Traits>&
1978 : operator<<(std::basic_ostream<_CharT, _Traits>&,
1979 : const std::uniform_real_distribution<_RealType>&);
1980 :
1981 : /**
1982 : * @brief Extracts a %uniform_real_distribution random number distribution
1983 : * @p __x from the input stream @p __is.
1984 : *
1985 : * @param __is An input stream.
1986 : * @param __x A %uniform_real_distribution random number generator engine.
1987 : *
1988 : * @returns The input stream with @p __x extracted or in an error state.
1989 : */
1990 : template<typename _RealType, typename _CharT, typename _Traits>
1991 : std::basic_istream<_CharT, _Traits>&
1992 : operator>>(std::basic_istream<_CharT, _Traits>&,
1993 : std::uniform_real_distribution<_RealType>&);
1994 :
1995 : /// @} group random_distributions_uniform
1996 :
1997 : /**
1998 : * @addtogroup random_distributions_normal Normal Distributions
1999 : * @ingroup random_distributions
2000 : * @{
2001 : */
2002 :
2003 : /**
2004 : * @brief A normal continuous distribution for random numbers.
2005 : *
2006 : * The formula for the normal probability density function is
2007 : * @f[
2008 : * p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
2009 : * e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} }
2010 : * @f]
2011 : *
2012 : * @headerfile random
2013 : * @since C++11
2014 : */
2015 : template<typename _RealType = double>
2016 : class normal_distribution
2017 : {
2018 : static_assert(std::is_floating_point<_RealType>::value,
2019 : "result_type must be a floating point type");
2020 :
2021 : public:
2022 : /** The type of the range of the distribution. */
2023 : typedef _RealType result_type;
2024 :
2025 : /** Parameter type. */
2026 : struct param_type
2027 : {
2028 : typedef normal_distribution<_RealType> distribution_type;
2029 :
2030 : param_type() : param_type(0.0) { }
2031 :
2032 : explicit
2033 : param_type(_RealType __mean, _RealType __stddev = _RealType(1))
2034 : : _M_mean(__mean), _M_stddev(__stddev)
2035 : {
2036 : __glibcxx_assert(_M_stddev > _RealType(0));
2037 : }
2038 :
2039 : _RealType
2040 : mean() const
2041 : { return _M_mean; }
2042 :
2043 : _RealType
2044 : stddev() const
2045 : { return _M_stddev; }
2046 :
2047 : friend bool
2048 : operator==(const param_type& __p1, const param_type& __p2)
2049 : { return (__p1._M_mean == __p2._M_mean
2050 : && __p1._M_stddev == __p2._M_stddev); }
2051 :
2052 : #if __cpp_impl_three_way_comparison < 201907L
2053 : friend bool
2054 : operator!=(const param_type& __p1, const param_type& __p2)
2055 : { return !(__p1 == __p2); }
2056 : #endif
2057 :
2058 : private:
2059 : _RealType _M_mean;
2060 : _RealType _M_stddev;
2061 : };
2062 :
2063 : public:
2064 : normal_distribution() : normal_distribution(0.0) { }
2065 :
2066 : /**
2067 : * Constructs a normal distribution with parameters @f$mean@f$ and
2068 : * standard deviation.
2069 : */
2070 : explicit
2071 : normal_distribution(result_type __mean,
2072 : result_type __stddev = result_type(1))
2073 : : _M_param(__mean, __stddev)
2074 : { }
2075 :
2076 : explicit
2077 : normal_distribution(const param_type& __p)
2078 : : _M_param(__p)
2079 : { }
2080 :
2081 : /**
2082 : * @brief Resets the distribution state.
2083 : */
2084 : void
2085 : reset()
2086 : { _M_saved_available = false; }
2087 :
2088 : /**
2089 : * @brief Returns the mean of the distribution.
2090 : */
2091 : _RealType
2092 : mean() const
2093 : { return _M_param.mean(); }
2094 :
2095 : /**
2096 : * @brief Returns the standard deviation of the distribution.
2097 : */
2098 : _RealType
2099 : stddev() const
2100 : { return _M_param.stddev(); }
2101 :
2102 : /**
2103 : * @brief Returns the parameter set of the distribution.
2104 : */
2105 : param_type
2106 : param() const
2107 : { return _M_param; }
2108 :
2109 : /**
2110 : * @brief Sets the parameter set of the distribution.
2111 : * @param __param The new parameter set of the distribution.
2112 : */
2113 : void
2114 : param(const param_type& __param)
2115 : { _M_param = __param; }
2116 :
2117 : /**
2118 : * @brief Returns the greatest lower bound value of the distribution.
2119 : */
2120 : result_type
2121 : min() const
2122 : { return std::numeric_limits<result_type>::lowest(); }
2123 :
2124 : /**
2125 : * @brief Returns the least upper bound value of the distribution.
2126 : */
2127 : result_type
2128 : max() const
2129 : { return std::numeric_limits<result_type>::max(); }
2130 :
2131 : /**
2132 : * @brief Generating functions.
2133 : */
2134 : template<typename _UniformRandomNumberGenerator>
2135 : result_type
2136 : operator()(_UniformRandomNumberGenerator& __urng)
2137 : { return this->operator()(__urng, _M_param); }
2138 :
2139 : template<typename _UniformRandomNumberGenerator>
2140 : result_type
2141 : operator()(_UniformRandomNumberGenerator& __urng,
2142 : const param_type& __p);
2143 :
2144 : template<typename _ForwardIterator,
2145 : typename _UniformRandomNumberGenerator>
2146 : void
2147 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2148 : _UniformRandomNumberGenerator& __urng)
2149 : { this->__generate(__f, __t, __urng, _M_param); }
2150 :
2151 : template<typename _ForwardIterator,
2152 : typename _UniformRandomNumberGenerator>
2153 : void
2154 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2155 : _UniformRandomNumberGenerator& __urng,
2156 : const param_type& __p)
2157 : { this->__generate_impl(__f, __t, __urng, __p); }
2158 :
2159 : template<typename _UniformRandomNumberGenerator>
2160 : void
2161 : __generate(result_type* __f, result_type* __t,
2162 : _UniformRandomNumberGenerator& __urng,
2163 : const param_type& __p)
2164 : { this->__generate_impl(__f, __t, __urng, __p); }
2165 :
2166 : /**
2167 : * @brief Return true if two normal distributions have
2168 : * the same parameters and the sequences that would
2169 : * be generated are equal.
2170 : */
2171 : template<typename _RealType1>
2172 : friend bool
2173 : operator==(const std::normal_distribution<_RealType1>& __d1,
2174 : const std::normal_distribution<_RealType1>& __d2);
2175 :
2176 : /**
2177 : * @brief Inserts a %normal_distribution random number distribution
2178 : * @p __x into the output stream @p __os.
2179 : *
2180 : * @param __os An output stream.
2181 : * @param __x A %normal_distribution random number distribution.
2182 : *
2183 : * @returns The output stream with the state of @p __x inserted or in
2184 : * an error state.
2185 : */
2186 : template<typename _RealType1, typename _CharT, typename _Traits>
2187 : friend std::basic_ostream<_CharT, _Traits>&
2188 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2189 : const std::normal_distribution<_RealType1>& __x);
2190 :
2191 : /**
2192 : * @brief Extracts a %normal_distribution random number distribution
2193 : * @p __x from the input stream @p __is.
2194 : *
2195 : * @param __is An input stream.
2196 : * @param __x A %normal_distribution random number generator engine.
2197 : *
2198 : * @returns The input stream with @p __x extracted or in an error
2199 : * state.
2200 : */
2201 : template<typename _RealType1, typename _CharT, typename _Traits>
2202 : friend std::basic_istream<_CharT, _Traits>&
2203 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
2204 : std::normal_distribution<_RealType1>& __x);
2205 :
2206 : private:
2207 : template<typename _ForwardIterator,
2208 : typename _UniformRandomNumberGenerator>
2209 : void
2210 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2211 : _UniformRandomNumberGenerator& __urng,
2212 : const param_type& __p);
2213 :
2214 : param_type _M_param;
2215 : result_type _M_saved = 0;
2216 : bool _M_saved_available = false;
2217 : };
2218 :
2219 : #if __cpp_impl_three_way_comparison < 201907L
2220 : /**
2221 : * @brief Return true if two normal distributions are different.
2222 : */
2223 : template<typename _RealType>
2224 : inline bool
2225 : operator!=(const std::normal_distribution<_RealType>& __d1,
2226 : const std::normal_distribution<_RealType>& __d2)
2227 : { return !(__d1 == __d2); }
2228 : #endif
2229 :
2230 : /**
2231 : * @brief A lognormal_distribution random number distribution.
2232 : *
2233 : * The formula for the normal probability mass function is
2234 : * @f[
2235 : * p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
2236 : * \exp{-\frac{(\ln{x} - m)^2}{2s^2}}
2237 : * @f]
2238 : *
2239 : * @headerfile random
2240 : * @since C++11
2241 : */
2242 : template<typename _RealType = double>
2243 : class lognormal_distribution
2244 : {
2245 : static_assert(std::is_floating_point<_RealType>::value,
2246 : "result_type must be a floating point type");
2247 :
2248 : public:
2249 : /** The type of the range of the distribution. */
2250 : typedef _RealType result_type;
2251 :
2252 : /** Parameter type. */
2253 : struct param_type
2254 : {
2255 : typedef lognormal_distribution<_RealType> distribution_type;
2256 :
2257 : param_type() : param_type(0.0) { }
2258 :
2259 : explicit
2260 : param_type(_RealType __m, _RealType __s = _RealType(1))
2261 : : _M_m(__m), _M_s(__s)
2262 : { }
2263 :
2264 : _RealType
2265 : m() const
2266 : { return _M_m; }
2267 :
2268 : _RealType
2269 : s() const
2270 : { return _M_s; }
2271 :
2272 : friend bool
2273 : operator==(const param_type& __p1, const param_type& __p2)
2274 : { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
2275 :
2276 : #if __cpp_impl_three_way_comparison < 201907L
2277 : friend bool
2278 : operator!=(const param_type& __p1, const param_type& __p2)
2279 : { return !(__p1 == __p2); }
2280 : #endif
2281 :
2282 : private:
2283 : _RealType _M_m;
2284 : _RealType _M_s;
2285 : };
2286 :
2287 : lognormal_distribution() : lognormal_distribution(0.0) { }
2288 :
2289 : explicit
2290 : lognormal_distribution(_RealType __m, _RealType __s = _RealType(1))
2291 : : _M_param(__m, __s), _M_nd()
2292 : { }
2293 :
2294 : explicit
2295 : lognormal_distribution(const param_type& __p)
2296 : : _M_param(__p), _M_nd()
2297 : { }
2298 :
2299 : /**
2300 : * Resets the distribution state.
2301 : */
2302 : void
2303 : reset()
2304 : { _M_nd.reset(); }
2305 :
2306 : /**
2307 : *
2308 : */
2309 : _RealType
2310 : m() const
2311 : { return _M_param.m(); }
2312 :
2313 : _RealType
2314 : s() const
2315 : { return _M_param.s(); }
2316 :
2317 : /**
2318 : * @brief Returns the parameter set of the distribution.
2319 : */
2320 : param_type
2321 : param() const
2322 : { return _M_param; }
2323 :
2324 : /**
2325 : * @brief Sets the parameter set of the distribution.
2326 : * @param __param The new parameter set of the distribution.
2327 : */
2328 : void
2329 : param(const param_type& __param)
2330 : { _M_param = __param; }
2331 :
2332 : /**
2333 : * @brief Returns the greatest lower bound value of the distribution.
2334 : */
2335 : result_type
2336 : min() const
2337 : { return result_type(0); }
2338 :
2339 : /**
2340 : * @brief Returns the least upper bound value of the distribution.
2341 : */
2342 : result_type
2343 : max() const
2344 : { return std::numeric_limits<result_type>::max(); }
2345 :
2346 : /**
2347 : * @brief Generating functions.
2348 : */
2349 : template<typename _UniformRandomNumberGenerator>
2350 : result_type
2351 : operator()(_UniformRandomNumberGenerator& __urng)
2352 : { return this->operator()(__urng, _M_param); }
2353 :
2354 : template<typename _UniformRandomNumberGenerator>
2355 : result_type
2356 : operator()(_UniformRandomNumberGenerator& __urng,
2357 : const param_type& __p)
2358 : { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
2359 :
2360 : template<typename _ForwardIterator,
2361 : typename _UniformRandomNumberGenerator>
2362 : void
2363 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2364 : _UniformRandomNumberGenerator& __urng)
2365 : { this->__generate(__f, __t, __urng, _M_param); }
2366 :
2367 : template<typename _ForwardIterator,
2368 : typename _UniformRandomNumberGenerator>
2369 : void
2370 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2371 : _UniformRandomNumberGenerator& __urng,
2372 : const param_type& __p)
2373 : { this->__generate_impl(__f, __t, __urng, __p); }
2374 :
2375 : template<typename _UniformRandomNumberGenerator>
2376 : void
2377 : __generate(result_type* __f, result_type* __t,
2378 : _UniformRandomNumberGenerator& __urng,
2379 : const param_type& __p)
2380 : { this->__generate_impl(__f, __t, __urng, __p); }
2381 :
2382 : /**
2383 : * @brief Return true if two lognormal distributions have
2384 : * the same parameters and the sequences that would
2385 : * be generated are equal.
2386 : */
2387 : friend bool
2388 : operator==(const lognormal_distribution& __d1,
2389 : const lognormal_distribution& __d2)
2390 : { return (__d1._M_param == __d2._M_param
2391 : && __d1._M_nd == __d2._M_nd); }
2392 :
2393 : /**
2394 : * @brief Inserts a %lognormal_distribution random number distribution
2395 : * @p __x into the output stream @p __os.
2396 : *
2397 : * @param __os An output stream.
2398 : * @param __x A %lognormal_distribution random number distribution.
2399 : *
2400 : * @returns The output stream with the state of @p __x inserted or in
2401 : * an error state.
2402 : */
2403 : template<typename _RealType1, typename _CharT, typename _Traits>
2404 : friend std::basic_ostream<_CharT, _Traits>&
2405 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2406 : const std::lognormal_distribution<_RealType1>& __x);
2407 :
2408 : /**
2409 : * @brief Extracts a %lognormal_distribution random number distribution
2410 : * @p __x from the input stream @p __is.
2411 : *
2412 : * @param __is An input stream.
2413 : * @param __x A %lognormal_distribution random number
2414 : * generator engine.
2415 : *
2416 : * @returns The input stream with @p __x extracted or in an error state.
2417 : */
2418 : template<typename _RealType1, typename _CharT, typename _Traits>
2419 : friend std::basic_istream<_CharT, _Traits>&
2420 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
2421 : std::lognormal_distribution<_RealType1>& __x);
2422 :
2423 : private:
2424 : template<typename _ForwardIterator,
2425 : typename _UniformRandomNumberGenerator>
2426 : void
2427 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2428 : _UniformRandomNumberGenerator& __urng,
2429 : const param_type& __p);
2430 :
2431 : param_type _M_param;
2432 :
2433 : std::normal_distribution<result_type> _M_nd;
2434 : };
2435 :
2436 : #if __cpp_impl_three_way_comparison < 201907L
2437 : /**
2438 : * @brief Return true if two lognormal distributions are different.
2439 : */
2440 : template<typename _RealType>
2441 : inline bool
2442 : operator!=(const std::lognormal_distribution<_RealType>& __d1,
2443 : const std::lognormal_distribution<_RealType>& __d2)
2444 : { return !(__d1 == __d2); }
2445 : #endif
2446 :
2447 : /// @} group random_distributions_normal
2448 :
2449 : /**
2450 : * @addtogroup random_distributions_poisson Poisson Distributions
2451 : * @ingroup random_distributions
2452 : * @{
2453 : */
2454 :
2455 : /**
2456 : * @brief A gamma continuous distribution for random numbers.
2457 : *
2458 : * The formula for the gamma probability density function is:
2459 : * @f[
2460 : * p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
2461 : * (x/\beta)^{\alpha - 1} e^{-x/\beta}
2462 : * @f]
2463 : *
2464 : * @headerfile random
2465 : * @since C++11
2466 : */
2467 : template<typename _RealType = double>
2468 : class gamma_distribution
2469 : {
2470 : static_assert(std::is_floating_point<_RealType>::value,
2471 : "result_type must be a floating point type");
2472 :
2473 : public:
2474 : /** The type of the range of the distribution. */
2475 : typedef _RealType result_type;
2476 :
2477 : /** Parameter type. */
2478 : struct param_type
2479 : {
2480 : typedef gamma_distribution<_RealType> distribution_type;
2481 : friend class gamma_distribution<_RealType>;
2482 :
2483 : param_type() : param_type(1.0) { }
2484 :
2485 : explicit
2486 : param_type(_RealType __alpha_val, _RealType __beta_val = _RealType(1))
2487 : : _M_alpha(__alpha_val), _M_beta(__beta_val)
2488 : {
2489 : __glibcxx_assert(_M_alpha > _RealType(0));
2490 : _M_initialize();
2491 : }
2492 :
2493 : _RealType
2494 : alpha() const
2495 : { return _M_alpha; }
2496 :
2497 : _RealType
2498 : beta() const
2499 : { return _M_beta; }
2500 :
2501 : friend bool
2502 : operator==(const param_type& __p1, const param_type& __p2)
2503 : { return (__p1._M_alpha == __p2._M_alpha
2504 : && __p1._M_beta == __p2._M_beta); }
2505 :
2506 : #if __cpp_impl_three_way_comparison < 201907L
2507 : friend bool
2508 : operator!=(const param_type& __p1, const param_type& __p2)
2509 : { return !(__p1 == __p2); }
2510 : #endif
2511 :
2512 : private:
2513 : void
2514 : _M_initialize();
2515 :
2516 : _RealType _M_alpha;
2517 : _RealType _M_beta;
2518 :
2519 : _RealType _M_malpha, _M_a2;
2520 : };
2521 :
2522 : public:
2523 : /**
2524 : * @brief Constructs a gamma distribution with parameters 1 and 1.
2525 : */
2526 : gamma_distribution() : gamma_distribution(1.0) { }
2527 :
2528 : /**
2529 : * @brief Constructs a gamma distribution with parameters
2530 : * @f$\alpha@f$ and @f$\beta@f$.
2531 : */
2532 : explicit
2533 : gamma_distribution(_RealType __alpha_val,
2534 : _RealType __beta_val = _RealType(1))
2535 : : _M_param(__alpha_val, __beta_val), _M_nd()
2536 : { }
2537 :
2538 : explicit
2539 : gamma_distribution(const param_type& __p)
2540 : : _M_param(__p), _M_nd()
2541 : { }
2542 :
2543 : /**
2544 : * @brief Resets the distribution state.
2545 : */
2546 : void
2547 : reset()
2548 : { _M_nd.reset(); }
2549 :
2550 : /**
2551 : * @brief Returns the @f$\alpha@f$ of the distribution.
2552 : */
2553 : _RealType
2554 : alpha() const
2555 : { return _M_param.alpha(); }
2556 :
2557 : /**
2558 : * @brief Returns the @f$\beta@f$ of the distribution.
2559 : */
2560 : _RealType
2561 : beta() const
2562 : { return _M_param.beta(); }
2563 :
2564 : /**
2565 : * @brief Returns the parameter set of the distribution.
2566 : */
2567 : param_type
2568 : param() const
2569 : { return _M_param; }
2570 :
2571 : /**
2572 : * @brief Sets the parameter set of the distribution.
2573 : * @param __param The new parameter set of the distribution.
2574 : */
2575 : void
2576 : param(const param_type& __param)
2577 : { _M_param = __param; }
2578 :
2579 : /**
2580 : * @brief Returns the greatest lower bound value of the distribution.
2581 : */
2582 : result_type
2583 : min() const
2584 : { return result_type(0); }
2585 :
2586 : /**
2587 : * @brief Returns the least upper bound value of the distribution.
2588 : */
2589 : result_type
2590 : max() const
2591 : { return std::numeric_limits<result_type>::max(); }
2592 :
2593 : /**
2594 : * @brief Generating functions.
2595 : */
2596 : template<typename _UniformRandomNumberGenerator>
2597 : result_type
2598 : operator()(_UniformRandomNumberGenerator& __urng)
2599 : { return this->operator()(__urng, _M_param); }
2600 :
2601 : template<typename _UniformRandomNumberGenerator>
2602 : result_type
2603 : operator()(_UniformRandomNumberGenerator& __urng,
2604 : const param_type& __p);
2605 :
2606 : template<typename _ForwardIterator,
2607 : typename _UniformRandomNumberGenerator>
2608 : void
2609 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2610 : _UniformRandomNumberGenerator& __urng)
2611 : { this->__generate(__f, __t, __urng, _M_param); }
2612 :
2613 : template<typename _ForwardIterator,
2614 : typename _UniformRandomNumberGenerator>
2615 : void
2616 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2617 : _UniformRandomNumberGenerator& __urng,
2618 : const param_type& __p)
2619 : { this->__generate_impl(__f, __t, __urng, __p); }
2620 :
2621 : template<typename _UniformRandomNumberGenerator>
2622 : void
2623 : __generate(result_type* __f, result_type* __t,
2624 : _UniformRandomNumberGenerator& __urng,
2625 : const param_type& __p)
2626 : { this->__generate_impl(__f, __t, __urng, __p); }
2627 :
2628 : /**
2629 : * @brief Return true if two gamma distributions have the same
2630 : * parameters and the sequences that would be generated
2631 : * are equal.
2632 : */
2633 : friend bool
2634 : operator==(const gamma_distribution& __d1,
2635 : const gamma_distribution& __d2)
2636 : { return (__d1._M_param == __d2._M_param
2637 : && __d1._M_nd == __d2._M_nd); }
2638 :
2639 : /**
2640 : * @brief Inserts a %gamma_distribution random number distribution
2641 : * @p __x into the output stream @p __os.
2642 : *
2643 : * @param __os An output stream.
2644 : * @param __x A %gamma_distribution random number distribution.
2645 : *
2646 : * @returns The output stream with the state of @p __x inserted or in
2647 : * an error state.
2648 : */
2649 : template<typename _RealType1, typename _CharT, typename _Traits>
2650 : friend std::basic_ostream<_CharT, _Traits>&
2651 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2652 : const std::gamma_distribution<_RealType1>& __x);
2653 :
2654 : /**
2655 : * @brief Extracts a %gamma_distribution random number distribution
2656 : * @p __x from the input stream @p __is.
2657 : *
2658 : * @param __is An input stream.
2659 : * @param __x A %gamma_distribution random number generator engine.
2660 : *
2661 : * @returns The input stream with @p __x extracted or in an error state.
2662 : */
2663 : template<typename _RealType1, typename _CharT, typename _Traits>
2664 : friend std::basic_istream<_CharT, _Traits>&
2665 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
2666 : std::gamma_distribution<_RealType1>& __x);
2667 :
2668 : private:
2669 : template<typename _ForwardIterator,
2670 : typename _UniformRandomNumberGenerator>
2671 : void
2672 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2673 : _UniformRandomNumberGenerator& __urng,
2674 : const param_type& __p);
2675 :
2676 : param_type _M_param;
2677 :
2678 : std::normal_distribution<result_type> _M_nd;
2679 : };
2680 :
2681 : #if __cpp_impl_three_way_comparison < 201907L
2682 : /**
2683 : * @brief Return true if two gamma distributions are different.
2684 : */
2685 : template<typename _RealType>
2686 : inline bool
2687 : operator!=(const std::gamma_distribution<_RealType>& __d1,
2688 : const std::gamma_distribution<_RealType>& __d2)
2689 : { return !(__d1 == __d2); }
2690 : #endif
2691 :
2692 : /// @} group random_distributions_poisson
2693 :
2694 : /**
2695 : * @addtogroup random_distributions_normal Normal Distributions
2696 : * @ingroup random_distributions
2697 : * @{
2698 : */
2699 :
2700 : /**
2701 : * @brief A chi_squared_distribution random number distribution.
2702 : *
2703 : * The formula for the normal probability mass function is
2704 : * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$
2705 : *
2706 : * @headerfile random
2707 : * @since C++11
2708 : */
2709 : template<typename _RealType = double>
2710 : class chi_squared_distribution
2711 : {
2712 : static_assert(std::is_floating_point<_RealType>::value,
2713 : "result_type must be a floating point type");
2714 :
2715 : public:
2716 : /** The type of the range of the distribution. */
2717 : typedef _RealType result_type;
2718 :
2719 : /** Parameter type. */
2720 : struct param_type
2721 : {
2722 : typedef chi_squared_distribution<_RealType> distribution_type;
2723 :
2724 : param_type() : param_type(1) { }
2725 :
2726 : explicit
2727 : param_type(_RealType __n)
2728 : : _M_n(__n)
2729 : { }
2730 :
2731 : _RealType
2732 : n() const
2733 : { return _M_n; }
2734 :
2735 : friend bool
2736 : operator==(const param_type& __p1, const param_type& __p2)
2737 : { return __p1._M_n == __p2._M_n; }
2738 :
2739 : #if __cpp_impl_three_way_comparison < 201907L
2740 : friend bool
2741 : operator!=(const param_type& __p1, const param_type& __p2)
2742 : { return !(__p1 == __p2); }
2743 : #endif
2744 :
2745 : private:
2746 : _RealType _M_n;
2747 : };
2748 :
2749 : chi_squared_distribution() : chi_squared_distribution(1) { }
2750 :
2751 : explicit
2752 : chi_squared_distribution(_RealType __n)
2753 : : _M_param(__n), _M_gd(__n / 2)
2754 : { }
2755 :
2756 : explicit
2757 : chi_squared_distribution(const param_type& __p)
2758 : : _M_param(__p), _M_gd(__p.n() / 2)
2759 : { }
2760 :
2761 : /**
2762 : * @brief Resets the distribution state.
2763 : */
2764 : void
2765 : reset()
2766 : { _M_gd.reset(); }
2767 :
2768 : /**
2769 : *
2770 : */
2771 : _RealType
2772 : n() const
2773 : { return _M_param.n(); }
2774 :
2775 : /**
2776 : * @brief Returns the parameter set of the distribution.
2777 : */
2778 : param_type
2779 : param() const
2780 : { return _M_param; }
2781 :
2782 : /**
2783 : * @brief Sets the parameter set of the distribution.
2784 : * @param __param The new parameter set of the distribution.
2785 : */
2786 : void
2787 : param(const param_type& __param)
2788 : {
2789 : _M_param = __param;
2790 : typedef typename std::gamma_distribution<result_type>::param_type
2791 : param_type;
2792 : _M_gd.param(param_type{__param.n() / 2});
2793 : }
2794 :
2795 : /**
2796 : * @brief Returns the greatest lower bound value of the distribution.
2797 : */
2798 : result_type
2799 : min() const
2800 : { return result_type(0); }
2801 :
2802 : /**
2803 : * @brief Returns the least upper bound value of the distribution.
2804 : */
2805 : result_type
2806 : max() const
2807 : { return std::numeric_limits<result_type>::max(); }
2808 :
2809 : /**
2810 : * @brief Generating functions.
2811 : */
2812 : template<typename _UniformRandomNumberGenerator>
2813 : result_type
2814 : operator()(_UniformRandomNumberGenerator& __urng)
2815 : { return 2 * _M_gd(__urng); }
2816 :
2817 : template<typename _UniformRandomNumberGenerator>
2818 : result_type
2819 : operator()(_UniformRandomNumberGenerator& __urng,
2820 : const param_type& __p)
2821 : {
2822 : typedef typename std::gamma_distribution<result_type>::param_type
2823 : param_type;
2824 : return 2 * _M_gd(__urng, param_type(__p.n() / 2));
2825 : }
2826 :
2827 : template<typename _ForwardIterator,
2828 : typename _UniformRandomNumberGenerator>
2829 : void
2830 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2831 : _UniformRandomNumberGenerator& __urng)
2832 : { this->__generate_impl(__f, __t, __urng); }
2833 :
2834 : template<typename _ForwardIterator,
2835 : typename _UniformRandomNumberGenerator>
2836 : void
2837 : __generate(_ForwardIterator __f, _ForwardIterator __t,
2838 : _UniformRandomNumberGenerator& __urng,
2839 : const param_type& __p)
2840 : { typename std::gamma_distribution<result_type>::param_type
2841 : __p2(__p.n() / 2);
2842 : this->__generate_impl(__f, __t, __urng, __p2); }
2843 :
2844 : template<typename _UniformRandomNumberGenerator>
2845 : void
2846 : __generate(result_type* __f, result_type* __t,
2847 : _UniformRandomNumberGenerator& __urng)
2848 : { this->__generate_impl(__f, __t, __urng); }
2849 :
2850 : template<typename _UniformRandomNumberGenerator>
2851 : void
2852 : __generate(result_type* __f, result_type* __t,
2853 : _UniformRandomNumberGenerator& __urng,
2854 : const param_type& __p)
2855 : { typename std::gamma_distribution<result_type>::param_type
2856 : __p2(__p.n() / 2);
2857 : this->__generate_impl(__f, __t, __urng, __p2); }
2858 :
2859 : /**
2860 : * @brief Return true if two Chi-squared distributions have
2861 : * the same parameters and the sequences that would be
2862 : * generated are equal.
2863 : */
2864 : friend bool
2865 : operator==(const chi_squared_distribution& __d1,
2866 : const chi_squared_distribution& __d2)
2867 : { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
2868 :
2869 : /**
2870 : * @brief Inserts a %chi_squared_distribution random number distribution
2871 : * @p __x into the output stream @p __os.
2872 : *
2873 : * @param __os An output stream.
2874 : * @param __x A %chi_squared_distribution random number distribution.
2875 : *
2876 : * @returns The output stream with the state of @p __x inserted or in
2877 : * an error state.
2878 : */
2879 : template<typename _RealType1, typename _CharT, typename _Traits>
2880 : friend std::basic_ostream<_CharT, _Traits>&
2881 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
2882 : const std::chi_squared_distribution<_RealType1>& __x);
2883 :
2884 : /**
2885 : * @brief Extracts a %chi_squared_distribution random number distribution
2886 : * @p __x from the input stream @p __is.
2887 : *
2888 : * @param __is An input stream.
2889 : * @param __x A %chi_squared_distribution random number
2890 : * generator engine.
2891 : *
2892 : * @returns The input stream with @p __x extracted or in an error state.
2893 : */
2894 : template<typename _RealType1, typename _CharT, typename _Traits>
2895 : friend std::basic_istream<_CharT, _Traits>&
2896 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
2897 : std::chi_squared_distribution<_RealType1>& __x);
2898 :
2899 : private:
2900 : template<typename _ForwardIterator,
2901 : typename _UniformRandomNumberGenerator>
2902 : void
2903 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2904 : _UniformRandomNumberGenerator& __urng);
2905 :
2906 : template<typename _ForwardIterator,
2907 : typename _UniformRandomNumberGenerator>
2908 : void
2909 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2910 : _UniformRandomNumberGenerator& __urng,
2911 : const typename
2912 : std::gamma_distribution<result_type>::param_type& __p);
2913 :
2914 : param_type _M_param;
2915 :
2916 : std::gamma_distribution<result_type> _M_gd;
2917 : };
2918 :
2919 : #if __cpp_impl_three_way_comparison < 201907L
2920 : /**
2921 : * @brief Return true if two Chi-squared distributions are different.
2922 : */
2923 : template<typename _RealType>
2924 : inline bool
2925 : operator!=(const std::chi_squared_distribution<_RealType>& __d1,
2926 : const std::chi_squared_distribution<_RealType>& __d2)
2927 : { return !(__d1 == __d2); }
2928 : #endif
2929 :
2930 : /**
2931 : * @brief A cauchy_distribution random number distribution.
2932 : *
2933 : * The formula for the normal probability mass function is
2934 : * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$
2935 : *
2936 : * @headerfile random
2937 : * @since C++11
2938 : */
2939 : template<typename _RealType = double>
2940 : class cauchy_distribution
2941 : {
2942 : static_assert(std::is_floating_point<_RealType>::value,
2943 : "result_type must be a floating point type");
2944 :
2945 : public:
2946 : /** The type of the range of the distribution. */
2947 : typedef _RealType result_type;
2948 :
2949 : /** Parameter type. */
2950 : struct param_type
2951 : {
2952 : typedef cauchy_distribution<_RealType> distribution_type;
2953 :
2954 : param_type() : param_type(0) { }
2955 :
2956 : explicit
2957 : param_type(_RealType __a, _RealType __b = _RealType(1))
2958 : : _M_a(__a), _M_b(__b)
2959 : { }
2960 :
2961 : _RealType
2962 : a() const
2963 : { return _M_a; }
2964 :
2965 : _RealType
2966 : b() const
2967 : { return _M_b; }
2968 :
2969 : friend bool
2970 : operator==(const param_type& __p1, const param_type& __p2)
2971 : { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
2972 :
2973 : #if __cpp_impl_three_way_comparison < 201907L
2974 : friend bool
2975 : operator!=(const param_type& __p1, const param_type& __p2)
2976 : { return !(__p1 == __p2); }
2977 : #endif
2978 :
2979 : private:
2980 : _RealType _M_a;
2981 : _RealType _M_b;
2982 : };
2983 :
2984 : cauchy_distribution() : cauchy_distribution(0.0) { }
2985 :
2986 : explicit
2987 : cauchy_distribution(_RealType __a, _RealType __b = 1.0)
2988 : : _M_param(__a, __b)
2989 : { }
2990 :
2991 : explicit
2992 : cauchy_distribution(const param_type& __p)
2993 : : _M_param(__p)
2994 : { }
2995 :
2996 : /**
2997 : * @brief Resets the distribution state.
2998 : */
2999 : void
3000 : reset()
3001 : { }
3002 :
3003 : /**
3004 : *
3005 : */
3006 : _RealType
3007 : a() const
3008 : { return _M_param.a(); }
3009 :
3010 : _RealType
3011 : b() const
3012 : { return _M_param.b(); }
3013 :
3014 : /**
3015 : * @brief Returns the parameter set of the distribution.
3016 : */
3017 : param_type
3018 : param() const
3019 : { return _M_param; }
3020 :
3021 : /**
3022 : * @brief Sets the parameter set of the distribution.
3023 : * @param __param The new parameter set of the distribution.
3024 : */
3025 : void
3026 : param(const param_type& __param)
3027 : { _M_param = __param; }
3028 :
3029 : /**
3030 : * @brief Returns the greatest lower bound value of the distribution.
3031 : */
3032 : result_type
3033 : min() const
3034 : { return std::numeric_limits<result_type>::lowest(); }
3035 :
3036 : /**
3037 : * @brief Returns the least upper bound value of the distribution.
3038 : */
3039 : result_type
3040 : max() const
3041 : { return std::numeric_limits<result_type>::max(); }
3042 :
3043 : /**
3044 : * @brief Generating functions.
3045 : */
3046 : template<typename _UniformRandomNumberGenerator>
3047 : result_type
3048 : operator()(_UniformRandomNumberGenerator& __urng)
3049 : { return this->operator()(__urng, _M_param); }
3050 :
3051 : template<typename _UniformRandomNumberGenerator>
3052 : result_type
3053 : operator()(_UniformRandomNumberGenerator& __urng,
3054 : const param_type& __p);
3055 :
3056 : template<typename _ForwardIterator,
3057 : typename _UniformRandomNumberGenerator>
3058 : void
3059 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3060 : _UniformRandomNumberGenerator& __urng)
3061 : { this->__generate(__f, __t, __urng, _M_param); }
3062 :
3063 : template<typename _ForwardIterator,
3064 : typename _UniformRandomNumberGenerator>
3065 : void
3066 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3067 : _UniformRandomNumberGenerator& __urng,
3068 : const param_type& __p)
3069 : { this->__generate_impl(__f, __t, __urng, __p); }
3070 :
3071 : template<typename _UniformRandomNumberGenerator>
3072 : void
3073 : __generate(result_type* __f, result_type* __t,
3074 : _UniformRandomNumberGenerator& __urng,
3075 : const param_type& __p)
3076 : { this->__generate_impl(__f, __t, __urng, __p); }
3077 :
3078 : /**
3079 : * @brief Return true if two Cauchy distributions have
3080 : * the same parameters.
3081 : */
3082 : friend bool
3083 : operator==(const cauchy_distribution& __d1,
3084 : const cauchy_distribution& __d2)
3085 : { return __d1._M_param == __d2._M_param; }
3086 :
3087 : private:
3088 : template<typename _ForwardIterator,
3089 : typename _UniformRandomNumberGenerator>
3090 : void
3091 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3092 : _UniformRandomNumberGenerator& __urng,
3093 : const param_type& __p);
3094 :
3095 : param_type _M_param;
3096 : };
3097 :
3098 : #if __cpp_impl_three_way_comparison < 201907L
3099 : /**
3100 : * @brief Return true if two Cauchy distributions have
3101 : * different parameters.
3102 : */
3103 : template<typename _RealType>
3104 : inline bool
3105 : operator!=(const std::cauchy_distribution<_RealType>& __d1,
3106 : const std::cauchy_distribution<_RealType>& __d2)
3107 : { return !(__d1 == __d2); }
3108 : #endif
3109 :
3110 : /**
3111 : * @brief Inserts a %cauchy_distribution random number distribution
3112 : * @p __x into the output stream @p __os.
3113 : *
3114 : * @param __os An output stream.
3115 : * @param __x A %cauchy_distribution random number distribution.
3116 : *
3117 : * @returns The output stream with the state of @p __x inserted or in
3118 : * an error state.
3119 : */
3120 : template<typename _RealType, typename _CharT, typename _Traits>
3121 : std::basic_ostream<_CharT, _Traits>&
3122 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3123 : const std::cauchy_distribution<_RealType>& __x);
3124 :
3125 : /**
3126 : * @brief Extracts a %cauchy_distribution random number distribution
3127 : * @p __x from the input stream @p __is.
3128 : *
3129 : * @param __is An input stream.
3130 : * @param __x A %cauchy_distribution random number
3131 : * generator engine.
3132 : *
3133 : * @returns The input stream with @p __x extracted or in an error state.
3134 : */
3135 : template<typename _RealType, typename _CharT, typename _Traits>
3136 : std::basic_istream<_CharT, _Traits>&
3137 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
3138 : std::cauchy_distribution<_RealType>& __x);
3139 :
3140 :
3141 : /**
3142 : * @brief A fisher_f_distribution random number distribution.
3143 : *
3144 : * The formula for the normal probability mass function is
3145 : * @f[
3146 : * p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
3147 : * (\frac{m}{n})^{m/2} x^{(m/2)-1}
3148 : * (1 + \frac{mx}{n})^{-(m+n)/2}
3149 : * @f]
3150 : *
3151 : * @headerfile random
3152 : * @since C++11
3153 : */
3154 : template<typename _RealType = double>
3155 : class fisher_f_distribution
3156 : {
3157 : static_assert(std::is_floating_point<_RealType>::value,
3158 : "result_type must be a floating point type");
3159 :
3160 : public:
3161 : /** The type of the range of the distribution. */
3162 : typedef _RealType result_type;
3163 :
3164 : /** Parameter type. */
3165 : struct param_type
3166 : {
3167 : typedef fisher_f_distribution<_RealType> distribution_type;
3168 :
3169 : param_type() : param_type(1) { }
3170 :
3171 : explicit
3172 : param_type(_RealType __m, _RealType __n = _RealType(1))
3173 : : _M_m(__m), _M_n(__n)
3174 : { }
3175 :
3176 : _RealType
3177 : m() const
3178 : { return _M_m; }
3179 :
3180 : _RealType
3181 : n() const
3182 : { return _M_n; }
3183 :
3184 : friend bool
3185 : operator==(const param_type& __p1, const param_type& __p2)
3186 : { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
3187 :
3188 : #if __cpp_impl_three_way_comparison < 201907L
3189 : friend bool
3190 : operator!=(const param_type& __p1, const param_type& __p2)
3191 : { return !(__p1 == __p2); }
3192 : #endif
3193 :
3194 : private:
3195 : _RealType _M_m;
3196 : _RealType _M_n;
3197 : };
3198 :
3199 : fisher_f_distribution() : fisher_f_distribution(1.0) { }
3200 :
3201 : explicit
3202 : fisher_f_distribution(_RealType __m,
3203 : _RealType __n = _RealType(1))
3204 : : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
3205 : { }
3206 :
3207 : explicit
3208 : fisher_f_distribution(const param_type& __p)
3209 : : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
3210 : { }
3211 :
3212 : /**
3213 : * @brief Resets the distribution state.
3214 : */
3215 : void
3216 : reset()
3217 : {
3218 : _M_gd_x.reset();
3219 : _M_gd_y.reset();
3220 : }
3221 :
3222 : /**
3223 : *
3224 : */
3225 : _RealType
3226 : m() const
3227 : { return _M_param.m(); }
3228 :
3229 : _RealType
3230 : n() const
3231 : { return _M_param.n(); }
3232 :
3233 : /**
3234 : * @brief Returns the parameter set of the distribution.
3235 : */
3236 : param_type
3237 : param() const
3238 : { return _M_param; }
3239 :
3240 : /**
3241 : * @brief Sets the parameter set of the distribution.
3242 : * @param __param The new parameter set of the distribution.
3243 : */
3244 : void
3245 : param(const param_type& __param)
3246 : { _M_param = __param; }
3247 :
3248 : /**
3249 : * @brief Returns the greatest lower bound value of the distribution.
3250 : */
3251 : result_type
3252 : min() const
3253 : { return result_type(0); }
3254 :
3255 : /**
3256 : * @brief Returns the least upper bound value of the distribution.
3257 : */
3258 : result_type
3259 : max() const
3260 : { return std::numeric_limits<result_type>::max(); }
3261 :
3262 : /**
3263 : * @brief Generating functions.
3264 : */
3265 : template<typename _UniformRandomNumberGenerator>
3266 : result_type
3267 : operator()(_UniformRandomNumberGenerator& __urng)
3268 : { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
3269 :
3270 : template<typename _UniformRandomNumberGenerator>
3271 : result_type
3272 : operator()(_UniformRandomNumberGenerator& __urng,
3273 : const param_type& __p)
3274 : {
3275 : typedef typename std::gamma_distribution<result_type>::param_type
3276 : param_type;
3277 : return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
3278 : / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
3279 : }
3280 :
3281 : template<typename _ForwardIterator,
3282 : typename _UniformRandomNumberGenerator>
3283 : void
3284 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3285 : _UniformRandomNumberGenerator& __urng)
3286 : { this->__generate_impl(__f, __t, __urng); }
3287 :
3288 : template<typename _ForwardIterator,
3289 : typename _UniformRandomNumberGenerator>
3290 : void
3291 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3292 : _UniformRandomNumberGenerator& __urng,
3293 : const param_type& __p)
3294 : { this->__generate_impl(__f, __t, __urng, __p); }
3295 :
3296 : template<typename _UniformRandomNumberGenerator>
3297 : void
3298 : __generate(result_type* __f, result_type* __t,
3299 : _UniformRandomNumberGenerator& __urng)
3300 : { this->__generate_impl(__f, __t, __urng); }
3301 :
3302 : template<typename _UniformRandomNumberGenerator>
3303 : void
3304 : __generate(result_type* __f, result_type* __t,
3305 : _UniformRandomNumberGenerator& __urng,
3306 : const param_type& __p)
3307 : { this->__generate_impl(__f, __t, __urng, __p); }
3308 :
3309 : /**
3310 : * @brief Return true if two Fisher f distributions have
3311 : * the same parameters and the sequences that would
3312 : * be generated are equal.
3313 : */
3314 : friend bool
3315 : operator==(const fisher_f_distribution& __d1,
3316 : const fisher_f_distribution& __d2)
3317 : { return (__d1._M_param == __d2._M_param
3318 : && __d1._M_gd_x == __d2._M_gd_x
3319 : && __d1._M_gd_y == __d2._M_gd_y); }
3320 :
3321 : /**
3322 : * @brief Inserts a %fisher_f_distribution random number distribution
3323 : * @p __x into the output stream @p __os.
3324 : *
3325 : * @param __os An output stream.
3326 : * @param __x A %fisher_f_distribution random number distribution.
3327 : *
3328 : * @returns The output stream with the state of @p __x inserted or in
3329 : * an error state.
3330 : */
3331 : template<typename _RealType1, typename _CharT, typename _Traits>
3332 : friend std::basic_ostream<_CharT, _Traits>&
3333 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3334 : const std::fisher_f_distribution<_RealType1>& __x);
3335 :
3336 : /**
3337 : * @brief Extracts a %fisher_f_distribution random number distribution
3338 : * @p __x from the input stream @p __is.
3339 : *
3340 : * @param __is An input stream.
3341 : * @param __x A %fisher_f_distribution random number
3342 : * generator engine.
3343 : *
3344 : * @returns The input stream with @p __x extracted or in an error state.
3345 : */
3346 : template<typename _RealType1, typename _CharT, typename _Traits>
3347 : friend std::basic_istream<_CharT, _Traits>&
3348 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
3349 : std::fisher_f_distribution<_RealType1>& __x);
3350 :
3351 : private:
3352 : template<typename _ForwardIterator,
3353 : typename _UniformRandomNumberGenerator>
3354 : void
3355 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3356 : _UniformRandomNumberGenerator& __urng);
3357 :
3358 : template<typename _ForwardIterator,
3359 : typename _UniformRandomNumberGenerator>
3360 : void
3361 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3362 : _UniformRandomNumberGenerator& __urng,
3363 : const param_type& __p);
3364 :
3365 : param_type _M_param;
3366 :
3367 : std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
3368 : };
3369 :
3370 : #if __cpp_impl_three_way_comparison < 201907L
3371 : /**
3372 : * @brief Return true if two Fisher f distributions are different.
3373 : */
3374 : template<typename _RealType>
3375 : inline bool
3376 : operator!=(const std::fisher_f_distribution<_RealType>& __d1,
3377 : const std::fisher_f_distribution<_RealType>& __d2)
3378 : { return !(__d1 == __d2); }
3379 : #endif
3380 :
3381 : /**
3382 : * @brief A student_t_distribution random number distribution.
3383 : *
3384 : * The formula for the normal probability mass function is:
3385 : * @f[
3386 : * p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
3387 : * (1 + \frac{x^2}{n}) ^{-(n+1)/2}
3388 : * @f]
3389 : *
3390 : * @headerfile random
3391 : * @since C++11
3392 : */
3393 : template<typename _RealType = double>
3394 : class student_t_distribution
3395 : {
3396 : static_assert(std::is_floating_point<_RealType>::value,
3397 : "result_type must be a floating point type");
3398 :
3399 : public:
3400 : /** The type of the range of the distribution. */
3401 : typedef _RealType result_type;
3402 :
3403 : /** Parameter type. */
3404 : struct param_type
3405 : {
3406 : typedef student_t_distribution<_RealType> distribution_type;
3407 :
3408 : param_type() : param_type(1) { }
3409 :
3410 : explicit
3411 : param_type(_RealType __n)
3412 : : _M_n(__n)
3413 : { }
3414 :
3415 : _RealType
3416 : n() const
3417 : { return _M_n; }
3418 :
3419 : friend bool
3420 : operator==(const param_type& __p1, const param_type& __p2)
3421 : { return __p1._M_n == __p2._M_n; }
3422 :
3423 : #if __cpp_impl_three_way_comparison < 201907L
3424 : friend bool
3425 : operator!=(const param_type& __p1, const param_type& __p2)
3426 : { return !(__p1 == __p2); }
3427 : #endif
3428 :
3429 : private:
3430 : _RealType _M_n;
3431 : };
3432 :
3433 : student_t_distribution() : student_t_distribution(1.0) { }
3434 :
3435 : explicit
3436 : student_t_distribution(_RealType __n)
3437 : : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
3438 : { }
3439 :
3440 : explicit
3441 : student_t_distribution(const param_type& __p)
3442 : : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
3443 : { }
3444 :
3445 : /**
3446 : * @brief Resets the distribution state.
3447 : */
3448 : void
3449 : reset()
3450 : {
3451 : _M_nd.reset();
3452 : _M_gd.reset();
3453 : }
3454 :
3455 : /**
3456 : *
3457 : */
3458 : _RealType
3459 : n() const
3460 : { return _M_param.n(); }
3461 :
3462 : /**
3463 : * @brief Returns the parameter set of the distribution.
3464 : */
3465 : param_type
3466 : param() const
3467 : { return _M_param; }
3468 :
3469 : /**
3470 : * @brief Sets the parameter set of the distribution.
3471 : * @param __param The new parameter set of the distribution.
3472 : */
3473 : void
3474 : param(const param_type& __param)
3475 : { _M_param = __param; }
3476 :
3477 : /**
3478 : * @brief Returns the greatest lower bound value of the distribution.
3479 : */
3480 : result_type
3481 : min() const
3482 : { return std::numeric_limits<result_type>::lowest(); }
3483 :
3484 : /**
3485 : * @brief Returns the least upper bound value of the distribution.
3486 : */
3487 : result_type
3488 : max() const
3489 : { return std::numeric_limits<result_type>::max(); }
3490 :
3491 : /**
3492 : * @brief Generating functions.
3493 : */
3494 : template<typename _UniformRandomNumberGenerator>
3495 : result_type
3496 : operator()(_UniformRandomNumberGenerator& __urng)
3497 : { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
3498 :
3499 : template<typename _UniformRandomNumberGenerator>
3500 : result_type
3501 : operator()(_UniformRandomNumberGenerator& __urng,
3502 : const param_type& __p)
3503 : {
3504 : typedef typename std::gamma_distribution<result_type>::param_type
3505 : param_type;
3506 :
3507 : const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
3508 : return _M_nd(__urng) * std::sqrt(__p.n() / __g);
3509 : }
3510 :
3511 : template<typename _ForwardIterator,
3512 : typename _UniformRandomNumberGenerator>
3513 : void
3514 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3515 : _UniformRandomNumberGenerator& __urng)
3516 : { this->__generate_impl(__f, __t, __urng); }
3517 :
3518 : template<typename _ForwardIterator,
3519 : typename _UniformRandomNumberGenerator>
3520 : void
3521 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3522 : _UniformRandomNumberGenerator& __urng,
3523 : const param_type& __p)
3524 : { this->__generate_impl(__f, __t, __urng, __p); }
3525 :
3526 : template<typename _UniformRandomNumberGenerator>
3527 : void
3528 : __generate(result_type* __f, result_type* __t,
3529 : _UniformRandomNumberGenerator& __urng)
3530 : { this->__generate_impl(__f, __t, __urng); }
3531 :
3532 : template<typename _UniformRandomNumberGenerator>
3533 : void
3534 : __generate(result_type* __f, result_type* __t,
3535 : _UniformRandomNumberGenerator& __urng,
3536 : const param_type& __p)
3537 : { this->__generate_impl(__f, __t, __urng, __p); }
3538 :
3539 : /**
3540 : * @brief Return true if two Student t distributions have
3541 : * the same parameters and the sequences that would
3542 : * be generated are equal.
3543 : */
3544 : friend bool
3545 : operator==(const student_t_distribution& __d1,
3546 : const student_t_distribution& __d2)
3547 : { return (__d1._M_param == __d2._M_param
3548 : && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
3549 :
3550 : /**
3551 : * @brief Inserts a %student_t_distribution random number distribution
3552 : * @p __x into the output stream @p __os.
3553 : *
3554 : * @param __os An output stream.
3555 : * @param __x A %student_t_distribution random number distribution.
3556 : *
3557 : * @returns The output stream with the state of @p __x inserted or in
3558 : * an error state.
3559 : */
3560 : template<typename _RealType1, typename _CharT, typename _Traits>
3561 : friend std::basic_ostream<_CharT, _Traits>&
3562 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3563 : const std::student_t_distribution<_RealType1>& __x);
3564 :
3565 : /**
3566 : * @brief Extracts a %student_t_distribution random number distribution
3567 : * @p __x from the input stream @p __is.
3568 : *
3569 : * @param __is An input stream.
3570 : * @param __x A %student_t_distribution random number
3571 : * generator engine.
3572 : *
3573 : * @returns The input stream with @p __x extracted or in an error state.
3574 : */
3575 : template<typename _RealType1, typename _CharT, typename _Traits>
3576 : friend std::basic_istream<_CharT, _Traits>&
3577 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
3578 : std::student_t_distribution<_RealType1>& __x);
3579 :
3580 : private:
3581 : template<typename _ForwardIterator,
3582 : typename _UniformRandomNumberGenerator>
3583 : void
3584 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3585 : _UniformRandomNumberGenerator& __urng);
3586 : template<typename _ForwardIterator,
3587 : typename _UniformRandomNumberGenerator>
3588 : void
3589 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3590 : _UniformRandomNumberGenerator& __urng,
3591 : const param_type& __p);
3592 :
3593 : param_type _M_param;
3594 :
3595 : std::normal_distribution<result_type> _M_nd;
3596 : std::gamma_distribution<result_type> _M_gd;
3597 : };
3598 :
3599 : #if __cpp_impl_three_way_comparison < 201907L
3600 : /**
3601 : * @brief Return true if two Student t distributions are different.
3602 : */
3603 : template<typename _RealType>
3604 : inline bool
3605 : operator!=(const std::student_t_distribution<_RealType>& __d1,
3606 : const std::student_t_distribution<_RealType>& __d2)
3607 : { return !(__d1 == __d2); }
3608 : #endif
3609 :
3610 : /// @} group random_distributions_normal
3611 :
3612 : /**
3613 : * @addtogroup random_distributions_bernoulli Bernoulli Distributions
3614 : * @ingroup random_distributions
3615 : * @{
3616 : */
3617 :
3618 : /**
3619 : * @brief A Bernoulli random number distribution.
3620 : *
3621 : * Generates a sequence of true and false values with likelihood @f$p@f$
3622 : * that true will come up and @f$(1 - p)@f$ that false will appear.
3623 : *
3624 : * @headerfile random
3625 : * @since C++11
3626 : */
3627 : class bernoulli_distribution
3628 : {
3629 : public:
3630 : /** The type of the range of the distribution. */
3631 : typedef bool result_type;
3632 :
3633 : /** Parameter type. */
3634 : struct param_type
3635 : {
3636 : typedef bernoulli_distribution distribution_type;
3637 :
3638 : param_type() : param_type(0.5) { }
3639 :
3640 : explicit
3641 : param_type(double __p)
3642 : : _M_p(__p)
3643 : {
3644 : __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0));
3645 : }
3646 :
3647 : double
3648 : p() const
3649 : { return _M_p; }
3650 :
3651 : friend bool
3652 : operator==(const param_type& __p1, const param_type& __p2)
3653 : { return __p1._M_p == __p2._M_p; }
3654 :
3655 : #if __cpp_impl_three_way_comparison < 201907L
3656 : friend bool
3657 : operator!=(const param_type& __p1, const param_type& __p2)
3658 : { return !(__p1 == __p2); }
3659 : #endif
3660 :
3661 : private:
3662 : double _M_p;
3663 : };
3664 :
3665 : public:
3666 : /**
3667 : * @brief Constructs a Bernoulli distribution with likelihood 0.5.
3668 : */
3669 : bernoulli_distribution() : bernoulli_distribution(0.5) { }
3670 :
3671 : /**
3672 : * @brief Constructs a Bernoulli distribution with likelihood @p p.
3673 : *
3674 : * @param __p [IN] The likelihood of a true result being returned.
3675 : * Must be in the interval @f$[0, 1]@f$.
3676 : */
3677 : explicit
3678 : bernoulli_distribution(double __p)
3679 : : _M_param(__p)
3680 : { }
3681 :
3682 : explicit
3683 : bernoulli_distribution(const param_type& __p)
3684 : : _M_param(__p)
3685 : { }
3686 :
3687 : /**
3688 : * @brief Resets the distribution state.
3689 : *
3690 : * Does nothing for a Bernoulli distribution.
3691 : */
3692 : void
3693 : reset() { }
3694 :
3695 : /**
3696 : * @brief Returns the @p p parameter of the distribution.
3697 : */
3698 : double
3699 : p() const
3700 : { return _M_param.p(); }
3701 :
3702 : /**
3703 : * @brief Returns the parameter set of the distribution.
3704 : */
3705 : param_type
3706 : param() const
3707 : { return _M_param; }
3708 :
3709 : /**
3710 : * @brief Sets the parameter set of the distribution.
3711 : * @param __param The new parameter set of the distribution.
3712 : */
3713 : void
3714 : param(const param_type& __param)
3715 : { _M_param = __param; }
3716 :
3717 : /**
3718 : * @brief Returns the greatest lower bound value of the distribution.
3719 : */
3720 : result_type
3721 : min() const
3722 : { return std::numeric_limits<result_type>::min(); }
3723 :
3724 : /**
3725 : * @brief Returns the least upper bound value of the distribution.
3726 : */
3727 : result_type
3728 : max() const
3729 : { return std::numeric_limits<result_type>::max(); }
3730 :
3731 : /**
3732 : * @brief Generating functions.
3733 : */
3734 : template<typename _UniformRandomNumberGenerator>
3735 : result_type
3736 : operator()(_UniformRandomNumberGenerator& __urng)
3737 : { return this->operator()(__urng, _M_param); }
3738 :
3739 : template<typename _UniformRandomNumberGenerator>
3740 : result_type
3741 : operator()(_UniformRandomNumberGenerator& __urng,
3742 : const param_type& __p)
3743 : {
3744 : __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3745 : __aurng(__urng);
3746 : if ((__aurng() - __aurng.min())
3747 : < __p.p() * (__aurng.max() - __aurng.min()))
3748 : return true;
3749 : return false;
3750 : }
3751 :
3752 : template<typename _ForwardIterator,
3753 : typename _UniformRandomNumberGenerator>
3754 : void
3755 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3756 : _UniformRandomNumberGenerator& __urng)
3757 : { this->__generate(__f, __t, __urng, _M_param); }
3758 :
3759 : template<typename _ForwardIterator,
3760 : typename _UniformRandomNumberGenerator>
3761 : void
3762 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3763 : _UniformRandomNumberGenerator& __urng, const param_type& __p)
3764 : { this->__generate_impl(__f, __t, __urng, __p); }
3765 :
3766 : template<typename _UniformRandomNumberGenerator>
3767 : void
3768 : __generate(result_type* __f, result_type* __t,
3769 : _UniformRandomNumberGenerator& __urng,
3770 : const param_type& __p)
3771 : { this->__generate_impl(__f, __t, __urng, __p); }
3772 :
3773 : /**
3774 : * @brief Return true if two Bernoulli distributions have
3775 : * the same parameters.
3776 : */
3777 : friend bool
3778 : operator==(const bernoulli_distribution& __d1,
3779 : const bernoulli_distribution& __d2)
3780 : { return __d1._M_param == __d2._M_param; }
3781 :
3782 : private:
3783 : template<typename _ForwardIterator,
3784 : typename _UniformRandomNumberGenerator>
3785 : void
3786 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3787 : _UniformRandomNumberGenerator& __urng,
3788 : const param_type& __p);
3789 :
3790 : param_type _M_param;
3791 : };
3792 :
3793 : #if __cpp_impl_three_way_comparison < 201907L
3794 : /**
3795 : * @brief Return true if two Bernoulli distributions have
3796 : * different parameters.
3797 : */
3798 : inline bool
3799 : operator!=(const std::bernoulli_distribution& __d1,
3800 : const std::bernoulli_distribution& __d2)
3801 : { return !(__d1 == __d2); }
3802 : #endif
3803 :
3804 : /**
3805 : * @brief Inserts a %bernoulli_distribution random number distribution
3806 : * @p __x into the output stream @p __os.
3807 : *
3808 : * @param __os An output stream.
3809 : * @param __x A %bernoulli_distribution random number distribution.
3810 : *
3811 : * @returns The output stream with the state of @p __x inserted or in
3812 : * an error state.
3813 : */
3814 : template<typename _CharT, typename _Traits>
3815 : std::basic_ostream<_CharT, _Traits>&
3816 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
3817 : const std::bernoulli_distribution& __x);
3818 :
3819 : /**
3820 : * @brief Extracts a %bernoulli_distribution random number distribution
3821 : * @p __x from the input stream @p __is.
3822 : *
3823 : * @param __is An input stream.
3824 : * @param __x A %bernoulli_distribution random number generator engine.
3825 : *
3826 : * @returns The input stream with @p __x extracted or in an error state.
3827 : */
3828 : template<typename _CharT, typename _Traits>
3829 : inline std::basic_istream<_CharT, _Traits>&
3830 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
3831 : std::bernoulli_distribution& __x)
3832 : {
3833 : double __p;
3834 : if (__is >> __p)
3835 : __x.param(bernoulli_distribution::param_type(__p));
3836 : return __is;
3837 : }
3838 :
3839 :
3840 : /**
3841 : * @brief A discrete binomial random number distribution.
3842 : *
3843 : * The formula for the binomial probability density function is
3844 : * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
3845 : * and @f$p@f$ are the parameters of the distribution.
3846 : *
3847 : * @headerfile random
3848 : * @since C++11
3849 : */
3850 : template<typename _IntType = int>
3851 : class binomial_distribution
3852 : {
3853 : static_assert(std::is_integral<_IntType>::value,
3854 : "result_type must be an integral type");
3855 :
3856 : public:
3857 : /** The type of the range of the distribution. */
3858 : typedef _IntType result_type;
3859 :
3860 : /** Parameter type. */
3861 : struct param_type
3862 : {
3863 : typedef binomial_distribution<_IntType> distribution_type;
3864 : friend class binomial_distribution<_IntType>;
3865 :
3866 : param_type() : param_type(1) { }
3867 :
3868 : explicit
3869 : param_type(_IntType __t, double __p = 0.5)
3870 : : _M_t(__t), _M_p(__p)
3871 : {
3872 : __glibcxx_assert((_M_t >= _IntType(0))
3873 : && (_M_p >= 0.0)
3874 : && (_M_p <= 1.0));
3875 : _M_initialize();
3876 : }
3877 :
3878 : _IntType
3879 : t() const
3880 : { return _M_t; }
3881 :
3882 : double
3883 : p() const
3884 : { return _M_p; }
3885 :
3886 : friend bool
3887 : operator==(const param_type& __p1, const param_type& __p2)
3888 : { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
3889 :
3890 : #if __cpp_impl_three_way_comparison < 201907L
3891 : friend bool
3892 : operator!=(const param_type& __p1, const param_type& __p2)
3893 : { return !(__p1 == __p2); }
3894 : #endif
3895 :
3896 : private:
3897 : void
3898 : _M_initialize();
3899 :
3900 : _IntType _M_t;
3901 : double _M_p;
3902 :
3903 : double _M_q;
3904 : #if _GLIBCXX_USE_C99_MATH_TR1
3905 : double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
3906 : _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
3907 : #endif
3908 : bool _M_easy;
3909 : };
3910 :
3911 : // constructors and member functions
3912 :
3913 : binomial_distribution() : binomial_distribution(1) { }
3914 :
3915 : explicit
3916 : binomial_distribution(_IntType __t, double __p = 0.5)
3917 : : _M_param(__t, __p), _M_nd()
3918 : { }
3919 :
3920 : explicit
3921 : binomial_distribution(const param_type& __p)
3922 : : _M_param(__p), _M_nd()
3923 : { }
3924 :
3925 : /**
3926 : * @brief Resets the distribution state.
3927 : */
3928 : void
3929 : reset()
3930 : { _M_nd.reset(); }
3931 :
3932 : /**
3933 : * @brief Returns the distribution @p t parameter.
3934 : */
3935 : _IntType
3936 : t() const
3937 : { return _M_param.t(); }
3938 :
3939 : /**
3940 : * @brief Returns the distribution @p p parameter.
3941 : */
3942 : double
3943 : p() const
3944 : { return _M_param.p(); }
3945 :
3946 : /**
3947 : * @brief Returns the parameter set of the distribution.
3948 : */
3949 : param_type
3950 : param() const
3951 : { return _M_param; }
3952 :
3953 : /**
3954 : * @brief Sets the parameter set of the distribution.
3955 : * @param __param The new parameter set of the distribution.
3956 : */
3957 : void
3958 : param(const param_type& __param)
3959 : { _M_param = __param; }
3960 :
3961 : /**
3962 : * @brief Returns the greatest lower bound value of the distribution.
3963 : */
3964 : result_type
3965 : min() const
3966 : { return 0; }
3967 :
3968 : /**
3969 : * @brief Returns the least upper bound value of the distribution.
3970 : */
3971 : result_type
3972 : max() const
3973 : { return _M_param.t(); }
3974 :
3975 : /**
3976 : * @brief Generating functions.
3977 : */
3978 : template<typename _UniformRandomNumberGenerator>
3979 : result_type
3980 : operator()(_UniformRandomNumberGenerator& __urng)
3981 : { return this->operator()(__urng, _M_param); }
3982 :
3983 : template<typename _UniformRandomNumberGenerator>
3984 : result_type
3985 : operator()(_UniformRandomNumberGenerator& __urng,
3986 : const param_type& __p);
3987 :
3988 : template<typename _ForwardIterator,
3989 : typename _UniformRandomNumberGenerator>
3990 : void
3991 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3992 : _UniformRandomNumberGenerator& __urng)
3993 : { this->__generate(__f, __t, __urng, _M_param); }
3994 :
3995 : template<typename _ForwardIterator,
3996 : typename _UniformRandomNumberGenerator>
3997 : void
3998 : __generate(_ForwardIterator __f, _ForwardIterator __t,
3999 : _UniformRandomNumberGenerator& __urng,
4000 : const param_type& __p)
4001 : { this->__generate_impl(__f, __t, __urng, __p); }
4002 :
4003 : template<typename _UniformRandomNumberGenerator>
4004 : void
4005 : __generate(result_type* __f, result_type* __t,
4006 : _UniformRandomNumberGenerator& __urng,
4007 : const param_type& __p)
4008 : { this->__generate_impl(__f, __t, __urng, __p); }
4009 :
4010 : /**
4011 : * @brief Return true if two binomial distributions have
4012 : * the same parameters and the sequences that would
4013 : * be generated are equal.
4014 : */
4015 : friend bool
4016 : operator==(const binomial_distribution& __d1,
4017 : const binomial_distribution& __d2)
4018 : #ifdef _GLIBCXX_USE_C99_MATH_TR1
4019 : { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4020 : #else
4021 : { return __d1._M_param == __d2._M_param; }
4022 : #endif
4023 :
4024 : /**
4025 : * @brief Inserts a %binomial_distribution random number distribution
4026 : * @p __x into the output stream @p __os.
4027 : *
4028 : * @param __os An output stream.
4029 : * @param __x A %binomial_distribution random number distribution.
4030 : *
4031 : * @returns The output stream with the state of @p __x inserted or in
4032 : * an error state.
4033 : */
4034 : template<typename _IntType1,
4035 : typename _CharT, typename _Traits>
4036 : friend std::basic_ostream<_CharT, _Traits>&
4037 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4038 : const std::binomial_distribution<_IntType1>& __x);
4039 :
4040 : /**
4041 : * @brief Extracts a %binomial_distribution random number distribution
4042 : * @p __x from the input stream @p __is.
4043 : *
4044 : * @param __is An input stream.
4045 : * @param __x A %binomial_distribution random number generator engine.
4046 : *
4047 : * @returns The input stream with @p __x extracted or in an error
4048 : * state.
4049 : */
4050 : template<typename _IntType1,
4051 : typename _CharT, typename _Traits>
4052 : friend std::basic_istream<_CharT, _Traits>&
4053 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
4054 : std::binomial_distribution<_IntType1>& __x);
4055 :
4056 : private:
4057 : template<typename _ForwardIterator,
4058 : typename _UniformRandomNumberGenerator>
4059 : void
4060 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4061 : _UniformRandomNumberGenerator& __urng,
4062 : const param_type& __p);
4063 :
4064 : template<typename _UniformRandomNumberGenerator>
4065 : result_type
4066 : _M_waiting(_UniformRandomNumberGenerator& __urng,
4067 : _IntType __t, double __q);
4068 :
4069 : param_type _M_param;
4070 :
4071 : // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
4072 : std::normal_distribution<double> _M_nd;
4073 : };
4074 :
4075 : #if __cpp_impl_three_way_comparison < 201907L
4076 : /**
4077 : * @brief Return true if two binomial distributions are different.
4078 : */
4079 : template<typename _IntType>
4080 : inline bool
4081 : operator!=(const std::binomial_distribution<_IntType>& __d1,
4082 : const std::binomial_distribution<_IntType>& __d2)
4083 : { return !(__d1 == __d2); }
4084 : #endif
4085 :
4086 : /**
4087 : * @brief A discrete geometric random number distribution.
4088 : *
4089 : * The formula for the geometric probability density function is
4090 : * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
4091 : * distribution.
4092 : *
4093 : * @headerfile random
4094 : * @since C++11
4095 : */
4096 : template<typename _IntType = int>
4097 : class geometric_distribution
4098 : {
4099 : static_assert(std::is_integral<_IntType>::value,
4100 : "result_type must be an integral type");
4101 :
4102 : public:
4103 : /** The type of the range of the distribution. */
4104 : typedef _IntType result_type;
4105 :
4106 : /** Parameter type. */
4107 : struct param_type
4108 : {
4109 : typedef geometric_distribution<_IntType> distribution_type;
4110 : friend class geometric_distribution<_IntType>;
4111 :
4112 : param_type() : param_type(0.5) { }
4113 :
4114 : explicit
4115 : param_type(double __p)
4116 : : _M_p(__p)
4117 : {
4118 : __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0));
4119 : _M_initialize();
4120 : }
4121 :
4122 : double
4123 : p() const
4124 : { return _M_p; }
4125 :
4126 : friend bool
4127 : operator==(const param_type& __p1, const param_type& __p2)
4128 : { return __p1._M_p == __p2._M_p; }
4129 :
4130 : #if __cpp_impl_three_way_comparison < 201907L
4131 : friend bool
4132 : operator!=(const param_type& __p1, const param_type& __p2)
4133 : { return !(__p1 == __p2); }
4134 : #endif
4135 :
4136 : private:
4137 : void
4138 : _M_initialize()
4139 : { _M_log_1_p = std::log(1.0 - _M_p); }
4140 :
4141 : double _M_p;
4142 :
4143 : double _M_log_1_p;
4144 : };
4145 :
4146 : // constructors and member functions
4147 :
4148 : geometric_distribution() : geometric_distribution(0.5) { }
4149 :
4150 : explicit
4151 : geometric_distribution(double __p)
4152 : : _M_param(__p)
4153 : { }
4154 :
4155 : explicit
4156 : geometric_distribution(const param_type& __p)
4157 : : _M_param(__p)
4158 : { }
4159 :
4160 : /**
4161 : * @brief Resets the distribution state.
4162 : *
4163 : * Does nothing for the geometric distribution.
4164 : */
4165 : void
4166 : reset() { }
4167 :
4168 : /**
4169 : * @brief Returns the distribution parameter @p p.
4170 : */
4171 : double
4172 : p() const
4173 : { return _M_param.p(); }
4174 :
4175 : /**
4176 : * @brief Returns the parameter set of the distribution.
4177 : */
4178 : param_type
4179 : param() const
4180 : { return _M_param; }
4181 :
4182 : /**
4183 : * @brief Sets the parameter set of the distribution.
4184 : * @param __param The new parameter set of the distribution.
4185 : */
4186 : void
4187 : param(const param_type& __param)
4188 : { _M_param = __param; }
4189 :
4190 : /**
4191 : * @brief Returns the greatest lower bound value of the distribution.
4192 : */
4193 : result_type
4194 : min() const
4195 : { return 0; }
4196 :
4197 : /**
4198 : * @brief Returns the least upper bound value of the distribution.
4199 : */
4200 : result_type
4201 : max() const
4202 : { return std::numeric_limits<result_type>::max(); }
4203 :
4204 : /**
4205 : * @brief Generating functions.
4206 : */
4207 : template<typename _UniformRandomNumberGenerator>
4208 : result_type
4209 : operator()(_UniformRandomNumberGenerator& __urng)
4210 : { return this->operator()(__urng, _M_param); }
4211 :
4212 : template<typename _UniformRandomNumberGenerator>
4213 : result_type
4214 : operator()(_UniformRandomNumberGenerator& __urng,
4215 : const param_type& __p);
4216 :
4217 : template<typename _ForwardIterator,
4218 : typename _UniformRandomNumberGenerator>
4219 : void
4220 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4221 : _UniformRandomNumberGenerator& __urng)
4222 : { this->__generate(__f, __t, __urng, _M_param); }
4223 :
4224 : template<typename _ForwardIterator,
4225 : typename _UniformRandomNumberGenerator>
4226 : void
4227 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4228 : _UniformRandomNumberGenerator& __urng,
4229 : const param_type& __p)
4230 : { this->__generate_impl(__f, __t, __urng, __p); }
4231 :
4232 : template<typename _UniformRandomNumberGenerator>
4233 : void
4234 : __generate(result_type* __f, result_type* __t,
4235 : _UniformRandomNumberGenerator& __urng,
4236 : const param_type& __p)
4237 : { this->__generate_impl(__f, __t, __urng, __p); }
4238 :
4239 : /**
4240 : * @brief Return true if two geometric distributions have
4241 : * the same parameters.
4242 : */
4243 : friend bool
4244 : operator==(const geometric_distribution& __d1,
4245 : const geometric_distribution& __d2)
4246 : { return __d1._M_param == __d2._M_param; }
4247 :
4248 : private:
4249 : template<typename _ForwardIterator,
4250 : typename _UniformRandomNumberGenerator>
4251 : void
4252 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4253 : _UniformRandomNumberGenerator& __urng,
4254 : const param_type& __p);
4255 :
4256 : param_type _M_param;
4257 : };
4258 :
4259 : #if __cpp_impl_three_way_comparison < 201907L
4260 : /**
4261 : * @brief Return true if two geometric distributions have
4262 : * different parameters.
4263 : */
4264 : template<typename _IntType>
4265 : inline bool
4266 : operator!=(const std::geometric_distribution<_IntType>& __d1,
4267 : const std::geometric_distribution<_IntType>& __d2)
4268 : { return !(__d1 == __d2); }
4269 : #endif
4270 :
4271 : /**
4272 : * @brief Inserts a %geometric_distribution random number distribution
4273 : * @p __x into the output stream @p __os.
4274 : *
4275 : * @param __os An output stream.
4276 : * @param __x A %geometric_distribution random number distribution.
4277 : *
4278 : * @returns The output stream with the state of @p __x inserted or in
4279 : * an error state.
4280 : */
4281 : template<typename _IntType,
4282 : typename _CharT, typename _Traits>
4283 : std::basic_ostream<_CharT, _Traits>&
4284 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4285 : const std::geometric_distribution<_IntType>& __x);
4286 :
4287 : /**
4288 : * @brief Extracts a %geometric_distribution random number distribution
4289 : * @p __x from the input stream @p __is.
4290 : *
4291 : * @param __is An input stream.
4292 : * @param __x A %geometric_distribution random number generator engine.
4293 : *
4294 : * @returns The input stream with @p __x extracted or in an error state.
4295 : */
4296 : template<typename _IntType,
4297 : typename _CharT, typename _Traits>
4298 : std::basic_istream<_CharT, _Traits>&
4299 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
4300 : std::geometric_distribution<_IntType>& __x);
4301 :
4302 :
4303 : /**
4304 : * @brief A negative_binomial_distribution random number distribution.
4305 : *
4306 : * The formula for the negative binomial probability mass function is
4307 : * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
4308 : * and @f$p@f$ are the parameters of the distribution.
4309 : *
4310 : * @headerfile random
4311 : * @since C++11
4312 : */
4313 : template<typename _IntType = int>
4314 : class negative_binomial_distribution
4315 : {
4316 : static_assert(std::is_integral<_IntType>::value,
4317 : "result_type must be an integral type");
4318 :
4319 : public:
4320 : /** The type of the range of the distribution. */
4321 : typedef _IntType result_type;
4322 :
4323 : /** Parameter type. */
4324 : struct param_type
4325 : {
4326 : typedef negative_binomial_distribution<_IntType> distribution_type;
4327 :
4328 : param_type() : param_type(1) { }
4329 :
4330 : explicit
4331 : param_type(_IntType __k, double __p = 0.5)
4332 : : _M_k(__k), _M_p(__p)
4333 : {
4334 : __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4335 : }
4336 :
4337 : _IntType
4338 : k() const
4339 : { return _M_k; }
4340 :
4341 : double
4342 : p() const
4343 : { return _M_p; }
4344 :
4345 : friend bool
4346 : operator==(const param_type& __p1, const param_type& __p2)
4347 : { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4348 :
4349 : #if __cpp_impl_three_way_comparison < 201907L
4350 : friend bool
4351 : operator!=(const param_type& __p1, const param_type& __p2)
4352 : { return !(__p1 == __p2); }
4353 : #endif
4354 :
4355 : private:
4356 : _IntType _M_k;
4357 : double _M_p;
4358 : };
4359 :
4360 : negative_binomial_distribution() : negative_binomial_distribution(1) { }
4361 :
4362 : explicit
4363 : negative_binomial_distribution(_IntType __k, double __p = 0.5)
4364 : : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4365 : { }
4366 :
4367 : explicit
4368 : negative_binomial_distribution(const param_type& __p)
4369 : : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
4370 : { }
4371 :
4372 : /**
4373 : * @brief Resets the distribution state.
4374 : */
4375 : void
4376 : reset()
4377 : { _M_gd.reset(); }
4378 :
4379 : /**
4380 : * @brief Return the @f$k@f$ parameter of the distribution.
4381 : */
4382 : _IntType
4383 : k() const
4384 : { return _M_param.k(); }
4385 :
4386 : /**
4387 : * @brief Return the @f$p@f$ parameter of the distribution.
4388 : */
4389 : double
4390 : p() const
4391 : { return _M_param.p(); }
4392 :
4393 : /**
4394 : * @brief Returns the parameter set of the distribution.
4395 : */
4396 : param_type
4397 : param() const
4398 : { return _M_param; }
4399 :
4400 : /**
4401 : * @brief Sets the parameter set of the distribution.
4402 : * @param __param The new parameter set of the distribution.
4403 : */
4404 : void
4405 : param(const param_type& __param)
4406 : { _M_param = __param; }
4407 :
4408 : /**
4409 : * @brief Returns the greatest lower bound value of the distribution.
4410 : */
4411 : result_type
4412 : min() const
4413 : { return result_type(0); }
4414 :
4415 : /**
4416 : * @brief Returns the least upper bound value of the distribution.
4417 : */
4418 : result_type
4419 : max() const
4420 : { return std::numeric_limits<result_type>::max(); }
4421 :
4422 : /**
4423 : * @brief Generating functions.
4424 : */
4425 : template<typename _UniformRandomNumberGenerator>
4426 : result_type
4427 : operator()(_UniformRandomNumberGenerator& __urng);
4428 :
4429 : template<typename _UniformRandomNumberGenerator>
4430 : result_type
4431 : operator()(_UniformRandomNumberGenerator& __urng,
4432 : const param_type& __p);
4433 :
4434 : template<typename _ForwardIterator,
4435 : typename _UniformRandomNumberGenerator>
4436 : void
4437 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4438 : _UniformRandomNumberGenerator& __urng)
4439 : { this->__generate_impl(__f, __t, __urng); }
4440 :
4441 : template<typename _ForwardIterator,
4442 : typename _UniformRandomNumberGenerator>
4443 : void
4444 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4445 : _UniformRandomNumberGenerator& __urng,
4446 : const param_type& __p)
4447 : { this->__generate_impl(__f, __t, __urng, __p); }
4448 :
4449 : template<typename _UniformRandomNumberGenerator>
4450 : void
4451 : __generate(result_type* __f, result_type* __t,
4452 : _UniformRandomNumberGenerator& __urng)
4453 : { this->__generate_impl(__f, __t, __urng); }
4454 :
4455 : template<typename _UniformRandomNumberGenerator>
4456 : void
4457 : __generate(result_type* __f, result_type* __t,
4458 : _UniformRandomNumberGenerator& __urng,
4459 : const param_type& __p)
4460 : { this->__generate_impl(__f, __t, __urng, __p); }
4461 :
4462 : /**
4463 : * @brief Return true if two negative binomial distributions have
4464 : * the same parameters and the sequences that would be
4465 : * generated are equal.
4466 : */
4467 : friend bool
4468 : operator==(const negative_binomial_distribution& __d1,
4469 : const negative_binomial_distribution& __d2)
4470 : { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4471 :
4472 : /**
4473 : * @brief Inserts a %negative_binomial_distribution random
4474 : * number distribution @p __x into the output stream @p __os.
4475 : *
4476 : * @param __os An output stream.
4477 : * @param __x A %negative_binomial_distribution random number
4478 : * distribution.
4479 : *
4480 : * @returns The output stream with the state of @p __x inserted or in
4481 : * an error state.
4482 : */
4483 : template<typename _IntType1, typename _CharT, typename _Traits>
4484 : friend std::basic_ostream<_CharT, _Traits>&
4485 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4486 : const std::negative_binomial_distribution<_IntType1>& __x);
4487 :
4488 : /**
4489 : * @brief Extracts a %negative_binomial_distribution random number
4490 : * distribution @p __x from the input stream @p __is.
4491 : *
4492 : * @param __is An input stream.
4493 : * @param __x A %negative_binomial_distribution random number
4494 : * generator engine.
4495 : *
4496 : * @returns The input stream with @p __x extracted or in an error state.
4497 : */
4498 : template<typename _IntType1, typename _CharT, typename _Traits>
4499 : friend std::basic_istream<_CharT, _Traits>&
4500 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
4501 : std::negative_binomial_distribution<_IntType1>& __x);
4502 :
4503 : private:
4504 : template<typename _ForwardIterator,
4505 : typename _UniformRandomNumberGenerator>
4506 : void
4507 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4508 : _UniformRandomNumberGenerator& __urng);
4509 : template<typename _ForwardIterator,
4510 : typename _UniformRandomNumberGenerator>
4511 : void
4512 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4513 : _UniformRandomNumberGenerator& __urng,
4514 : const param_type& __p);
4515 :
4516 : param_type _M_param;
4517 :
4518 : std::gamma_distribution<double> _M_gd;
4519 : };
4520 :
4521 : #if __cpp_impl_three_way_comparison < 201907L
4522 : /**
4523 : * @brief Return true if two negative binomial distributions are different.
4524 : */
4525 : template<typename _IntType>
4526 : inline bool
4527 : operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
4528 : const std::negative_binomial_distribution<_IntType>& __d2)
4529 : { return !(__d1 == __d2); }
4530 : #endif
4531 :
4532 : /// @} group random_distributions_bernoulli
4533 :
4534 : /**
4535 : * @addtogroup random_distributions_poisson Poisson Distributions
4536 : * @ingroup random_distributions
4537 : * @{
4538 : */
4539 :
4540 : /**
4541 : * @brief A discrete Poisson random number distribution.
4542 : *
4543 : * The formula for the Poisson probability density function is
4544 : * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
4545 : * parameter of the distribution.
4546 : *
4547 : * @headerfile random
4548 : * @since C++11
4549 : */
4550 : template<typename _IntType = int>
4551 : class poisson_distribution
4552 : {
4553 : static_assert(std::is_integral<_IntType>::value,
4554 : "result_type must be an integral type");
4555 :
4556 : public:
4557 : /** The type of the range of the distribution. */
4558 : typedef _IntType result_type;
4559 :
4560 : /** Parameter type. */
4561 : struct param_type
4562 : {
4563 : typedef poisson_distribution<_IntType> distribution_type;
4564 : friend class poisson_distribution<_IntType>;
4565 :
4566 : param_type() : param_type(1.0) { }
4567 :
4568 : explicit
4569 : param_type(double __mean)
4570 : : _M_mean(__mean)
4571 : {
4572 : __glibcxx_assert(_M_mean > 0.0);
4573 : _M_initialize();
4574 : }
4575 :
4576 : double
4577 : mean() const
4578 : { return _M_mean; }
4579 :
4580 : friend bool
4581 : operator==(const param_type& __p1, const param_type& __p2)
4582 : { return __p1._M_mean == __p2._M_mean; }
4583 :
4584 : #if __cpp_impl_three_way_comparison < 201907L
4585 : friend bool
4586 : operator!=(const param_type& __p1, const param_type& __p2)
4587 : { return !(__p1 == __p2); }
4588 : #endif
4589 :
4590 : private:
4591 : // Hosts either log(mean) or the threshold of the simple method.
4592 : void
4593 : _M_initialize();
4594 :
4595 : double _M_mean;
4596 :
4597 : double _M_lm_thr;
4598 : #if _GLIBCXX_USE_C99_MATH_TR1
4599 : double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4600 : #endif
4601 : };
4602 :
4603 : // constructors and member functions
4604 :
4605 : poisson_distribution() : poisson_distribution(1.0) { }
4606 :
4607 : explicit
4608 : poisson_distribution(double __mean)
4609 : : _M_param(__mean), _M_nd()
4610 : { }
4611 :
4612 : explicit
4613 : poisson_distribution(const param_type& __p)
4614 : : _M_param(__p), _M_nd()
4615 : { }
4616 :
4617 : /**
4618 : * @brief Resets the distribution state.
4619 : */
4620 : void
4621 : reset()
4622 : { _M_nd.reset(); }
4623 :
4624 : /**
4625 : * @brief Returns the distribution parameter @p mean.
4626 : */
4627 : double
4628 : mean() const
4629 : { return _M_param.mean(); }
4630 :
4631 : /**
4632 : * @brief Returns the parameter set of the distribution.
4633 : */
4634 : param_type
4635 : param() const
4636 : { return _M_param; }
4637 :
4638 : /**
4639 : * @brief Sets the parameter set of the distribution.
4640 : * @param __param The new parameter set of the distribution.
4641 : */
4642 : void
4643 : param(const param_type& __param)
4644 : { _M_param = __param; }
4645 :
4646 : /**
4647 : * @brief Returns the greatest lower bound value of the distribution.
4648 : */
4649 : result_type
4650 : min() const
4651 : { return 0; }
4652 :
4653 : /**
4654 : * @brief Returns the least upper bound value of the distribution.
4655 : */
4656 : result_type
4657 : max() const
4658 : { return std::numeric_limits<result_type>::max(); }
4659 :
4660 : /**
4661 : * @brief Generating functions.
4662 : */
4663 : template<typename _UniformRandomNumberGenerator>
4664 : result_type
4665 : operator()(_UniformRandomNumberGenerator& __urng)
4666 : { return this->operator()(__urng, _M_param); }
4667 :
4668 : template<typename _UniformRandomNumberGenerator>
4669 : result_type
4670 : operator()(_UniformRandomNumberGenerator& __urng,
4671 : const param_type& __p);
4672 :
4673 : template<typename _ForwardIterator,
4674 : typename _UniformRandomNumberGenerator>
4675 : void
4676 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4677 : _UniformRandomNumberGenerator& __urng)
4678 : { this->__generate(__f, __t, __urng, _M_param); }
4679 :
4680 : template<typename _ForwardIterator,
4681 : typename _UniformRandomNumberGenerator>
4682 : void
4683 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4684 : _UniformRandomNumberGenerator& __urng,
4685 : const param_type& __p)
4686 : { this->__generate_impl(__f, __t, __urng, __p); }
4687 :
4688 : template<typename _UniformRandomNumberGenerator>
4689 : void
4690 : __generate(result_type* __f, result_type* __t,
4691 : _UniformRandomNumberGenerator& __urng,
4692 : const param_type& __p)
4693 : { this->__generate_impl(__f, __t, __urng, __p); }
4694 :
4695 : /**
4696 : * @brief Return true if two Poisson distributions have the same
4697 : * parameters and the sequences that would be generated
4698 : * are equal.
4699 : */
4700 : friend bool
4701 : operator==(const poisson_distribution& __d1,
4702 : const poisson_distribution& __d2)
4703 : #ifdef _GLIBCXX_USE_C99_MATH_TR1
4704 : { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4705 : #else
4706 : { return __d1._M_param == __d2._M_param; }
4707 : #endif
4708 :
4709 : /**
4710 : * @brief Inserts a %poisson_distribution random number distribution
4711 : * @p __x into the output stream @p __os.
4712 : *
4713 : * @param __os An output stream.
4714 : * @param __x A %poisson_distribution random number distribution.
4715 : *
4716 : * @returns The output stream with the state of @p __x inserted or in
4717 : * an error state.
4718 : */
4719 : template<typename _IntType1, typename _CharT, typename _Traits>
4720 : friend std::basic_ostream<_CharT, _Traits>&
4721 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4722 : const std::poisson_distribution<_IntType1>& __x);
4723 :
4724 : /**
4725 : * @brief Extracts a %poisson_distribution random number distribution
4726 : * @p __x from the input stream @p __is.
4727 : *
4728 : * @param __is An input stream.
4729 : * @param __x A %poisson_distribution random number generator engine.
4730 : *
4731 : * @returns The input stream with @p __x extracted or in an error
4732 : * state.
4733 : */
4734 : template<typename _IntType1, typename _CharT, typename _Traits>
4735 : friend std::basic_istream<_CharT, _Traits>&
4736 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
4737 : std::poisson_distribution<_IntType1>& __x);
4738 :
4739 : private:
4740 : template<typename _ForwardIterator,
4741 : typename _UniformRandomNumberGenerator>
4742 : void
4743 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4744 : _UniformRandomNumberGenerator& __urng,
4745 : const param_type& __p);
4746 :
4747 : param_type _M_param;
4748 :
4749 : // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
4750 : std::normal_distribution<double> _M_nd;
4751 : };
4752 :
4753 : #if __cpp_impl_three_way_comparison < 201907L
4754 : /**
4755 : * @brief Return true if two Poisson distributions are different.
4756 : */
4757 : template<typename _IntType>
4758 : inline bool
4759 : operator!=(const std::poisson_distribution<_IntType>& __d1,
4760 : const std::poisson_distribution<_IntType>& __d2)
4761 : { return !(__d1 == __d2); }
4762 : #endif
4763 :
4764 : /**
4765 : * @brief An exponential continuous distribution for random numbers.
4766 : *
4767 : * The formula for the exponential probability density function is
4768 : * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
4769 : *
4770 : * <table border=1 cellpadding=10 cellspacing=0>
4771 : * <caption align=top>Distribution Statistics</caption>
4772 : * <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4773 : * <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr>
4774 : * <tr><td>Mode</td><td>@f$zero@f$</td></tr>
4775 : * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
4776 : * <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4777 : * </table>
4778 : *
4779 : * @headerfile random
4780 : * @since C++11
4781 : */
4782 : template<typename _RealType = double>
4783 : class exponential_distribution
4784 : {
4785 : static_assert(std::is_floating_point<_RealType>::value,
4786 : "result_type must be a floating point type");
4787 :
4788 : public:
4789 : /** The type of the range of the distribution. */
4790 : typedef _RealType result_type;
4791 :
4792 : /** Parameter type. */
4793 : struct param_type
4794 : {
4795 : typedef exponential_distribution<_RealType> distribution_type;
4796 :
4797 : param_type() : param_type(1.0) { }
4798 :
4799 : explicit
4800 : param_type(_RealType __lambda)
4801 : : _M_lambda(__lambda)
4802 : {
4803 : __glibcxx_assert(_M_lambda > _RealType(0));
4804 : }
4805 :
4806 : _RealType
4807 : lambda() const
4808 : { return _M_lambda; }
4809 :
4810 : friend bool
4811 : operator==(const param_type& __p1, const param_type& __p2)
4812 : { return __p1._M_lambda == __p2._M_lambda; }
4813 :
4814 : #if __cpp_impl_three_way_comparison < 201907L
4815 : friend bool
4816 : operator!=(const param_type& __p1, const param_type& __p2)
4817 : { return !(__p1 == __p2); }
4818 : #endif
4819 :
4820 : private:
4821 : _RealType _M_lambda;
4822 : };
4823 :
4824 : public:
4825 : /**
4826 : * @brief Constructs an exponential distribution with inverse scale
4827 : * parameter 1.0
4828 : */
4829 : exponential_distribution() : exponential_distribution(1.0) { }
4830 :
4831 : /**
4832 : * @brief Constructs an exponential distribution with inverse scale
4833 : * parameter @f$\lambda@f$.
4834 : */
4835 : explicit
4836 : exponential_distribution(_RealType __lambda)
4837 : : _M_param(__lambda)
4838 : { }
4839 :
4840 : explicit
4841 : exponential_distribution(const param_type& __p)
4842 : : _M_param(__p)
4843 : { }
4844 :
4845 : /**
4846 : * @brief Resets the distribution state.
4847 : *
4848 : * Has no effect on exponential distributions.
4849 : */
4850 : void
4851 : reset() { }
4852 :
4853 : /**
4854 : * @brief Returns the inverse scale parameter of the distribution.
4855 : */
4856 : _RealType
4857 : lambda() const
4858 : { return _M_param.lambda(); }
4859 :
4860 : /**
4861 : * @brief Returns the parameter set of the distribution.
4862 : */
4863 : param_type
4864 : param() const
4865 : { return _M_param; }
4866 :
4867 : /**
4868 : * @brief Sets the parameter set of the distribution.
4869 : * @param __param The new parameter set of the distribution.
4870 : */
4871 : void
4872 : param(const param_type& __param)
4873 : { _M_param = __param; }
4874 :
4875 : /**
4876 : * @brief Returns the greatest lower bound value of the distribution.
4877 : */
4878 : result_type
4879 : min() const
4880 : { return result_type(0); }
4881 :
4882 : /**
4883 : * @brief Returns the least upper bound value of the distribution.
4884 : */
4885 : result_type
4886 : max() const
4887 : { return std::numeric_limits<result_type>::max(); }
4888 :
4889 : /**
4890 : * @brief Generating functions.
4891 : */
4892 : template<typename _UniformRandomNumberGenerator>
4893 : result_type
4894 : operator()(_UniformRandomNumberGenerator& __urng)
4895 : { return this->operator()(__urng, _M_param); }
4896 :
4897 : template<typename _UniformRandomNumberGenerator>
4898 : result_type
4899 : operator()(_UniformRandomNumberGenerator& __urng,
4900 : const param_type& __p)
4901 : {
4902 : __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4903 : __aurng(__urng);
4904 : return -std::log(result_type(1) - __aurng()) / __p.lambda();
4905 : }
4906 :
4907 : template<typename _ForwardIterator,
4908 : typename _UniformRandomNumberGenerator>
4909 : void
4910 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4911 : _UniformRandomNumberGenerator& __urng)
4912 : { this->__generate(__f, __t, __urng, _M_param); }
4913 :
4914 : template<typename _ForwardIterator,
4915 : typename _UniformRandomNumberGenerator>
4916 : void
4917 : __generate(_ForwardIterator __f, _ForwardIterator __t,
4918 : _UniformRandomNumberGenerator& __urng,
4919 : const param_type& __p)
4920 : { this->__generate_impl(__f, __t, __urng, __p); }
4921 :
4922 : template<typename _UniformRandomNumberGenerator>
4923 : void
4924 : __generate(result_type* __f, result_type* __t,
4925 : _UniformRandomNumberGenerator& __urng,
4926 : const param_type& __p)
4927 : { this->__generate_impl(__f, __t, __urng, __p); }
4928 :
4929 : /**
4930 : * @brief Return true if two exponential distributions have the same
4931 : * parameters.
4932 : */
4933 : friend bool
4934 : operator==(const exponential_distribution& __d1,
4935 : const exponential_distribution& __d2)
4936 : { return __d1._M_param == __d2._M_param; }
4937 :
4938 : private:
4939 : template<typename _ForwardIterator,
4940 : typename _UniformRandomNumberGenerator>
4941 : void
4942 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4943 : _UniformRandomNumberGenerator& __urng,
4944 : const param_type& __p);
4945 :
4946 : param_type _M_param;
4947 : };
4948 :
4949 : #if __cpp_impl_three_way_comparison < 201907L
4950 : /**
4951 : * @brief Return true if two exponential distributions have different
4952 : * parameters.
4953 : */
4954 : template<typename _RealType>
4955 : inline bool
4956 : operator!=(const std::exponential_distribution<_RealType>& __d1,
4957 : const std::exponential_distribution<_RealType>& __d2)
4958 : { return !(__d1 == __d2); }
4959 : #endif
4960 :
4961 : /**
4962 : * @brief Inserts a %exponential_distribution random number distribution
4963 : * @p __x into the output stream @p __os.
4964 : *
4965 : * @param __os An output stream.
4966 : * @param __x A %exponential_distribution random number distribution.
4967 : *
4968 : * @returns The output stream with the state of @p __x inserted or in
4969 : * an error state.
4970 : */
4971 : template<typename _RealType, typename _CharT, typename _Traits>
4972 : std::basic_ostream<_CharT, _Traits>&
4973 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4974 : const std::exponential_distribution<_RealType>& __x);
4975 :
4976 : /**
4977 : * @brief Extracts a %exponential_distribution random number distribution
4978 : * @p __x from the input stream @p __is.
4979 : *
4980 : * @param __is An input stream.
4981 : * @param __x A %exponential_distribution random number
4982 : * generator engine.
4983 : *
4984 : * @returns The input stream with @p __x extracted or in an error state.
4985 : */
4986 : template<typename _RealType, typename _CharT, typename _Traits>
4987 : std::basic_istream<_CharT, _Traits>&
4988 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
4989 : std::exponential_distribution<_RealType>& __x);
4990 :
4991 :
4992 : /**
4993 : * @brief A weibull_distribution random number distribution.
4994 : *
4995 : * The formula for the normal probability density function is:
4996 : * @f[
4997 : * p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
4998 : * \exp{(-(\frac{x}{\beta})^\alpha)}
4999 : * @f]
5000 : *
5001 : * @headerfile random
5002 : * @since C++11
5003 : */
5004 : template<typename _RealType = double>
5005 : class weibull_distribution
5006 : {
5007 : static_assert(std::is_floating_point<_RealType>::value,
5008 : "result_type must be a floating point type");
5009 :
5010 : public:
5011 : /** The type of the range of the distribution. */
5012 : typedef _RealType result_type;
5013 :
5014 : /** Parameter type. */
5015 : struct param_type
5016 : {
5017 : typedef weibull_distribution<_RealType> distribution_type;
5018 :
5019 : param_type() : param_type(1.0) { }
5020 :
5021 : explicit
5022 : param_type(_RealType __a, _RealType __b = _RealType(1.0))
5023 : : _M_a(__a), _M_b(__b)
5024 : { }
5025 :
5026 : _RealType
5027 : a() const
5028 : { return _M_a; }
5029 :
5030 : _RealType
5031 : b() const
5032 : { return _M_b; }
5033 :
5034 : friend bool
5035 : operator==(const param_type& __p1, const param_type& __p2)
5036 : { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5037 :
5038 : #if __cpp_impl_three_way_comparison < 201907L
5039 : friend bool
5040 : operator!=(const param_type& __p1, const param_type& __p2)
5041 : { return !(__p1 == __p2); }
5042 : #endif
5043 :
5044 : private:
5045 : _RealType _M_a;
5046 : _RealType _M_b;
5047 : };
5048 :
5049 : weibull_distribution() : weibull_distribution(1.0) { }
5050 :
5051 : explicit
5052 : weibull_distribution(_RealType __a, _RealType __b = _RealType(1))
5053 : : _M_param(__a, __b)
5054 : { }
5055 :
5056 : explicit
5057 : weibull_distribution(const param_type& __p)
5058 : : _M_param(__p)
5059 : { }
5060 :
5061 : /**
5062 : * @brief Resets the distribution state.
5063 : */
5064 : void
5065 : reset()
5066 : { }
5067 :
5068 : /**
5069 : * @brief Return the @f$a@f$ parameter of the distribution.
5070 : */
5071 : _RealType
5072 : a() const
5073 : { return _M_param.a(); }
5074 :
5075 : /**
5076 : * @brief Return the @f$b@f$ parameter of the distribution.
5077 : */
5078 : _RealType
5079 : b() const
5080 : { return _M_param.b(); }
5081 :
5082 : /**
5083 : * @brief Returns the parameter set of the distribution.
5084 : */
5085 : param_type
5086 : param() const
5087 : { return _M_param; }
5088 :
5089 : /**
5090 : * @brief Sets the parameter set of the distribution.
5091 : * @param __param The new parameter set of the distribution.
5092 : */
5093 : void
5094 : param(const param_type& __param)
5095 : { _M_param = __param; }
5096 :
5097 : /**
5098 : * @brief Returns the greatest lower bound value of the distribution.
5099 : */
5100 : result_type
5101 : min() const
5102 : { return result_type(0); }
5103 :
5104 : /**
5105 : * @brief Returns the least upper bound value of the distribution.
5106 : */
5107 : result_type
5108 : max() const
5109 : { return std::numeric_limits<result_type>::max(); }
5110 :
5111 : /**
5112 : * @brief Generating functions.
5113 : */
5114 : template<typename _UniformRandomNumberGenerator>
5115 : result_type
5116 : operator()(_UniformRandomNumberGenerator& __urng)
5117 : { return this->operator()(__urng, _M_param); }
5118 :
5119 : template<typename _UniformRandomNumberGenerator>
5120 : result_type
5121 : operator()(_UniformRandomNumberGenerator& __urng,
5122 : const param_type& __p);
5123 :
5124 : template<typename _ForwardIterator,
5125 : typename _UniformRandomNumberGenerator>
5126 : void
5127 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5128 : _UniformRandomNumberGenerator& __urng)
5129 : { this->__generate(__f, __t, __urng, _M_param); }
5130 :
5131 : template<typename _ForwardIterator,
5132 : typename _UniformRandomNumberGenerator>
5133 : void
5134 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5135 : _UniformRandomNumberGenerator& __urng,
5136 : const param_type& __p)
5137 : { this->__generate_impl(__f, __t, __urng, __p); }
5138 :
5139 : template<typename _UniformRandomNumberGenerator>
5140 : void
5141 : __generate(result_type* __f, result_type* __t,
5142 : _UniformRandomNumberGenerator& __urng,
5143 : const param_type& __p)
5144 : { this->__generate_impl(__f, __t, __urng, __p); }
5145 :
5146 : /**
5147 : * @brief Return true if two Weibull distributions have the same
5148 : * parameters.
5149 : */
5150 : friend bool
5151 : operator==(const weibull_distribution& __d1,
5152 : const weibull_distribution& __d2)
5153 : { return __d1._M_param == __d2._M_param; }
5154 :
5155 : private:
5156 : template<typename _ForwardIterator,
5157 : typename _UniformRandomNumberGenerator>
5158 : void
5159 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5160 : _UniformRandomNumberGenerator& __urng,
5161 : const param_type& __p);
5162 :
5163 : param_type _M_param;
5164 : };
5165 :
5166 : #if __cpp_impl_three_way_comparison < 201907L
5167 : /**
5168 : * @brief Return true if two Weibull distributions have different
5169 : * parameters.
5170 : */
5171 : template<typename _RealType>
5172 : inline bool
5173 : operator!=(const std::weibull_distribution<_RealType>& __d1,
5174 : const std::weibull_distribution<_RealType>& __d2)
5175 : { return !(__d1 == __d2); }
5176 : #endif
5177 :
5178 : /**
5179 : * @brief Inserts a %weibull_distribution random number distribution
5180 : * @p __x into the output stream @p __os.
5181 : *
5182 : * @param __os An output stream.
5183 : * @param __x A %weibull_distribution random number distribution.
5184 : *
5185 : * @returns The output stream with the state of @p __x inserted or in
5186 : * an error state.
5187 : */
5188 : template<typename _RealType, typename _CharT, typename _Traits>
5189 : std::basic_ostream<_CharT, _Traits>&
5190 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5191 : const std::weibull_distribution<_RealType>& __x);
5192 :
5193 : /**
5194 : * @brief Extracts a %weibull_distribution random number distribution
5195 : * @p __x from the input stream @p __is.
5196 : *
5197 : * @param __is An input stream.
5198 : * @param __x A %weibull_distribution random number
5199 : * generator engine.
5200 : *
5201 : * @returns The input stream with @p __x extracted or in an error state.
5202 : */
5203 : template<typename _RealType, typename _CharT, typename _Traits>
5204 : std::basic_istream<_CharT, _Traits>&
5205 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
5206 : std::weibull_distribution<_RealType>& __x);
5207 :
5208 :
5209 : /**
5210 : * @brief A extreme_value_distribution random number distribution.
5211 : *
5212 : * The formula for the normal probability mass function is
5213 : * @f[
5214 : * p(x|a,b) = \frac{1}{b}
5215 : * \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
5216 : * @f]
5217 : *
5218 : * @headerfile random
5219 : * @since C++11
5220 : */
5221 : template<typename _RealType = double>
5222 : class extreme_value_distribution
5223 : {
5224 : static_assert(std::is_floating_point<_RealType>::value,
5225 : "result_type must be a floating point type");
5226 :
5227 : public:
5228 : /** The type of the range of the distribution. */
5229 : typedef _RealType result_type;
5230 :
5231 : /** Parameter type. */
5232 : struct param_type
5233 : {
5234 : typedef extreme_value_distribution<_RealType> distribution_type;
5235 :
5236 : param_type() : param_type(0.0) { }
5237 :
5238 : explicit
5239 : param_type(_RealType __a, _RealType __b = _RealType(1.0))
5240 : : _M_a(__a), _M_b(__b)
5241 : { }
5242 :
5243 : _RealType
5244 : a() const
5245 : { return _M_a; }
5246 :
5247 : _RealType
5248 : b() const
5249 : { return _M_b; }
5250 :
5251 : friend bool
5252 : operator==(const param_type& __p1, const param_type& __p2)
5253 : { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5254 :
5255 : #if __cpp_impl_three_way_comparison < 201907L
5256 : friend bool
5257 : operator!=(const param_type& __p1, const param_type& __p2)
5258 : { return !(__p1 == __p2); }
5259 : #endif
5260 :
5261 : private:
5262 : _RealType _M_a;
5263 : _RealType _M_b;
5264 : };
5265 :
5266 : extreme_value_distribution() : extreme_value_distribution(0.0) { }
5267 :
5268 : explicit
5269 : extreme_value_distribution(_RealType __a, _RealType __b = _RealType(1))
5270 : : _M_param(__a, __b)
5271 : { }
5272 :
5273 : explicit
5274 : extreme_value_distribution(const param_type& __p)
5275 : : _M_param(__p)
5276 : { }
5277 :
5278 : /**
5279 : * @brief Resets the distribution state.
5280 : */
5281 : void
5282 : reset()
5283 : { }
5284 :
5285 : /**
5286 : * @brief Return the @f$a@f$ parameter of the distribution.
5287 : */
5288 : _RealType
5289 : a() const
5290 : { return _M_param.a(); }
5291 :
5292 : /**
5293 : * @brief Return the @f$b@f$ parameter of the distribution.
5294 : */
5295 : _RealType
5296 : b() const
5297 : { return _M_param.b(); }
5298 :
5299 : /**
5300 : * @brief Returns the parameter set of the distribution.
5301 : */
5302 : param_type
5303 : param() const
5304 : { return _M_param; }
5305 :
5306 : /**
5307 : * @brief Sets the parameter set of the distribution.
5308 : * @param __param The new parameter set of the distribution.
5309 : */
5310 : void
5311 : param(const param_type& __param)
5312 : { _M_param = __param; }
5313 :
5314 : /**
5315 : * @brief Returns the greatest lower bound value of the distribution.
5316 : */
5317 : result_type
5318 : min() const
5319 : { return std::numeric_limits<result_type>::lowest(); }
5320 :
5321 : /**
5322 : * @brief Returns the least upper bound value of the distribution.
5323 : */
5324 : result_type
5325 : max() const
5326 : { return std::numeric_limits<result_type>::max(); }
5327 :
5328 : /**
5329 : * @brief Generating functions.
5330 : */
5331 : template<typename _UniformRandomNumberGenerator>
5332 : result_type
5333 : operator()(_UniformRandomNumberGenerator& __urng)
5334 : { return this->operator()(__urng, _M_param); }
5335 :
5336 : template<typename _UniformRandomNumberGenerator>
5337 : result_type
5338 : operator()(_UniformRandomNumberGenerator& __urng,
5339 : const param_type& __p);
5340 :
5341 : template<typename _ForwardIterator,
5342 : typename _UniformRandomNumberGenerator>
5343 : void
5344 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5345 : _UniformRandomNumberGenerator& __urng)
5346 : { this->__generate(__f, __t, __urng, _M_param); }
5347 :
5348 : template<typename _ForwardIterator,
5349 : typename _UniformRandomNumberGenerator>
5350 : void
5351 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5352 : _UniformRandomNumberGenerator& __urng,
5353 : const param_type& __p)
5354 : { this->__generate_impl(__f, __t, __urng, __p); }
5355 :
5356 : template<typename _UniformRandomNumberGenerator>
5357 : void
5358 : __generate(result_type* __f, result_type* __t,
5359 : _UniformRandomNumberGenerator& __urng,
5360 : const param_type& __p)
5361 : { this->__generate_impl(__f, __t, __urng, __p); }
5362 :
5363 : /**
5364 : * @brief Return true if two extreme value distributions have the same
5365 : * parameters.
5366 : */
5367 : friend bool
5368 : operator==(const extreme_value_distribution& __d1,
5369 : const extreme_value_distribution& __d2)
5370 : { return __d1._M_param == __d2._M_param; }
5371 :
5372 : private:
5373 : template<typename _ForwardIterator,
5374 : typename _UniformRandomNumberGenerator>
5375 : void
5376 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5377 : _UniformRandomNumberGenerator& __urng,
5378 : const param_type& __p);
5379 :
5380 : param_type _M_param;
5381 : };
5382 :
5383 : #if __cpp_impl_three_way_comparison < 201907L
5384 : /**
5385 : * @brief Return true if two extreme value distributions have different
5386 : * parameters.
5387 : */
5388 : template<typename _RealType>
5389 : inline bool
5390 : operator!=(const std::extreme_value_distribution<_RealType>& __d1,
5391 : const std::extreme_value_distribution<_RealType>& __d2)
5392 : { return !(__d1 == __d2); }
5393 : #endif
5394 :
5395 : /**
5396 : * @brief Inserts a %extreme_value_distribution random number distribution
5397 : * @p __x into the output stream @p __os.
5398 : *
5399 : * @param __os An output stream.
5400 : * @param __x A %extreme_value_distribution random number distribution.
5401 : *
5402 : * @returns The output stream with the state of @p __x inserted or in
5403 : * an error state.
5404 : */
5405 : template<typename _RealType, typename _CharT, typename _Traits>
5406 : std::basic_ostream<_CharT, _Traits>&
5407 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5408 : const std::extreme_value_distribution<_RealType>& __x);
5409 :
5410 : /**
5411 : * @brief Extracts a %extreme_value_distribution random number
5412 : * distribution @p __x from the input stream @p __is.
5413 : *
5414 : * @param __is An input stream.
5415 : * @param __x A %extreme_value_distribution random number
5416 : * generator engine.
5417 : *
5418 : * @returns The input stream with @p __x extracted or in an error state.
5419 : */
5420 : template<typename _RealType, typename _CharT, typename _Traits>
5421 : std::basic_istream<_CharT, _Traits>&
5422 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
5423 : std::extreme_value_distribution<_RealType>& __x);
5424 :
5425 : /// @} group random_distributions_poisson
5426 :
5427 : /**
5428 : * @addtogroup random_distributions_sampling Sampling Distributions
5429 : * @ingroup random_distributions
5430 : * @{
5431 : */
5432 :
5433 : /**
5434 : * @brief A discrete_distribution random number distribution.
5435 : *
5436 : * This distribution produces random numbers @f$ i, 0 \leq i < n @f$,
5437 : * distributed according to the probability mass function
5438 : * @f$ p(i | p_0, ..., p_{n-1}) = p_i @f$.
5439 : *
5440 : * @headerfile random
5441 : * @since C++11
5442 : */
5443 : template<typename _IntType = int>
5444 : class discrete_distribution
5445 : {
5446 : static_assert(std::is_integral<_IntType>::value,
5447 : "result_type must be an integral type");
5448 :
5449 : public:
5450 : /** The type of the range of the distribution. */
5451 : typedef _IntType result_type;
5452 :
5453 : /** Parameter type. */
5454 : struct param_type
5455 : {
5456 : typedef discrete_distribution<_IntType> distribution_type;
5457 : friend class discrete_distribution<_IntType>;
5458 :
5459 : param_type()
5460 : : _M_prob(), _M_cp()
5461 : { }
5462 :
5463 : template<typename _InputIterator>
5464 : param_type(_InputIterator __wbegin,
5465 : _InputIterator __wend)
5466 : : _M_prob(__wbegin, __wend), _M_cp()
5467 : { _M_initialize(); }
5468 :
5469 : param_type(initializer_list<double> __wil)
5470 : : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5471 : { _M_initialize(); }
5472 :
5473 : template<typename _Func>
5474 : param_type(size_t __nw, double __xmin, double __xmax,
5475 : _Func __fw);
5476 :
5477 : // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5478 : param_type(const param_type&) = default;
5479 : param_type& operator=(const param_type&) = default;
5480 :
5481 : std::vector<double>
5482 : probabilities() const
5483 : { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
5484 :
5485 : friend bool
5486 : operator==(const param_type& __p1, const param_type& __p2)
5487 : { return __p1._M_prob == __p2._M_prob; }
5488 :
5489 : #if __cpp_impl_three_way_comparison < 201907L
5490 : friend bool
5491 : operator!=(const param_type& __p1, const param_type& __p2)
5492 : { return !(__p1 == __p2); }
5493 : #endif
5494 :
5495 : private:
5496 : void
5497 : _M_initialize();
5498 :
5499 : std::vector<double> _M_prob;
5500 : std::vector<double> _M_cp;
5501 : };
5502 :
5503 : discrete_distribution()
5504 : : _M_param()
5505 : { }
5506 :
5507 : template<typename _InputIterator>
5508 : discrete_distribution(_InputIterator __wbegin,
5509 : _InputIterator __wend)
5510 : : _M_param(__wbegin, __wend)
5511 : { }
5512 :
5513 : discrete_distribution(initializer_list<double> __wl)
5514 : : _M_param(__wl)
5515 : { }
5516 :
5517 : template<typename _Func>
5518 : discrete_distribution(size_t __nw, double __xmin, double __xmax,
5519 : _Func __fw)
5520 : : _M_param(__nw, __xmin, __xmax, __fw)
5521 : { }
5522 :
5523 : explicit
5524 : discrete_distribution(const param_type& __p)
5525 : : _M_param(__p)
5526 : { }
5527 :
5528 : /**
5529 : * @brief Resets the distribution state.
5530 : */
5531 : void
5532 : reset()
5533 : { }
5534 :
5535 : /**
5536 : * @brief Returns the probabilities of the distribution.
5537 : */
5538 : std::vector<double>
5539 : probabilities() const
5540 : {
5541 : return _M_param._M_prob.empty()
5542 : ? std::vector<double>(1, 1.0) : _M_param._M_prob;
5543 : }
5544 :
5545 : /**
5546 : * @brief Returns the parameter set of the distribution.
5547 : */
5548 : param_type
5549 : param() const
5550 : { return _M_param; }
5551 :
5552 : /**
5553 : * @brief Sets the parameter set of the distribution.
5554 : * @param __param The new parameter set of the distribution.
5555 : */
5556 : void
5557 : param(const param_type& __param)
5558 : { _M_param = __param; }
5559 :
5560 : /**
5561 : * @brief Returns the greatest lower bound value of the distribution.
5562 : */
5563 : result_type
5564 : min() const
5565 : { return result_type(0); }
5566 :
5567 : /**
5568 : * @brief Returns the least upper bound value of the distribution.
5569 : */
5570 : result_type
5571 : max() const
5572 : {
5573 : return _M_param._M_prob.empty()
5574 : ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
5575 : }
5576 :
5577 : /**
5578 : * @brief Generating functions.
5579 : */
5580 : template<typename _UniformRandomNumberGenerator>
5581 : result_type
5582 : operator()(_UniformRandomNumberGenerator& __urng)
5583 : { return this->operator()(__urng, _M_param); }
5584 :
5585 : template<typename _UniformRandomNumberGenerator>
5586 : result_type
5587 : operator()(_UniformRandomNumberGenerator& __urng,
5588 : const param_type& __p);
5589 :
5590 : template<typename _ForwardIterator,
5591 : typename _UniformRandomNumberGenerator>
5592 : void
5593 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5594 : _UniformRandomNumberGenerator& __urng)
5595 : { this->__generate(__f, __t, __urng, _M_param); }
5596 :
5597 : template<typename _ForwardIterator,
5598 : typename _UniformRandomNumberGenerator>
5599 : void
5600 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5601 : _UniformRandomNumberGenerator& __urng,
5602 : const param_type& __p)
5603 : { this->__generate_impl(__f, __t, __urng, __p); }
5604 :
5605 : template<typename _UniformRandomNumberGenerator>
5606 : void
5607 : __generate(result_type* __f, result_type* __t,
5608 : _UniformRandomNumberGenerator& __urng,
5609 : const param_type& __p)
5610 : { this->__generate_impl(__f, __t, __urng, __p); }
5611 :
5612 : /**
5613 : * @brief Return true if two discrete distributions have the same
5614 : * parameters.
5615 : */
5616 : friend bool
5617 : operator==(const discrete_distribution& __d1,
5618 : const discrete_distribution& __d2)
5619 : { return __d1._M_param == __d2._M_param; }
5620 :
5621 : /**
5622 : * @brief Inserts a %discrete_distribution random number distribution
5623 : * @p __x into the output stream @p __os.
5624 : *
5625 : * @param __os An output stream.
5626 : * @param __x A %discrete_distribution random number distribution.
5627 : *
5628 : * @returns The output stream with the state of @p __x inserted or in
5629 : * an error state.
5630 : */
5631 : template<typename _IntType1, typename _CharT, typename _Traits>
5632 : friend std::basic_ostream<_CharT, _Traits>&
5633 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5634 : const std::discrete_distribution<_IntType1>& __x);
5635 :
5636 : /**
5637 : * @brief Extracts a %discrete_distribution random number distribution
5638 : * @p __x from the input stream @p __is.
5639 : *
5640 : * @param __is An input stream.
5641 : * @param __x A %discrete_distribution random number
5642 : * generator engine.
5643 : *
5644 : * @returns The input stream with @p __x extracted or in an error
5645 : * state.
5646 : */
5647 : template<typename _IntType1, typename _CharT, typename _Traits>
5648 : friend std::basic_istream<_CharT, _Traits>&
5649 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
5650 : std::discrete_distribution<_IntType1>& __x);
5651 :
5652 : private:
5653 : template<typename _ForwardIterator,
5654 : typename _UniformRandomNumberGenerator>
5655 : void
5656 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5657 : _UniformRandomNumberGenerator& __urng,
5658 : const param_type& __p);
5659 :
5660 : param_type _M_param;
5661 : };
5662 :
5663 : #if __cpp_impl_three_way_comparison < 201907L
5664 : /**
5665 : * @brief Return true if two discrete distributions have different
5666 : * parameters.
5667 : */
5668 : template<typename _IntType>
5669 : inline bool
5670 : operator!=(const std::discrete_distribution<_IntType>& __d1,
5671 : const std::discrete_distribution<_IntType>& __d2)
5672 : { return !(__d1 == __d2); }
5673 : #endif
5674 :
5675 : /**
5676 : * @brief A piecewise_constant_distribution random number distribution.
5677 : *
5678 : * This distribution produces random numbers @f$ x, b_0 \leq x < b_n @f$,
5679 : * uniformly distributed over each subinterval @f$ [b_i, b_{i+1}) @f$
5680 : * according to the probability mass function
5681 : * @f[
5682 : * p(x | b_0, ..., b_n, \rho_0, ..., \rho_{n-1})
5683 : * = \rho_i \cdot \frac{b_{i+1} - x}{b_{i+1} - b_i}
5684 : * + \rho_{i+1} \cdot \frac{ x - b_i}{b_{i+1} - b_i}
5685 : * @f]
5686 : * for @f$ b_i \leq x < b_{i+1} @f$.
5687 : *
5688 : * @headerfile random
5689 : * @since C++11
5690 : */
5691 : template<typename _RealType = double>
5692 : class piecewise_constant_distribution
5693 : {
5694 : static_assert(std::is_floating_point<_RealType>::value,
5695 : "result_type must be a floating point type");
5696 :
5697 : public:
5698 : /** The type of the range of the distribution. */
5699 : typedef _RealType result_type;
5700 :
5701 : /** Parameter type. */
5702 : struct param_type
5703 : {
5704 : typedef piecewise_constant_distribution<_RealType> distribution_type;
5705 : friend class piecewise_constant_distribution<_RealType>;
5706 :
5707 : param_type()
5708 : : _M_int(), _M_den(), _M_cp()
5709 : { }
5710 :
5711 : template<typename _InputIteratorB, typename _InputIteratorW>
5712 : param_type(_InputIteratorB __bfirst,
5713 : _InputIteratorB __bend,
5714 : _InputIteratorW __wbegin);
5715 :
5716 : template<typename _Func>
5717 : param_type(initializer_list<_RealType> __bi, _Func __fw);
5718 :
5719 : template<typename _Func>
5720 : param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
5721 : _Func __fw);
5722 :
5723 : // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5724 : param_type(const param_type&) = default;
5725 : param_type& operator=(const param_type&) = default;
5726 :
5727 : std::vector<_RealType>
5728 : intervals() const
5729 : {
5730 : if (_M_int.empty())
5731 : {
5732 : std::vector<_RealType> __tmp(2);
5733 : __tmp[1] = _RealType(1);
5734 : return __tmp;
5735 : }
5736 : else
5737 : return _M_int;
5738 : }
5739 :
5740 : std::vector<double>
5741 : densities() const
5742 : { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
5743 :
5744 : friend bool
5745 : operator==(const param_type& __p1, const param_type& __p2)
5746 : { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5747 :
5748 : #if __cpp_impl_three_way_comparison < 201907L
5749 : friend bool
5750 : operator!=(const param_type& __p1, const param_type& __p2)
5751 : { return !(__p1 == __p2); }
5752 : #endif
5753 :
5754 : private:
5755 : void
5756 : _M_initialize();
5757 :
5758 : std::vector<_RealType> _M_int;
5759 : std::vector<double> _M_den;
5760 : std::vector<double> _M_cp;
5761 : };
5762 :
5763 : piecewise_constant_distribution()
5764 : : _M_param()
5765 : { }
5766 :
5767 : template<typename _InputIteratorB, typename _InputIteratorW>
5768 : piecewise_constant_distribution(_InputIteratorB __bfirst,
5769 : _InputIteratorB __bend,
5770 : _InputIteratorW __wbegin)
5771 : : _M_param(__bfirst, __bend, __wbegin)
5772 : { }
5773 :
5774 : template<typename _Func>
5775 : piecewise_constant_distribution(initializer_list<_RealType> __bl,
5776 : _Func __fw)
5777 : : _M_param(__bl, __fw)
5778 : { }
5779 :
5780 : template<typename _Func>
5781 : piecewise_constant_distribution(size_t __nw,
5782 : _RealType __xmin, _RealType __xmax,
5783 : _Func __fw)
5784 : : _M_param(__nw, __xmin, __xmax, __fw)
5785 : { }
5786 :
5787 : explicit
5788 : piecewise_constant_distribution(const param_type& __p)
5789 : : _M_param(__p)
5790 : { }
5791 :
5792 : /**
5793 : * @brief Resets the distribution state.
5794 : */
5795 : void
5796 : reset()
5797 : { }
5798 :
5799 : /**
5800 : * @brief Returns a vector of the intervals.
5801 : */
5802 : std::vector<_RealType>
5803 : intervals() const
5804 : {
5805 : if (_M_param._M_int.empty())
5806 : {
5807 : std::vector<_RealType> __tmp(2);
5808 : __tmp[1] = _RealType(1);
5809 : return __tmp;
5810 : }
5811 : else
5812 : return _M_param._M_int;
5813 : }
5814 :
5815 : /**
5816 : * @brief Returns a vector of the probability densities.
5817 : */
5818 : std::vector<double>
5819 : densities() const
5820 : {
5821 : return _M_param._M_den.empty()
5822 : ? std::vector<double>(1, 1.0) : _M_param._M_den;
5823 : }
5824 :
5825 : /**
5826 : * @brief Returns the parameter set of the distribution.
5827 : */
5828 : param_type
5829 : param() const
5830 : { return _M_param; }
5831 :
5832 : /**
5833 : * @brief Sets the parameter set of the distribution.
5834 : * @param __param The new parameter set of the distribution.
5835 : */
5836 : void
5837 : param(const param_type& __param)
5838 : { _M_param = __param; }
5839 :
5840 : /**
5841 : * @brief Returns the greatest lower bound value of the distribution.
5842 : */
5843 : result_type
5844 : min() const
5845 : {
5846 : return _M_param._M_int.empty()
5847 : ? result_type(0) : _M_param._M_int.front();
5848 : }
5849 :
5850 : /**
5851 : * @brief Returns the least upper bound value of the distribution.
5852 : */
5853 : result_type
5854 : max() const
5855 : {
5856 : return _M_param._M_int.empty()
5857 : ? result_type(1) : _M_param._M_int.back();
5858 : }
5859 :
5860 : /**
5861 : * @brief Generating functions.
5862 : */
5863 : template<typename _UniformRandomNumberGenerator>
5864 : result_type
5865 : operator()(_UniformRandomNumberGenerator& __urng)
5866 : { return this->operator()(__urng, _M_param); }
5867 :
5868 : template<typename _UniformRandomNumberGenerator>
5869 : result_type
5870 : operator()(_UniformRandomNumberGenerator& __urng,
5871 : const param_type& __p);
5872 :
5873 : template<typename _ForwardIterator,
5874 : typename _UniformRandomNumberGenerator>
5875 : void
5876 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5877 : _UniformRandomNumberGenerator& __urng)
5878 : { this->__generate(__f, __t, __urng, _M_param); }
5879 :
5880 : template<typename _ForwardIterator,
5881 : typename _UniformRandomNumberGenerator>
5882 : void
5883 : __generate(_ForwardIterator __f, _ForwardIterator __t,
5884 : _UniformRandomNumberGenerator& __urng,
5885 : const param_type& __p)
5886 : { this->__generate_impl(__f, __t, __urng, __p); }
5887 :
5888 : template<typename _UniformRandomNumberGenerator>
5889 : void
5890 : __generate(result_type* __f, result_type* __t,
5891 : _UniformRandomNumberGenerator& __urng,
5892 : const param_type& __p)
5893 : { this->__generate_impl(__f, __t, __urng, __p); }
5894 :
5895 : /**
5896 : * @brief Return true if two piecewise constant distributions have the
5897 : * same parameters.
5898 : */
5899 : friend bool
5900 : operator==(const piecewise_constant_distribution& __d1,
5901 : const piecewise_constant_distribution& __d2)
5902 : { return __d1._M_param == __d2._M_param; }
5903 :
5904 : /**
5905 : * @brief Inserts a %piecewise_constant_distribution random
5906 : * number distribution @p __x into the output stream @p __os.
5907 : *
5908 : * @param __os An output stream.
5909 : * @param __x A %piecewise_constant_distribution random number
5910 : * distribution.
5911 : *
5912 : * @returns The output stream with the state of @p __x inserted or in
5913 : * an error state.
5914 : */
5915 : template<typename _RealType1, typename _CharT, typename _Traits>
5916 : friend std::basic_ostream<_CharT, _Traits>&
5917 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5918 : const std::piecewise_constant_distribution<_RealType1>& __x);
5919 :
5920 : /**
5921 : * @brief Extracts a %piecewise_constant_distribution random
5922 : * number distribution @p __x from the input stream @p __is.
5923 : *
5924 : * @param __is An input stream.
5925 : * @param __x A %piecewise_constant_distribution random number
5926 : * generator engine.
5927 : *
5928 : * @returns The input stream with @p __x extracted or in an error
5929 : * state.
5930 : */
5931 : template<typename _RealType1, typename _CharT, typename _Traits>
5932 : friend std::basic_istream<_CharT, _Traits>&
5933 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
5934 : std::piecewise_constant_distribution<_RealType1>& __x);
5935 :
5936 : private:
5937 : template<typename _ForwardIterator,
5938 : typename _UniformRandomNumberGenerator>
5939 : void
5940 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5941 : _UniformRandomNumberGenerator& __urng,
5942 : const param_type& __p);
5943 :
5944 : param_type _M_param;
5945 : };
5946 :
5947 : #if __cpp_impl_three_way_comparison < 201907L
5948 : /**
5949 : * @brief Return true if two piecewise constant distributions have
5950 : * different parameters.
5951 : */
5952 : template<typename _RealType>
5953 : inline bool
5954 : operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
5955 : const std::piecewise_constant_distribution<_RealType>& __d2)
5956 : { return !(__d1 == __d2); }
5957 : #endif
5958 :
5959 : /**
5960 : * @brief A piecewise_linear_distribution random number distribution.
5961 : *
5962 : * This distribution produces random numbers @f$ x, b_0 \leq x < b_n @f$,
5963 : * distributed over each subinterval @f$ [b_i, b_{i+1}) @f$
5964 : * according to the probability mass function
5965 : * @f$ p(x | b_0, ..., b_n, \rho_0, ..., \rho_n) = \rho_i @f$,
5966 : * for @f$ b_i \leq x < b_{i+1} @f$.
5967 : *
5968 : * @headerfile random
5969 : * @since C++11
5970 : */
5971 : template<typename _RealType = double>
5972 : class piecewise_linear_distribution
5973 : {
5974 : static_assert(std::is_floating_point<_RealType>::value,
5975 : "result_type must be a floating point type");
5976 :
5977 : public:
5978 : /** The type of the range of the distribution. */
5979 : typedef _RealType result_type;
5980 :
5981 : /** Parameter type. */
5982 : struct param_type
5983 : {
5984 : typedef piecewise_linear_distribution<_RealType> distribution_type;
5985 : friend class piecewise_linear_distribution<_RealType>;
5986 :
5987 : param_type()
5988 : : _M_int(), _M_den(), _M_cp(), _M_m()
5989 : { }
5990 :
5991 : template<typename _InputIteratorB, typename _InputIteratorW>
5992 : param_type(_InputIteratorB __bfirst,
5993 : _InputIteratorB __bend,
5994 : _InputIteratorW __wbegin);
5995 :
5996 : template<typename _Func>
5997 : param_type(initializer_list<_RealType> __bl, _Func __fw);
5998 :
5999 : template<typename _Func>
6000 : param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
6001 : _Func __fw);
6002 :
6003 : // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
6004 : param_type(const param_type&) = default;
6005 : param_type& operator=(const param_type&) = default;
6006 :
6007 : std::vector<_RealType>
6008 : intervals() const
6009 : {
6010 : if (_M_int.empty())
6011 : {
6012 : std::vector<_RealType> __tmp(2);
6013 : __tmp[1] = _RealType(1);
6014 : return __tmp;
6015 : }
6016 : else
6017 : return _M_int;
6018 : }
6019 :
6020 : std::vector<double>
6021 : densities() const
6022 : { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
6023 :
6024 : friend bool
6025 : operator==(const param_type& __p1, const param_type& __p2)
6026 : { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
6027 :
6028 : #if __cpp_impl_three_way_comparison < 201907L
6029 : friend bool
6030 : operator!=(const param_type& __p1, const param_type& __p2)
6031 : { return !(__p1 == __p2); }
6032 : #endif
6033 :
6034 : private:
6035 : void
6036 : _M_initialize();
6037 :
6038 : std::vector<_RealType> _M_int;
6039 : std::vector<double> _M_den;
6040 : std::vector<double> _M_cp;
6041 : std::vector<double> _M_m;
6042 : };
6043 :
6044 : piecewise_linear_distribution()
6045 : : _M_param()
6046 : { }
6047 :
6048 : template<typename _InputIteratorB, typename _InputIteratorW>
6049 : piecewise_linear_distribution(_InputIteratorB __bfirst,
6050 : _InputIteratorB __bend,
6051 : _InputIteratorW __wbegin)
6052 : : _M_param(__bfirst, __bend, __wbegin)
6053 : { }
6054 :
6055 : template<typename _Func>
6056 : piecewise_linear_distribution(initializer_list<_RealType> __bl,
6057 : _Func __fw)
6058 : : _M_param(__bl, __fw)
6059 : { }
6060 :
6061 : template<typename _Func>
6062 : piecewise_linear_distribution(size_t __nw,
6063 : _RealType __xmin, _RealType __xmax,
6064 : _Func __fw)
6065 : : _M_param(__nw, __xmin, __xmax, __fw)
6066 : { }
6067 :
6068 : explicit
6069 : piecewise_linear_distribution(const param_type& __p)
6070 : : _M_param(__p)
6071 : { }
6072 :
6073 : /**
6074 : * Resets the distribution state.
6075 : */
6076 : void
6077 : reset()
6078 : { }
6079 :
6080 : /**
6081 : * @brief Return the intervals of the distribution.
6082 : */
6083 : std::vector<_RealType>
6084 : intervals() const
6085 : {
6086 : if (_M_param._M_int.empty())
6087 : {
6088 : std::vector<_RealType> __tmp(2);
6089 : __tmp[1] = _RealType(1);
6090 : return __tmp;
6091 : }
6092 : else
6093 : return _M_param._M_int;
6094 : }
6095 :
6096 : /**
6097 : * @brief Return a vector of the probability densities of the
6098 : * distribution.
6099 : */
6100 : std::vector<double>
6101 : densities() const
6102 : {
6103 : return _M_param._M_den.empty()
6104 : ? std::vector<double>(2, 1.0) : _M_param._M_den;
6105 : }
6106 :
6107 : /**
6108 : * @brief Returns the parameter set of the distribution.
6109 : */
6110 : param_type
6111 : param() const
6112 : { return _M_param; }
6113 :
6114 : /**
6115 : * @brief Sets the parameter set of the distribution.
6116 : * @param __param The new parameter set of the distribution.
6117 : */
6118 : void
6119 : param(const param_type& __param)
6120 : { _M_param = __param; }
6121 :
6122 : /**
6123 : * @brief Returns the greatest lower bound value of the distribution.
6124 : */
6125 : result_type
6126 : min() const
6127 : {
6128 : return _M_param._M_int.empty()
6129 : ? result_type(0) : _M_param._M_int.front();
6130 : }
6131 :
6132 : /**
6133 : * @brief Returns the least upper bound value of the distribution.
6134 : */
6135 : result_type
6136 : max() const
6137 : {
6138 : return _M_param._M_int.empty()
6139 : ? result_type(1) : _M_param._M_int.back();
6140 : }
6141 :
6142 : /**
6143 : * @brief Generating functions.
6144 : */
6145 : template<typename _UniformRandomNumberGenerator>
6146 : result_type
6147 : operator()(_UniformRandomNumberGenerator& __urng)
6148 : { return this->operator()(__urng, _M_param); }
6149 :
6150 : template<typename _UniformRandomNumberGenerator>
6151 : result_type
6152 : operator()(_UniformRandomNumberGenerator& __urng,
6153 : const param_type& __p);
6154 :
6155 : template<typename _ForwardIterator,
6156 : typename _UniformRandomNumberGenerator>
6157 : void
6158 : __generate(_ForwardIterator __f, _ForwardIterator __t,
6159 : _UniformRandomNumberGenerator& __urng)
6160 : { this->__generate(__f, __t, __urng, _M_param); }
6161 :
6162 : template<typename _ForwardIterator,
6163 : typename _UniformRandomNumberGenerator>
6164 : void
6165 : __generate(_ForwardIterator __f, _ForwardIterator __t,
6166 : _UniformRandomNumberGenerator& __urng,
6167 : const param_type& __p)
6168 : { this->__generate_impl(__f, __t, __urng, __p); }
6169 :
6170 : template<typename _UniformRandomNumberGenerator>
6171 : void
6172 : __generate(result_type* __f, result_type* __t,
6173 : _UniformRandomNumberGenerator& __urng,
6174 : const param_type& __p)
6175 : { this->__generate_impl(__f, __t, __urng, __p); }
6176 :
6177 : /**
6178 : * @brief Return true if two piecewise linear distributions have the
6179 : * same parameters.
6180 : */
6181 : friend bool
6182 : operator==(const piecewise_linear_distribution& __d1,
6183 : const piecewise_linear_distribution& __d2)
6184 : { return __d1._M_param == __d2._M_param; }
6185 :
6186 : /**
6187 : * @brief Inserts a %piecewise_linear_distribution random number
6188 : * distribution @p __x into the output stream @p __os.
6189 : *
6190 : * @param __os An output stream.
6191 : * @param __x A %piecewise_linear_distribution random number
6192 : * distribution.
6193 : *
6194 : * @returns The output stream with the state of @p __x inserted or in
6195 : * an error state.
6196 : */
6197 : template<typename _RealType1, typename _CharT, typename _Traits>
6198 : friend std::basic_ostream<_CharT, _Traits>&
6199 : operator<<(std::basic_ostream<_CharT, _Traits>& __os,
6200 : const std::piecewise_linear_distribution<_RealType1>& __x);
6201 :
6202 : /**
6203 : * @brief Extracts a %piecewise_linear_distribution random number
6204 : * distribution @p __x from the input stream @p __is.
6205 : *
6206 : * @param __is An input stream.
6207 : * @param __x A %piecewise_linear_distribution random number
6208 : * generator engine.
6209 : *
6210 : * @returns The input stream with @p __x extracted or in an error
6211 : * state.
6212 : */
6213 : template<typename _RealType1, typename _CharT, typename _Traits>
6214 : friend std::basic_istream<_CharT, _Traits>&
6215 : operator>>(std::basic_istream<_CharT, _Traits>& __is,
6216 : std::piecewise_linear_distribution<_RealType1>& __x);
6217 :
6218 : private:
6219 : template<typename _ForwardIterator,
6220 : typename _UniformRandomNumberGenerator>
6221 : void
6222 : __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
6223 : _UniformRandomNumberGenerator& __urng,
6224 : const param_type& __p);
6225 :
6226 : param_type _M_param;
6227 : };
6228 :
6229 : #if __cpp_impl_three_way_comparison < 201907L
6230 : /**
6231 : * @brief Return true if two piecewise linear distributions have
6232 : * different parameters.
6233 : */
6234 : template<typename _RealType>
6235 : inline bool
6236 : operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
6237 : const std::piecewise_linear_distribution<_RealType>& __d2)
6238 : { return !(__d1 == __d2); }
6239 : #endif
6240 :
6241 : /// @} group random_distributions_sampling
6242 :
6243 : /// @} *group random_distributions
6244 :
6245 : /**
6246 : * @addtogroup random_utilities Random Number Utilities
6247 : * @ingroup random
6248 : * @{
6249 : */
6250 :
6251 : /**
6252 : * @brief The seed_seq class generates sequences of seeds for random
6253 : * number generators.
6254 : *
6255 : * @headerfile random
6256 : * @since C++11
6257 : */
6258 : class seed_seq
6259 : {
6260 : public:
6261 : /** The type of the seed vales. */
6262 : typedef uint_least32_t result_type;
6263 :
6264 : /** Default constructor. */
6265 : seed_seq() noexcept
6266 : : _M_v()
6267 : { }
6268 :
6269 : template<typename _IntType, typename = _Require<is_integral<_IntType>>>
6270 : seed_seq(std::initializer_list<_IntType> __il);
6271 :
6272 : template<typename _InputIterator>
6273 : seed_seq(_InputIterator __begin, _InputIterator __end);
6274 :
6275 : // generating functions
6276 : template<typename _RandomAccessIterator>
6277 : void
6278 : generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6279 :
6280 : // property functions
6281 : size_t size() const noexcept
6282 : { return _M_v.size(); }
6283 :
6284 : template<typename _OutputIterator>
6285 : void
6286 : param(_OutputIterator __dest) const
6287 : { std::copy(_M_v.begin(), _M_v.end(), __dest); }
6288 :
6289 : // no copy functions
6290 : seed_seq(const seed_seq&) = delete;
6291 : seed_seq& operator=(const seed_seq&) = delete;
6292 :
6293 : private:
6294 : std::vector<result_type> _M_v;
6295 : };
6296 :
6297 : /// @} group random_utilities
6298 :
6299 : /// @} group random
6300 :
6301 : _GLIBCXX_END_NAMESPACE_VERSION
6302 : } // namespace std
6303 :
6304 : #endif
|
