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