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