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