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