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