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