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