libstdc++

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