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