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