libstdc++
bits/random.tcc
Go to the documentation of this file.
1 // random number generation (out of line) -*- C++ -*-
2 
3 // Copyright (C) 2009-2021 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 /** @file bits/random.tcc
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{random}
28  */
29 
30 #ifndef _RANDOM_TCC
31 #define _RANDOM_TCC 1
32 
33 #include <numeric> // std::accumulate and std::partial_sum
34 
35 namespace std _GLIBCXX_VISIBILITY(default)
36 {
37 _GLIBCXX_BEGIN_NAMESPACE_VERSION
38 
39  /*
40  * (Further) implementation-space details.
41  */
42  namespace __detail
43  {
44  // General case for x = (ax + c) mod m -- use Schrage's algorithm
45  // to avoid integer overflow.
46  //
47  // Preconditions: a > 0, m > 0.
48  //
49  // Note: only works correctly for __m % __a < __m / __a.
50  template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
51  _Tp
52  _Mod<_Tp, __m, __a, __c, false, true>::
53  __calc(_Tp __x)
54  {
55  if (__a == 1)
56  __x %= __m;
57  else
58  {
59  static const _Tp __q = __m / __a;
60  static const _Tp __r = __m % __a;
61 
62  _Tp __t1 = __a * (__x % __q);
63  _Tp __t2 = __r * (__x / __q);
64  if (__t1 >= __t2)
65  __x = __t1 - __t2;
66  else
67  __x = __m - __t2 + __t1;
68  }
69 
70  if (__c != 0)
71  {
72  const _Tp __d = __m - __x;
73  if (__d > __c)
74  __x += __c;
75  else
76  __x = __c - __d;
77  }
78  return __x;
79  }
80 
81  template<typename _InputIterator, typename _OutputIterator,
82  typename _Tp>
83  _OutputIterator
84  __normalize(_InputIterator __first, _InputIterator __last,
85  _OutputIterator __result, const _Tp& __factor)
86  {
87  for (; __first != __last; ++__first, ++__result)
88  *__result = *__first / __factor;
89  return __result;
90  }
91 
92  } // namespace __detail
93 
94  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
95  constexpr _UIntType
97 
98  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
99  constexpr _UIntType
101 
102  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
103  constexpr _UIntType
105 
106  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
107  constexpr _UIntType
108  linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
109 
110  /**
111  * Seeds the LCR with integral value @p __s, adjusted so that the
112  * ring identity is never a member of the convergence set.
113  */
114  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
115  void
117  seed(result_type __s)
118  {
119  if ((__detail::__mod<_UIntType, __m>(__c) == 0)
120  && (__detail::__mod<_UIntType, __m>(__s) == 0))
121  _M_x = 1;
122  else
123  _M_x = __detail::__mod<_UIntType, __m>(__s);
124  }
125 
126  /**
127  * Seeds the LCR engine with a value generated by @p __q.
128  */
129  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
130  template<typename _Sseq>
131  auto
133  seed(_Sseq& __q)
134  -> _If_seed_seq<_Sseq>
135  {
136  const _UIntType __k0 = __m == 0 ? std::numeric_limits<_UIntType>::digits
137  : std::__lg(__m);
138  const _UIntType __k = (__k0 + 31) / 32;
139  uint_least32_t __arr[__k + 3];
140  __q.generate(__arr + 0, __arr + __k + 3);
141  _UIntType __factor = 1u;
142  _UIntType __sum = 0u;
143  for (size_t __j = 0; __j < __k; ++__j)
144  {
145  __sum += __arr[__j + 3] * __factor;
146  __factor *= __detail::_Shift<_UIntType, 32>::__value;
147  }
148  seed(__sum);
149  }
150 
151  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
152  typename _CharT, typename _Traits>
155  const linear_congruential_engine<_UIntType,
156  __a, __c, __m>& __lcr)
157  {
158  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
159 
160  const typename __ios_base::fmtflags __flags = __os.flags();
161  const _CharT __fill = __os.fill();
163  __os.fill(__os.widen(' '));
164 
165  __os << __lcr._M_x;
166 
167  __os.flags(__flags);
168  __os.fill(__fill);
169  return __os;
170  }
171 
172  template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m,
173  typename _CharT, typename _Traits>
176  linear_congruential_engine<_UIntType, __a, __c, __m>& __lcr)
177  {
178  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
179 
180  const typename __ios_base::fmtflags __flags = __is.flags();
181  __is.flags(__ios_base::dec);
182 
183  __is >> __lcr._M_x;
184 
185  __is.flags(__flags);
186  return __is;
187  }
188 
189 
190  template<typename _UIntType,
191  size_t __w, size_t __n, size_t __m, size_t __r,
192  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
193  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
194  _UIntType __f>
195  constexpr size_t
196  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
197  __s, __b, __t, __c, __l, __f>::word_size;
198 
199  template<typename _UIntType,
200  size_t __w, size_t __n, size_t __m, size_t __r,
201  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
202  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
203  _UIntType __f>
204  constexpr size_t
205  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
206  __s, __b, __t, __c, __l, __f>::state_size;
207 
208  template<typename _UIntType,
209  size_t __w, size_t __n, size_t __m, size_t __r,
210  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
211  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
212  _UIntType __f>
213  constexpr size_t
214  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
215  __s, __b, __t, __c, __l, __f>::shift_size;
216 
217  template<typename _UIntType,
218  size_t __w, size_t __n, size_t __m, size_t __r,
219  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
220  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
221  _UIntType __f>
222  constexpr size_t
223  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
224  __s, __b, __t, __c, __l, __f>::mask_bits;
225 
226  template<typename _UIntType,
227  size_t __w, size_t __n, size_t __m, size_t __r,
228  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
229  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
230  _UIntType __f>
231  constexpr _UIntType
232  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
233  __s, __b, __t, __c, __l, __f>::xor_mask;
234 
235  template<typename _UIntType,
236  size_t __w, size_t __n, size_t __m, size_t __r,
237  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
238  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
239  _UIntType __f>
240  constexpr size_t
241  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
242  __s, __b, __t, __c, __l, __f>::tempering_u;
243 
244  template<typename _UIntType,
245  size_t __w, size_t __n, size_t __m, size_t __r,
246  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
247  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
248  _UIntType __f>
249  constexpr _UIntType
250  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
251  __s, __b, __t, __c, __l, __f>::tempering_d;
252 
253  template<typename _UIntType,
254  size_t __w, size_t __n, size_t __m, size_t __r,
255  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
256  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
257  _UIntType __f>
258  constexpr size_t
259  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
260  __s, __b, __t, __c, __l, __f>::tempering_s;
261 
262  template<typename _UIntType,
263  size_t __w, size_t __n, size_t __m, size_t __r,
264  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
265  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
266  _UIntType __f>
267  constexpr _UIntType
268  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
269  __s, __b, __t, __c, __l, __f>::tempering_b;
270 
271  template<typename _UIntType,
272  size_t __w, size_t __n, size_t __m, size_t __r,
273  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
274  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
275  _UIntType __f>
276  constexpr size_t
277  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
278  __s, __b, __t, __c, __l, __f>::tempering_t;
279 
280  template<typename _UIntType,
281  size_t __w, size_t __n, size_t __m, size_t __r,
282  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
283  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
284  _UIntType __f>
285  constexpr _UIntType
286  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
287  __s, __b, __t, __c, __l, __f>::tempering_c;
288 
289  template<typename _UIntType,
290  size_t __w, size_t __n, size_t __m, size_t __r,
291  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
292  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
293  _UIntType __f>
294  constexpr size_t
295  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
296  __s, __b, __t, __c, __l, __f>::tempering_l;
297 
298  template<typename _UIntType,
299  size_t __w, size_t __n, size_t __m, size_t __r,
300  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
301  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
302  _UIntType __f>
303  constexpr _UIntType
304  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
305  __s, __b, __t, __c, __l, __f>::
306  initialization_multiplier;
307 
308  template<typename _UIntType,
309  size_t __w, size_t __n, size_t __m, size_t __r,
310  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
311  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
312  _UIntType __f>
313  constexpr _UIntType
314  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
315  __s, __b, __t, __c, __l, __f>::default_seed;
316 
317  template<typename _UIntType,
318  size_t __w, size_t __n, size_t __m, size_t __r,
319  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
320  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
321  _UIntType __f>
322  void
323  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
324  __s, __b, __t, __c, __l, __f>::
325  seed(result_type __sd)
326  {
327  _M_x[0] = __detail::__mod<_UIntType,
328  __detail::_Shift<_UIntType, __w>::__value>(__sd);
329 
330  for (size_t __i = 1; __i < state_size; ++__i)
331  {
332  _UIntType __x = _M_x[__i - 1];
333  __x ^= __x >> (__w - 2);
334  __x *= __f;
335  __x += __detail::__mod<_UIntType, __n>(__i);
336  _M_x[__i] = __detail::__mod<_UIntType,
337  __detail::_Shift<_UIntType, __w>::__value>(__x);
338  }
339  _M_p = state_size;
340  }
341 
342  template<typename _UIntType,
343  size_t __w, size_t __n, size_t __m, size_t __r,
344  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
345  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
346  _UIntType __f>
347  template<typename _Sseq>
348  auto
349  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
350  __s, __b, __t, __c, __l, __f>::
351  seed(_Sseq& __q)
352  -> _If_seed_seq<_Sseq>
353  {
354  const _UIntType __upper_mask = (~_UIntType()) << __r;
355  const size_t __k = (__w + 31) / 32;
356  uint_least32_t __arr[__n * __k];
357  __q.generate(__arr + 0, __arr + __n * __k);
358 
359  bool __zero = true;
360  for (size_t __i = 0; __i < state_size; ++__i)
361  {
362  _UIntType __factor = 1u;
363  _UIntType __sum = 0u;
364  for (size_t __j = 0; __j < __k; ++__j)
365  {
366  __sum += __arr[__k * __i + __j] * __factor;
367  __factor *= __detail::_Shift<_UIntType, 32>::__value;
368  }
369  _M_x[__i] = __detail::__mod<_UIntType,
370  __detail::_Shift<_UIntType, __w>::__value>(__sum);
371 
372  if (__zero)
373  {
374  if (__i == 0)
375  {
376  if ((_M_x[0] & __upper_mask) != 0u)
377  __zero = false;
378  }
379  else if (_M_x[__i] != 0u)
380  __zero = false;
381  }
382  }
383  if (__zero)
384  _M_x[0] = __detail::_Shift<_UIntType, __w - 1>::__value;
385  _M_p = state_size;
386  }
387 
388  template<typename _UIntType, size_t __w,
389  size_t __n, size_t __m, size_t __r,
390  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
391  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
392  _UIntType __f>
393  void
394  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
395  __s, __b, __t, __c, __l, __f>::
396  _M_gen_rand(void)
397  {
398  const _UIntType __upper_mask = (~_UIntType()) << __r;
399  const _UIntType __lower_mask = ~__upper_mask;
400 
401  for (size_t __k = 0; __k < (__n - __m); ++__k)
402  {
403  _UIntType __y = ((_M_x[__k] & __upper_mask)
404  | (_M_x[__k + 1] & __lower_mask));
405  _M_x[__k] = (_M_x[__k + __m] ^ (__y >> 1)
406  ^ ((__y & 0x01) ? __a : 0));
407  }
408 
409  for (size_t __k = (__n - __m); __k < (__n - 1); ++__k)
410  {
411  _UIntType __y = ((_M_x[__k] & __upper_mask)
412  | (_M_x[__k + 1] & __lower_mask));
413  _M_x[__k] = (_M_x[__k + (__m - __n)] ^ (__y >> 1)
414  ^ ((__y & 0x01) ? __a : 0));
415  }
416 
417  _UIntType __y = ((_M_x[__n - 1] & __upper_mask)
418  | (_M_x[0] & __lower_mask));
419  _M_x[__n - 1] = (_M_x[__m - 1] ^ (__y >> 1)
420  ^ ((__y & 0x01) ? __a : 0));
421  _M_p = 0;
422  }
423 
424  template<typename _UIntType, size_t __w,
425  size_t __n, size_t __m, size_t __r,
426  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
427  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
428  _UIntType __f>
429  void
430  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
431  __s, __b, __t, __c, __l, __f>::
432  discard(unsigned long long __z)
433  {
434  while (__z > state_size - _M_p)
435  {
436  __z -= state_size - _M_p;
437  _M_gen_rand();
438  }
439  _M_p += __z;
440  }
441 
442  template<typename _UIntType, size_t __w,
443  size_t __n, size_t __m, size_t __r,
444  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
445  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
446  _UIntType __f>
447  typename
448  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
449  __s, __b, __t, __c, __l, __f>::result_type
450  mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d,
451  __s, __b, __t, __c, __l, __f>::
452  operator()()
453  {
454  // Reload the vector - cost is O(n) amortized over n calls.
455  if (_M_p >= state_size)
456  _M_gen_rand();
457 
458  // Calculate o(x(i)).
459  result_type __z = _M_x[_M_p++];
460  __z ^= (__z >> __u) & __d;
461  __z ^= (__z << __s) & __b;
462  __z ^= (__z << __t) & __c;
463  __z ^= (__z >> __l);
464 
465  return __z;
466  }
467 
468  template<typename _UIntType, size_t __w,
469  size_t __n, size_t __m, size_t __r,
470  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
471  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
472  _UIntType __f, typename _CharT, typename _Traits>
475  const mersenne_twister_engine<_UIntType, __w, __n, __m,
476  __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
477  {
478  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
479 
480  const typename __ios_base::fmtflags __flags = __os.flags();
481  const _CharT __fill = __os.fill();
482  const _CharT __space = __os.widen(' ');
484  __os.fill(__space);
485 
486  for (size_t __i = 0; __i < __n; ++__i)
487  __os << __x._M_x[__i] << __space;
488  __os << __x._M_p;
489 
490  __os.flags(__flags);
491  __os.fill(__fill);
492  return __os;
493  }
494 
495  template<typename _UIntType, size_t __w,
496  size_t __n, size_t __m, size_t __r,
497  _UIntType __a, size_t __u, _UIntType __d, size_t __s,
498  _UIntType __b, size_t __t, _UIntType __c, size_t __l,
499  _UIntType __f, typename _CharT, typename _Traits>
502  mersenne_twister_engine<_UIntType, __w, __n, __m,
503  __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __x)
504  {
505  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
506 
507  const typename __ios_base::fmtflags __flags = __is.flags();
509 
510  for (size_t __i = 0; __i < __n; ++__i)
511  __is >> __x._M_x[__i];
512  __is >> __x._M_p;
513 
514  __is.flags(__flags);
515  return __is;
516  }
517 
518 
519  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
520  constexpr size_t
521  subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
522 
523  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
524  constexpr size_t
525  subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
526 
527  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
528  constexpr size_t
529  subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
530 
531  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
532  constexpr _UIntType
533  subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
534 
535  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
536  void
538  seed(result_type __value)
539  {
541  __lcg(__value == 0u ? default_seed : __value);
542 
543  const size_t __n = (__w + 31) / 32;
544 
545  for (size_t __i = 0; __i < long_lag; ++__i)
546  {
547  _UIntType __sum = 0u;
548  _UIntType __factor = 1u;
549  for (size_t __j = 0; __j < __n; ++__j)
550  {
551  __sum += __detail::__mod<uint_least32_t,
552  __detail::_Shift<uint_least32_t, 32>::__value>
553  (__lcg()) * __factor;
554  __factor *= __detail::_Shift<_UIntType, 32>::__value;
555  }
556  _M_x[__i] = __detail::__mod<_UIntType,
557  __detail::_Shift<_UIntType, __w>::__value>(__sum);
558  }
559  _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
560  _M_p = 0;
561  }
562 
563  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
564  template<typename _Sseq>
565  auto
567  seed(_Sseq& __q)
568  -> _If_seed_seq<_Sseq>
569  {
570  const size_t __k = (__w + 31) / 32;
571  uint_least32_t __arr[__r * __k];
572  __q.generate(__arr + 0, __arr + __r * __k);
573 
574  for (size_t __i = 0; __i < long_lag; ++__i)
575  {
576  _UIntType __sum = 0u;
577  _UIntType __factor = 1u;
578  for (size_t __j = 0; __j < __k; ++__j)
579  {
580  __sum += __arr[__k * __i + __j] * __factor;
581  __factor *= __detail::_Shift<_UIntType, 32>::__value;
582  }
583  _M_x[__i] = __detail::__mod<_UIntType,
584  __detail::_Shift<_UIntType, __w>::__value>(__sum);
585  }
586  _M_carry = (_M_x[long_lag - 1] == 0) ? 1 : 0;
587  _M_p = 0;
588  }
589 
590  template<typename _UIntType, size_t __w, size_t __s, size_t __r>
592  result_type
594  operator()()
595  {
596  // Derive short lag index from current index.
597  long __ps = _M_p - short_lag;
598  if (__ps < 0)
599  __ps += long_lag;
600 
601  // Calculate new x(i) without overflow or division.
602  // NB: Thanks to the requirements for _UIntType, _M_x[_M_p] + _M_carry
603  // cannot overflow.
604  _UIntType __xi;
605  if (_M_x[__ps] >= _M_x[_M_p] + _M_carry)
606  {
607  __xi = _M_x[__ps] - _M_x[_M_p] - _M_carry;
608  _M_carry = 0;
609  }
610  else
611  {
612  __xi = (__detail::_Shift<_UIntType, __w>::__value
613  - _M_x[_M_p] - _M_carry + _M_x[__ps]);
614  _M_carry = 1;
615  }
616  _M_x[_M_p] = __xi;
617 
618  // Adjust current index to loop around in ring buffer.
619  if (++_M_p >= long_lag)
620  _M_p = 0;
621 
622  return __xi;
623  }
624 
625  template<typename _UIntType, size_t __w, size_t __s, size_t __r,
626  typename _CharT, typename _Traits>
629  const subtract_with_carry_engine<_UIntType,
630  __w, __s, __r>& __x)
631  {
632  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
633 
634  const typename __ios_base::fmtflags __flags = __os.flags();
635  const _CharT __fill = __os.fill();
636  const _CharT __space = __os.widen(' ');
638  __os.fill(__space);
639 
640  for (size_t __i = 0; __i < __r; ++__i)
641  __os << __x._M_x[__i] << __space;
642  __os << __x._M_carry << __space << __x._M_p;
643 
644  __os.flags(__flags);
645  __os.fill(__fill);
646  return __os;
647  }
648 
649  template<typename _UIntType, size_t __w, size_t __s, size_t __r,
650  typename _CharT, typename _Traits>
653  subtract_with_carry_engine<_UIntType, __w, __s, __r>& __x)
654  {
655  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
656 
657  const typename __ios_base::fmtflags __flags = __is.flags();
659 
660  for (size_t __i = 0; __i < __r; ++__i)
661  __is >> __x._M_x[__i];
662  __is >> __x._M_carry;
663  __is >> __x._M_p;
664 
665  __is.flags(__flags);
666  return __is;
667  }
668 
669 
670  template<typename _RandomNumberEngine, size_t __p, size_t __r>
671  constexpr size_t
672  discard_block_engine<_RandomNumberEngine, __p, __r>::block_size;
673 
674  template<typename _RandomNumberEngine, size_t __p, size_t __r>
675  constexpr size_t
676  discard_block_engine<_RandomNumberEngine, __p, __r>::used_block;
677 
678  template<typename _RandomNumberEngine, size_t __p, size_t __r>
679  typename discard_block_engine<_RandomNumberEngine,
680  __p, __r>::result_type
682  operator()()
683  {
684  if (_M_n >= used_block)
685  {
686  _M_b.discard(block_size - _M_n);
687  _M_n = 0;
688  }
689  ++_M_n;
690  return _M_b();
691  }
692 
693  template<typename _RandomNumberEngine, size_t __p, size_t __r,
694  typename _CharT, typename _Traits>
697  const discard_block_engine<_RandomNumberEngine,
698  __p, __r>& __x)
699  {
700  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
701 
702  const typename __ios_base::fmtflags __flags = __os.flags();
703  const _CharT __fill = __os.fill();
704  const _CharT __space = __os.widen(' ');
706  __os.fill(__space);
707 
708  __os << __x.base() << __space << __x._M_n;
709 
710  __os.flags(__flags);
711  __os.fill(__fill);
712  return __os;
713  }
714 
715  template<typename _RandomNumberEngine, size_t __p, size_t __r,
716  typename _CharT, typename _Traits>
719  discard_block_engine<_RandomNumberEngine, __p, __r>& __x)
720  {
721  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
722 
723  const typename __ios_base::fmtflags __flags = __is.flags();
725 
726  __is >> __x._M_b >> __x._M_n;
727 
728  __is.flags(__flags);
729  return __is;
730  }
731 
732 
733  template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
734  typename independent_bits_engine<_RandomNumberEngine, __w, _UIntType>::
735  result_type
737  operator()()
738  {
739  typedef typename _RandomNumberEngine::result_type _Eresult_type;
740  const _Eresult_type __r
741  = (_M_b.max() - _M_b.min() < std::numeric_limits<_Eresult_type>::max()
742  ? _M_b.max() - _M_b.min() + 1 : 0);
743  const unsigned __edig = std::numeric_limits<_Eresult_type>::digits;
744  const unsigned __m = __r ? std::__lg(__r) : __edig;
745 
747  __ctype;
748  const unsigned __cdig = std::numeric_limits<__ctype>::digits;
749 
750  unsigned __n, __n0;
751  __ctype __s0, __s1, __y0, __y1;
752 
753  for (size_t __i = 0; __i < 2; ++__i)
754  {
755  __n = (__w + __m - 1) / __m + __i;
756  __n0 = __n - __w % __n;
757  const unsigned __w0 = __w / __n; // __w0 <= __m
758 
759  __s0 = 0;
760  __s1 = 0;
761  if (__w0 < __cdig)
762  {
763  __s0 = __ctype(1) << __w0;
764  __s1 = __s0 << 1;
765  }
766 
767  __y0 = 0;
768  __y1 = 0;
769  if (__r)
770  {
771  __y0 = __s0 * (__r / __s0);
772  if (__s1)
773  __y1 = __s1 * (__r / __s1);
774 
775  if (__r - __y0 <= __y0 / __n)
776  break;
777  }
778  else
779  break;
780  }
781 
782  result_type __sum = 0;
783  for (size_t __k = 0; __k < __n0; ++__k)
784  {
785  __ctype __u;
786  do
787  __u = _M_b() - _M_b.min();
788  while (__y0 && __u >= __y0);
789  __sum = __s0 * __sum + (__s0 ? __u % __s0 : __u);
790  }
791  for (size_t __k = __n0; __k < __n; ++__k)
792  {
793  __ctype __u;
794  do
795  __u = _M_b() - _M_b.min();
796  while (__y1 && __u >= __y1);
797  __sum = __s1 * __sum + (__s1 ? __u % __s1 : __u);
798  }
799  return __sum;
800  }
801 
802 
803  template<typename _RandomNumberEngine, size_t __k>
804  constexpr size_t
806 
807  namespace __detail
808  {
809  // Determine whether an integer is representable as double.
810  template<typename _Tp>
811  constexpr bool
812  __representable_as_double(_Tp __x) noexcept
813  {
814  static_assert(numeric_limits<_Tp>::is_integer, "");
815  static_assert(!numeric_limits<_Tp>::is_signed, "");
816  // All integers <= 2^53 are representable.
817  return (__x <= (1ull << __DBL_MANT_DIG__))
818  // Between 2^53 and 2^54 only even numbers are representable.
819  || (!(__x & 1) && __detail::__representable_as_double(__x >> 1));
820  }
821 
822  // Determine whether x+1 is representable as double.
823  template<typename _Tp>
824  constexpr bool
825  __p1_representable_as_double(_Tp __x) noexcept
826  {
827  static_assert(numeric_limits<_Tp>::is_integer, "");
828  static_assert(!numeric_limits<_Tp>::is_signed, "");
829  return numeric_limits<_Tp>::digits < __DBL_MANT_DIG__
830  || (bool(__x + 1u) // return false if x+1 wraps around to zero
831  && __detail::__representable_as_double(__x + 1u));
832  }
833  }
834 
835  template<typename _RandomNumberEngine, size_t __k>
838  operator()()
839  {
840  constexpr result_type __range = max() - min();
841  size_t __j = __k;
842  const result_type __y = _M_y - min();
843  // Avoid using slower long double arithmetic if possible.
844  if _GLIBCXX17_CONSTEXPR (__detail::__p1_representable_as_double(__range))
845  __j *= __y / (__range + 1.0);
846  else
847  __j *= __y / (__range + 1.0L);
848  _M_y = _M_v[__j];
849  _M_v[__j] = _M_b();
850 
851  return _M_y;
852  }
853 
854  template<typename _RandomNumberEngine, size_t __k,
855  typename _CharT, typename _Traits>
859  {
860  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
861 
862  const typename __ios_base::fmtflags __flags = __os.flags();
863  const _CharT __fill = __os.fill();
864  const _CharT __space = __os.widen(' ');
866  __os.fill(__space);
867 
868  __os << __x.base();
869  for (size_t __i = 0; __i < __k; ++__i)
870  __os << __space << __x._M_v[__i];
871  __os << __space << __x._M_y;
872 
873  __os.flags(__flags);
874  __os.fill(__fill);
875  return __os;
876  }
877 
878  template<typename _RandomNumberEngine, size_t __k,
879  typename _CharT, typename _Traits>
883  {
884  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
885 
886  const typename __ios_base::fmtflags __flags = __is.flags();
888 
889  __is >> __x._M_b;
890  for (size_t __i = 0; __i < __k; ++__i)
891  __is >> __x._M_v[__i];
892  __is >> __x._M_y;
893 
894  __is.flags(__flags);
895  return __is;
896  }
897 
898 
899  template<typename _IntType, typename _CharT, typename _Traits>
902  const uniform_int_distribution<_IntType>& __x)
903  {
904  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
905 
906  const typename __ios_base::fmtflags __flags = __os.flags();
907  const _CharT __fill = __os.fill();
908  const _CharT __space = __os.widen(' ');
910  __os.fill(__space);
911 
912  __os << __x.a() << __space << __x.b();
913 
914  __os.flags(__flags);
915  __os.fill(__fill);
916  return __os;
917  }
918 
919  template<typename _IntType, typename _CharT, typename _Traits>
923  {
924  using param_type
926  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
927 
928  const typename __ios_base::fmtflags __flags = __is.flags();
930 
931  _IntType __a, __b;
932  if (__is >> __a >> __b)
933  __x.param(param_type(__a, __b));
934 
935  __is.flags(__flags);
936  return __is;
937  }
938 
939 
940  template<typename _RealType>
941  template<typename _ForwardIterator,
942  typename _UniformRandomNumberGenerator>
943  void
945  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
946  _UniformRandomNumberGenerator& __urng,
947  const param_type& __p)
948  {
949  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
950  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
951  __aurng(__urng);
952  auto __range = __p.b() - __p.a();
953  while (__f != __t)
954  *__f++ = __aurng() * __range + __p.a();
955  }
956 
957  template<typename _RealType, typename _CharT, typename _Traits>
960  const uniform_real_distribution<_RealType>& __x)
961  {
962  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
963 
964  const typename __ios_base::fmtflags __flags = __os.flags();
965  const _CharT __fill = __os.fill();
966  const std::streamsize __precision = __os.precision();
967  const _CharT __space = __os.widen(' ');
969  __os.fill(__space);
971 
972  __os << __x.a() << __space << __x.b();
973 
974  __os.flags(__flags);
975  __os.fill(__fill);
976  __os.precision(__precision);
977  return __os;
978  }
979 
980  template<typename _RealType, typename _CharT, typename _Traits>
984  {
985  using param_type
987  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
988 
989  const typename __ios_base::fmtflags __flags = __is.flags();
991 
992  _RealType __a, __b;
993  if (__is >> __a >> __b)
994  __x.param(param_type(__a, __b));
995 
996  __is.flags(__flags);
997  return __is;
998  }
999 
1000 
1001  template<typename _ForwardIterator,
1002  typename _UniformRandomNumberGenerator>
1003  void
1004  std::bernoulli_distribution::
1005  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1006  _UniformRandomNumberGenerator& __urng,
1007  const param_type& __p)
1008  {
1009  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1010  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
1011  __aurng(__urng);
1012  auto __limit = __p.p() * (__aurng.max() - __aurng.min());
1013 
1014  while (__f != __t)
1015  *__f++ = (__aurng() - __aurng.min()) < __limit;
1016  }
1017 
1018  template<typename _CharT, typename _Traits>
1021  const bernoulli_distribution& __x)
1022  {
1023  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1024 
1025  const typename __ios_base::fmtflags __flags = __os.flags();
1026  const _CharT __fill = __os.fill();
1027  const std::streamsize __precision = __os.precision();
1029  __os.fill(__os.widen(' '));
1031 
1032  __os << __x.p();
1033 
1034  __os.flags(__flags);
1035  __os.fill(__fill);
1036  __os.precision(__precision);
1037  return __os;
1038  }
1039 
1040 
1041  template<typename _IntType>
1042  template<typename _UniformRandomNumberGenerator>
1045  operator()(_UniformRandomNumberGenerator& __urng,
1046  const param_type& __param)
1047  {
1048  // About the epsilon thing see this thread:
1049  // http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html
1050  const double __naf =
1052  // The largest _RealType convertible to _IntType.
1053  const double __thr =
1055  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
1056  __aurng(__urng);
1057 
1058  double __cand;
1059  do
1060  __cand = std::floor(std::log(1.0 - __aurng()) / __param._M_log_1_p);
1061  while (__cand >= __thr);
1062 
1063  return result_type(__cand + __naf);
1064  }
1065 
1066  template<typename _IntType>
1067  template<typename _ForwardIterator,
1068  typename _UniformRandomNumberGenerator>
1069  void
1071  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1072  _UniformRandomNumberGenerator& __urng,
1073  const param_type& __param)
1074  {
1075  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1076  // About the epsilon thing see this thread:
1077  // http://gcc.gnu.org/ml/gcc-patches/2006-10/msg00971.html
1078  const double __naf =
1080  // The largest _RealType convertible to _IntType.
1081  const double __thr =
1083  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
1084  __aurng(__urng);
1085 
1086  while (__f != __t)
1087  {
1088  double __cand;
1089  do
1090  __cand = std::floor(std::log(1.0 - __aurng())
1091  / __param._M_log_1_p);
1092  while (__cand >= __thr);
1093 
1094  *__f++ = __cand + __naf;
1095  }
1096  }
1097 
1098  template<typename _IntType,
1099  typename _CharT, typename _Traits>
1102  const geometric_distribution<_IntType>& __x)
1103  {
1104  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1105 
1106  const typename __ios_base::fmtflags __flags = __os.flags();
1107  const _CharT __fill = __os.fill();
1108  const std::streamsize __precision = __os.precision();
1110  __os.fill(__os.widen(' '));
1112 
1113  __os << __x.p();
1114 
1115  __os.flags(__flags);
1116  __os.fill(__fill);
1117  __os.precision(__precision);
1118  return __os;
1119  }
1120 
1121  template<typename _IntType,
1122  typename _CharT, typename _Traits>
1126  {
1127  using param_type = typename geometric_distribution<_IntType>::param_type;
1128  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
1129 
1130  const typename __ios_base::fmtflags __flags = __is.flags();
1131  __is.flags(__ios_base::skipws);
1132 
1133  double __p;
1134  if (__is >> __p)
1135  __x.param(param_type(__p));
1136 
1137  __is.flags(__flags);
1138  return __is;
1139  }
1140 
1141  // This is Leger's algorithm, also in Devroye, Ch. X, Example 1.5.
1142  template<typename _IntType>
1143  template<typename _UniformRandomNumberGenerator>
1146  operator()(_UniformRandomNumberGenerator& __urng)
1147  {
1148  const double __y = _M_gd(__urng);
1149 
1150  // XXX Is the constructor too slow?
1152  return __poisson(__urng);
1153  }
1154 
1155  template<typename _IntType>
1156  template<typename _UniformRandomNumberGenerator>
1159  operator()(_UniformRandomNumberGenerator& __urng,
1160  const param_type& __p)
1161  {
1163  param_type;
1164 
1165  const double __y =
1166  _M_gd(__urng, param_type(__p.k(), (1.0 - __p.p()) / __p.p()));
1167 
1169  return __poisson(__urng);
1170  }
1171 
1172  template<typename _IntType>
1173  template<typename _ForwardIterator,
1174  typename _UniformRandomNumberGenerator>
1175  void
1176  negative_binomial_distribution<_IntType>::
1177  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1178  _UniformRandomNumberGenerator& __urng)
1179  {
1180  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1181  while (__f != __t)
1182  {
1183  const double __y = _M_gd(__urng);
1184 
1185  // XXX Is the constructor too slow?
1187  *__f++ = __poisson(__urng);
1188  }
1189  }
1190 
1191  template<typename _IntType>
1192  template<typename _ForwardIterator,
1193  typename _UniformRandomNumberGenerator>
1194  void
1195  negative_binomial_distribution<_IntType>::
1196  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1197  _UniformRandomNumberGenerator& __urng,
1198  const param_type& __p)
1199  {
1200  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1202  __p2(__p.k(), (1.0 - __p.p()) / __p.p());
1203 
1204  while (__f != __t)
1205  {
1206  const double __y = _M_gd(__urng, __p2);
1207 
1209  *__f++ = __poisson(__urng);
1210  }
1211  }
1212 
1213  template<typename _IntType, typename _CharT, typename _Traits>
1216  const negative_binomial_distribution<_IntType>& __x)
1217  {
1218  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1219 
1220  const typename __ios_base::fmtflags __flags = __os.flags();
1221  const _CharT __fill = __os.fill();
1222  const std::streamsize __precision = __os.precision();
1223  const _CharT __space = __os.widen(' ');
1225  __os.fill(__os.widen(' '));
1227 
1228  __os << __x.k() << __space << __x.p()
1229  << __space << __x._M_gd;
1230 
1231  __os.flags(__flags);
1232  __os.fill(__fill);
1233  __os.precision(__precision);
1234  return __os;
1235  }
1236 
1237  template<typename _IntType, typename _CharT, typename _Traits>
1240  negative_binomial_distribution<_IntType>& __x)
1241  {
1242  using param_type
1243  = typename negative_binomial_distribution<_IntType>::param_type;
1244  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
1245 
1246  const typename __ios_base::fmtflags __flags = __is.flags();
1247  __is.flags(__ios_base::skipws);
1248 
1249  _IntType __k;
1250  double __p;
1251  if (__is >> __k >> __p >> __x._M_gd)
1252  __x.param(param_type(__k, __p));
1253 
1254  __is.flags(__flags);
1255  return __is;
1256  }
1257 
1258 
1259  template<typename _IntType>
1260  void
1261  poisson_distribution<_IntType>::param_type::
1262  _M_initialize()
1263  {
1264 #if _GLIBCXX_USE_C99_MATH_TR1
1265  if (_M_mean >= 12)
1266  {
1267  const double __m = std::floor(_M_mean);
1268  _M_lm_thr = std::log(_M_mean);
1269  _M_lfm = std::lgamma(__m + 1);
1270  _M_sm = std::sqrt(__m);
1271 
1272  const double __pi_4 = 0.7853981633974483096156608458198757L;
1273  const double __dx = std::sqrt(2 * __m * std::log(32 * __m
1274  / __pi_4));
1275  _M_d = std::round(std::max<double>(6.0, std::min(__m, __dx)));
1276  const double __cx = 2 * __m + _M_d;
1277  _M_scx = std::sqrt(__cx / 2);
1278  _M_1cx = 1 / __cx;
1279 
1280  _M_c2b = std::sqrt(__pi_4 * __cx) * std::exp(_M_1cx);
1281  _M_cb = 2 * __cx * std::exp(-_M_d * _M_1cx * (1 + _M_d / 2))
1282  / _M_d;
1283  }
1284  else
1285 #endif
1286  _M_lm_thr = std::exp(-_M_mean);
1287  }
1288 
1289  /**
1290  * A rejection algorithm when mean >= 12 and a simple method based
1291  * upon the multiplication of uniform random variates otherwise.
1292  * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
1293  * is defined.
1294  *
1295  * Reference:
1296  * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
1297  * New York, 1986, Ch. X, Sects. 3.3 & 3.4 (+ Errata!).
1298  */
1299  template<typename _IntType>
1300  template<typename _UniformRandomNumberGenerator>
1303  operator()(_UniformRandomNumberGenerator& __urng,
1304  const param_type& __param)
1305  {
1306  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
1307  __aurng(__urng);
1308 #if _GLIBCXX_USE_C99_MATH_TR1
1309  if (__param.mean() >= 12)
1310  {
1311  double __x;
1312 
1313  // See comments above...
1314  const double __naf =
1316  const double __thr =
1318 
1319  const double __m = std::floor(__param.mean());
1320  // sqrt(pi / 2)
1321  const double __spi_2 = 1.2533141373155002512078826424055226L;
1322  const double __c1 = __param._M_sm * __spi_2;
1323  const double __c2 = __param._M_c2b + __c1;
1324  const double __c3 = __c2 + 1;
1325  const double __c4 = __c3 + 1;
1326  // 1 / 78
1327  const double __178 = 0.0128205128205128205128205128205128L;
1328  // e^(1 / 78)
1329  const double __e178 = 1.0129030479320018583185514777512983L;
1330  const double __c5 = __c4 + __e178;
1331  const double __c = __param._M_cb + __c5;
1332  const double __2cx = 2 * (2 * __m + __param._M_d);
1333 
1334  bool __reject = true;
1335  do
1336  {
1337  const double __u = __c * __aurng();
1338  const double __e = -std::log(1.0 - __aurng());
1339 
1340  double __w = 0.0;
1341 
1342  if (__u <= __c1)
1343  {
1344  const double __n = _M_nd(__urng);
1345  const double __y = -std::abs(__n) * __param._M_sm - 1;
1346  __x = std::floor(__y);
1347  __w = -__n * __n / 2;
1348  if (__x < -__m)
1349  continue;
1350  }
1351  else if (__u <= __c2)
1352  {
1353  const double __n = _M_nd(__urng);
1354  const double __y = 1 + std::abs(__n) * __param._M_scx;
1355  __x = std::ceil(__y);
1356  __w = __y * (2 - __y) * __param._M_1cx;
1357  if (__x > __param._M_d)
1358  continue;
1359  }
1360  else if (__u <= __c3)
1361  // NB: This case not in the book, nor in the Errata,
1362  // but should be ok...
1363  __x = -1;
1364  else if (__u <= __c4)
1365  __x = 0;
1366  else if (__u <= __c5)
1367  {
1368  __x = 1;
1369  // Only in the Errata, see libstdc++/83237.
1370  __w = __178;
1371  }
1372  else
1373  {
1374  const double __v = -std::log(1.0 - __aurng());
1375  const double __y = __param._M_d
1376  + __v * __2cx / __param._M_d;
1377  __x = std::ceil(__y);
1378  __w = -__param._M_d * __param._M_1cx * (1 + __y / 2);
1379  }
1380 
1381  __reject = (__w - __e - __x * __param._M_lm_thr
1382  > __param._M_lfm - std::lgamma(__x + __m + 1));
1383 
1384  __reject |= __x + __m >= __thr;
1385 
1386  } while (__reject);
1387 
1388  return result_type(__x + __m + __naf);
1389  }
1390  else
1391 #endif
1392  {
1393  _IntType __x = 0;
1394  double __prod = 1.0;
1395 
1396  do
1397  {
1398  __prod *= __aurng();
1399  __x += 1;
1400  }
1401  while (__prod > __param._M_lm_thr);
1402 
1403  return __x - 1;
1404  }
1405  }
1406 
1407  template<typename _IntType>
1408  template<typename _ForwardIterator,
1409  typename _UniformRandomNumberGenerator>
1410  void
1412  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1413  _UniformRandomNumberGenerator& __urng,
1414  const param_type& __param)
1415  {
1416  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1417  // We could duplicate everything from operator()...
1418  while (__f != __t)
1419  *__f++ = this->operator()(__urng, __param);
1420  }
1421 
1422  template<typename _IntType,
1423  typename _CharT, typename _Traits>
1426  const poisson_distribution<_IntType>& __x)
1427  {
1428  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1429 
1430  const typename __ios_base::fmtflags __flags = __os.flags();
1431  const _CharT __fill = __os.fill();
1432  const std::streamsize __precision = __os.precision();
1433  const _CharT __space = __os.widen(' ');
1435  __os.fill(__space);
1437 
1438  __os << __x.mean() << __space << __x._M_nd;
1439 
1440  __os.flags(__flags);
1441  __os.fill(__fill);
1442  __os.precision(__precision);
1443  return __os;
1444  }
1445 
1446  template<typename _IntType,
1447  typename _CharT, typename _Traits>
1450  poisson_distribution<_IntType>& __x)
1451  {
1452  using param_type = typename poisson_distribution<_IntType>::param_type;
1453  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
1454 
1455  const typename __ios_base::fmtflags __flags = __is.flags();
1456  __is.flags(__ios_base::skipws);
1457 
1458  double __mean;
1459  if (__is >> __mean >> __x._M_nd)
1460  __x.param(param_type(__mean));
1461 
1462  __is.flags(__flags);
1463  return __is;
1464  }
1465 
1466 
1467  template<typename _IntType>
1468  void
1469  binomial_distribution<_IntType>::param_type::
1470  _M_initialize()
1471  {
1472  const double __p12 = _M_p <= 0.5 ? _M_p : 1.0 - _M_p;
1473 
1474  _M_easy = true;
1475 
1476 #if _GLIBCXX_USE_C99_MATH_TR1
1477  if (_M_t * __p12 >= 8)
1478  {
1479  _M_easy = false;
1480  const double __np = std::floor(_M_t * __p12);
1481  const double __pa = __np / _M_t;
1482  const double __1p = 1 - __pa;
1483 
1484  const double __pi_4 = 0.7853981633974483096156608458198757L;
1485  const double __d1x =
1486  std::sqrt(__np * __1p * std::log(32 * __np
1487  / (81 * __pi_4 * __1p)));
1488  _M_d1 = std::round(std::max<double>(1.0, __d1x));
1489  const double __d2x =
1490  std::sqrt(__np * __1p * std::log(32 * _M_t * __1p
1491  / (__pi_4 * __pa)));
1492  _M_d2 = std::round(std::max<double>(1.0, __d2x));
1493 
1494  // sqrt(pi / 2)
1495  const double __spi_2 = 1.2533141373155002512078826424055226L;
1496  _M_s1 = std::sqrt(__np * __1p) * (1 + _M_d1 / (4 * __np));
1497  _M_s2 = std::sqrt(__np * __1p) * (1 + _M_d2 / (4 * _M_t * __1p));
1498  _M_c = 2 * _M_d1 / __np;
1499  _M_a1 = std::exp(_M_c) * _M_s1 * __spi_2;
1500  const double __a12 = _M_a1 + _M_s2 * __spi_2;
1501  const double __s1s = _M_s1 * _M_s1;
1502  _M_a123 = __a12 + (std::exp(_M_d1 / (_M_t * __1p))
1503  * 2 * __s1s / _M_d1
1504  * std::exp(-_M_d1 * _M_d1 / (2 * __s1s)));
1505  const double __s2s = _M_s2 * _M_s2;
1506  _M_s = (_M_a123 + 2 * __s2s / _M_d2
1507  * std::exp(-_M_d2 * _M_d2 / (2 * __s2s)));
1508  _M_lf = (std::lgamma(__np + 1)
1509  + std::lgamma(_M_t - __np + 1));
1510  _M_lp1p = std::log(__pa / __1p);
1511 
1512  _M_q = -std::log(1 - (__p12 - __pa) / __1p);
1513  }
1514  else
1515 #endif
1516  _M_q = -std::log(1 - __p12);
1517  }
1518 
1519  template<typename _IntType>
1520  template<typename _UniformRandomNumberGenerator>
1522  binomial_distribution<_IntType>::
1523  _M_waiting(_UniformRandomNumberGenerator& __urng,
1524  _IntType __t, double __q)
1525  {
1526  _IntType __x = 0;
1527  double __sum = 0.0;
1528  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
1529  __aurng(__urng);
1530 
1531  do
1532  {
1533  if (__t == __x)
1534  return __x;
1535  const double __e = -std::log(1.0 - __aurng());
1536  __sum += __e / (__t - __x);
1537  __x += 1;
1538  }
1539  while (__sum <= __q);
1540 
1541  return __x - 1;
1542  }
1543 
1544  /**
1545  * A rejection algorithm when t * p >= 8 and a simple waiting time
1546  * method - the second in the referenced book - otherwise.
1547  * NB: The former is available only if _GLIBCXX_USE_C99_MATH_TR1
1548  * is defined.
1549  *
1550  * Reference:
1551  * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
1552  * New York, 1986, Ch. X, Sect. 4 (+ Errata!).
1553  */
1554  template<typename _IntType>
1555  template<typename _UniformRandomNumberGenerator>
1558  operator()(_UniformRandomNumberGenerator& __urng,
1559  const param_type& __param)
1560  {
1561  result_type __ret;
1562  const _IntType __t = __param.t();
1563  const double __p = __param.p();
1564  const double __p12 = __p <= 0.5 ? __p : 1.0 - __p;
1565  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
1566  __aurng(__urng);
1567 
1568 #if _GLIBCXX_USE_C99_MATH_TR1
1569  if (!__param._M_easy)
1570  {
1571  double __x;
1572 
1573  // See comments above...
1574  const double __naf =
1576  const double __thr =
1578 
1579  const double __np = std::floor(__t * __p12);
1580 
1581  // sqrt(pi / 2)
1582  const double __spi_2 = 1.2533141373155002512078826424055226L;
1583  const double __a1 = __param._M_a1;
1584  const double __a12 = __a1 + __param._M_s2 * __spi_2;
1585  const double __a123 = __param._M_a123;
1586  const double __s1s = __param._M_s1 * __param._M_s1;
1587  const double __s2s = __param._M_s2 * __param._M_s2;
1588 
1589  bool __reject;
1590  do
1591  {
1592  const double __u = __param._M_s * __aurng();
1593 
1594  double __v;
1595 
1596  if (__u <= __a1)
1597  {
1598  const double __n = _M_nd(__urng);
1599  const double __y = __param._M_s1 * std::abs(__n);
1600  __reject = __y >= __param._M_d1;
1601  if (!__reject)
1602  {
1603  const double __e = -std::log(1.0 - __aurng());
1604  __x = std::floor(__y);
1605  __v = -__e - __n * __n / 2 + __param._M_c;
1606  }
1607  }
1608  else if (__u <= __a12)
1609  {
1610  const double __n = _M_nd(__urng);
1611  const double __y = __param._M_s2 * std::abs(__n);
1612  __reject = __y >= __param._M_d2;
1613  if (!__reject)
1614  {
1615  const double __e = -std::log(1.0 - __aurng());
1616  __x = std::floor(-__y);
1617  __v = -__e - __n * __n / 2;
1618  }
1619  }
1620  else if (__u <= __a123)
1621  {
1622  const double __e1 = -std::log(1.0 - __aurng());
1623  const double __e2 = -std::log(1.0 - __aurng());
1624 
1625  const double __y = __param._M_d1
1626  + 2 * __s1s * __e1 / __param._M_d1;
1627  __x = std::floor(__y);
1628  __v = (-__e2 + __param._M_d1 * (1 / (__t - __np)
1629  -__y / (2 * __s1s)));
1630  __reject = false;
1631  }
1632  else
1633  {
1634  const double __e1 = -std::log(1.0 - __aurng());
1635  const double __e2 = -std::log(1.0 - __aurng());
1636 
1637  const double __y = __param._M_d2
1638  + 2 * __s2s * __e1 / __param._M_d2;
1639  __x = std::floor(-__y);
1640  __v = -__e2 - __param._M_d2 * __y / (2 * __s2s);
1641  __reject = false;
1642  }
1643 
1644  __reject = __reject || __x < -__np || __x > __t - __np;
1645  if (!__reject)
1646  {
1647  const double __lfx =
1648  std::lgamma(__np + __x + 1)
1649  + std::lgamma(__t - (__np + __x) + 1);
1650  __reject = __v > __param._M_lf - __lfx
1651  + __x * __param._M_lp1p;
1652  }
1653 
1654  __reject |= __x + __np >= __thr;
1655  }
1656  while (__reject);
1657 
1658  __x += __np + __naf;
1659 
1660  const _IntType __z = _M_waiting(__urng, __t - _IntType(__x),
1661  __param._M_q);
1662  __ret = _IntType(__x) + __z;
1663  }
1664  else
1665 #endif
1666  __ret = _M_waiting(__urng, __t, __param._M_q);
1667 
1668  if (__p12 != __p)
1669  __ret = __t - __ret;
1670  return __ret;
1671  }
1672 
1673  template<typename _IntType>
1674  template<typename _ForwardIterator,
1675  typename _UniformRandomNumberGenerator>
1676  void
1678  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1679  _UniformRandomNumberGenerator& __urng,
1680  const param_type& __param)
1681  {
1682  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1683  // We could duplicate everything from operator()...
1684  while (__f != __t)
1685  *__f++ = this->operator()(__urng, __param);
1686  }
1687 
1688  template<typename _IntType,
1689  typename _CharT, typename _Traits>
1692  const binomial_distribution<_IntType>& __x)
1693  {
1694  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1695 
1696  const typename __ios_base::fmtflags __flags = __os.flags();
1697  const _CharT __fill = __os.fill();
1698  const std::streamsize __precision = __os.precision();
1699  const _CharT __space = __os.widen(' ');
1701  __os.fill(__space);
1703 
1704  __os << __x.t() << __space << __x.p()
1705  << __space << __x._M_nd;
1706 
1707  __os.flags(__flags);
1708  __os.fill(__fill);
1709  __os.precision(__precision);
1710  return __os;
1711  }
1712 
1713  template<typename _IntType,
1714  typename _CharT, typename _Traits>
1717  binomial_distribution<_IntType>& __x)
1718  {
1719  using param_type = typename binomial_distribution<_IntType>::param_type;
1720  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
1721 
1722  const typename __ios_base::fmtflags __flags = __is.flags();
1724 
1725  _IntType __t;
1726  double __p;
1727  if (__is >> __t >> __p >> __x._M_nd)
1728  __x.param(param_type(__t, __p));
1729 
1730  __is.flags(__flags);
1731  return __is;
1732  }
1733 
1734 
1735  template<typename _RealType>
1736  template<typename _ForwardIterator,
1737  typename _UniformRandomNumberGenerator>
1738  void
1740  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1741  _UniformRandomNumberGenerator& __urng,
1742  const param_type& __p)
1743  {
1744  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1745  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1746  __aurng(__urng);
1747  while (__f != __t)
1748  *__f++ = -std::log(result_type(1) - __aurng()) / __p.lambda();
1749  }
1750 
1751  template<typename _RealType, typename _CharT, typename _Traits>
1754  const exponential_distribution<_RealType>& __x)
1755  {
1756  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1757 
1758  const typename __ios_base::fmtflags __flags = __os.flags();
1759  const _CharT __fill = __os.fill();
1760  const std::streamsize __precision = __os.precision();
1762  __os.fill(__os.widen(' '));
1764 
1765  __os << __x.lambda();
1766 
1767  __os.flags(__flags);
1768  __os.fill(__fill);
1769  __os.precision(__precision);
1770  return __os;
1771  }
1772 
1773  template<typename _RealType, typename _CharT, typename _Traits>
1777  {
1778  using param_type
1780  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
1781 
1782  const typename __ios_base::fmtflags __flags = __is.flags();
1784 
1785  _RealType __lambda;
1786  if (__is >> __lambda)
1787  __x.param(param_type(__lambda));
1788 
1789  __is.flags(__flags);
1790  return __is;
1791  }
1792 
1793 
1794  /**
1795  * Polar method due to Marsaglia.
1796  *
1797  * Devroye, L. Non-Uniform Random Variates Generation. Springer-Verlag,
1798  * New York, 1986, Ch. V, Sect. 4.4.
1799  */
1800  template<typename _RealType>
1801  template<typename _UniformRandomNumberGenerator>
1804  operator()(_UniformRandomNumberGenerator& __urng,
1805  const param_type& __param)
1806  {
1807  result_type __ret;
1808  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1809  __aurng(__urng);
1810 
1811  if (_M_saved_available)
1812  {
1813  _M_saved_available = false;
1814  __ret = _M_saved;
1815  }
1816  else
1817  {
1818  result_type __x, __y, __r2;
1819  do
1820  {
1821  __x = result_type(2.0) * __aurng() - 1.0;
1822  __y = result_type(2.0) * __aurng() - 1.0;
1823  __r2 = __x * __x + __y * __y;
1824  }
1825  while (__r2 > 1.0 || __r2 == 0.0);
1826 
1827  const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
1828  _M_saved = __x * __mult;
1829  _M_saved_available = true;
1830  __ret = __y * __mult;
1831  }
1832 
1833  __ret = __ret * __param.stddev() + __param.mean();
1834  return __ret;
1835  }
1836 
1837  template<typename _RealType>
1838  template<typename _ForwardIterator,
1839  typename _UniformRandomNumberGenerator>
1840  void
1842  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1843  _UniformRandomNumberGenerator& __urng,
1844  const param_type& __param)
1845  {
1846  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1847 
1848  if (__f == __t)
1849  return;
1850 
1851  if (_M_saved_available)
1852  {
1853  _M_saved_available = false;
1854  *__f++ = _M_saved * __param.stddev() + __param.mean();
1855 
1856  if (__f == __t)
1857  return;
1858  }
1859 
1860  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1861  __aurng(__urng);
1862 
1863  while (__f + 1 < __t)
1864  {
1865  result_type __x, __y, __r2;
1866  do
1867  {
1868  __x = result_type(2.0) * __aurng() - 1.0;
1869  __y = result_type(2.0) * __aurng() - 1.0;
1870  __r2 = __x * __x + __y * __y;
1871  }
1872  while (__r2 > 1.0 || __r2 == 0.0);
1873 
1874  const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
1875  *__f++ = __y * __mult * __param.stddev() + __param.mean();
1876  *__f++ = __x * __mult * __param.stddev() + __param.mean();
1877  }
1878 
1879  if (__f != __t)
1880  {
1881  result_type __x, __y, __r2;
1882  do
1883  {
1884  __x = result_type(2.0) * __aurng() - 1.0;
1885  __y = result_type(2.0) * __aurng() - 1.0;
1886  __r2 = __x * __x + __y * __y;
1887  }
1888  while (__r2 > 1.0 || __r2 == 0.0);
1889 
1890  const result_type __mult = std::sqrt(-2 * std::log(__r2) / __r2);
1891  _M_saved = __x * __mult;
1892  _M_saved_available = true;
1893  *__f = __y * __mult * __param.stddev() + __param.mean();
1894  }
1895  }
1896 
1897  template<typename _RealType>
1898  bool
1901  {
1902  if (__d1._M_param == __d2._M_param
1903  && __d1._M_saved_available == __d2._M_saved_available)
1904  {
1905  if (__d1._M_saved_available
1906  && __d1._M_saved == __d2._M_saved)
1907  return true;
1908  else if(!__d1._M_saved_available)
1909  return true;
1910  else
1911  return false;
1912  }
1913  else
1914  return false;
1915  }
1916 
1917  template<typename _RealType, typename _CharT, typename _Traits>
1920  const normal_distribution<_RealType>& __x)
1921  {
1922  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1923 
1924  const typename __ios_base::fmtflags __flags = __os.flags();
1925  const _CharT __fill = __os.fill();
1926  const std::streamsize __precision = __os.precision();
1927  const _CharT __space = __os.widen(' ');
1929  __os.fill(__space);
1931 
1932  __os << __x.mean() << __space << __x.stddev()
1933  << __space << __x._M_saved_available;
1934  if (__x._M_saved_available)
1935  __os << __space << __x._M_saved;
1936 
1937  __os.flags(__flags);
1938  __os.fill(__fill);
1939  __os.precision(__precision);
1940  return __os;
1941  }
1942 
1943  template<typename _RealType, typename _CharT, typename _Traits>
1946  normal_distribution<_RealType>& __x)
1947  {
1948  using param_type = typename normal_distribution<_RealType>::param_type;
1949  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
1950 
1951  const typename __ios_base::fmtflags __flags = __is.flags();
1953 
1954  double __mean, __stddev;
1955  bool __saved_avail;
1956  if (__is >> __mean >> __stddev >> __saved_avail)
1957  {
1958  if (__saved_avail && (__is >> __x._M_saved))
1959  {
1960  __x._M_saved_available = __saved_avail;
1961  __x.param(param_type(__mean, __stddev));
1962  }
1963  }
1964 
1965  __is.flags(__flags);
1966  return __is;
1967  }
1968 
1969 
1970  template<typename _RealType>
1971  template<typename _ForwardIterator,
1972  typename _UniformRandomNumberGenerator>
1973  void
1974  lognormal_distribution<_RealType>::
1975  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
1976  _UniformRandomNumberGenerator& __urng,
1977  const param_type& __p)
1978  {
1979  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
1980  while (__f != __t)
1981  *__f++ = std::exp(__p.s() * _M_nd(__urng) + __p.m());
1982  }
1983 
1984  template<typename _RealType, typename _CharT, typename _Traits>
1987  const lognormal_distribution<_RealType>& __x)
1988  {
1989  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
1990 
1991  const typename __ios_base::fmtflags __flags = __os.flags();
1992  const _CharT __fill = __os.fill();
1993  const std::streamsize __precision = __os.precision();
1994  const _CharT __space = __os.widen(' ');
1996  __os.fill(__space);
1998 
1999  __os << __x.m() << __space << __x.s()
2000  << __space << __x._M_nd;
2001 
2002  __os.flags(__flags);
2003  __os.fill(__fill);
2004  __os.precision(__precision);
2005  return __os;
2006  }
2007 
2008  template<typename _RealType, typename _CharT, typename _Traits>
2011  lognormal_distribution<_RealType>& __x)
2012  {
2013  using param_type
2014  = typename lognormal_distribution<_RealType>::param_type;
2015  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2016 
2017  const typename __ios_base::fmtflags __flags = __is.flags();
2019 
2020  _RealType __m, __s;
2021  if (__is >> __m >> __s >> __x._M_nd)
2022  __x.param(param_type(__m, __s));
2023 
2024  __is.flags(__flags);
2025  return __is;
2026  }
2027 
2028  template<typename _RealType>
2029  template<typename _ForwardIterator,
2030  typename _UniformRandomNumberGenerator>
2031  void
2033  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2034  _UniformRandomNumberGenerator& __urng)
2035  {
2036  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2037  while (__f != __t)
2038  *__f++ = 2 * _M_gd(__urng);
2039  }
2040 
2041  template<typename _RealType>
2042  template<typename _ForwardIterator,
2043  typename _UniformRandomNumberGenerator>
2044  void
2046  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2047  _UniformRandomNumberGenerator& __urng,
2048  const typename
2050  {
2051  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2052  while (__f != __t)
2053  *__f++ = 2 * _M_gd(__urng, __p);
2054  }
2055 
2056  template<typename _RealType, typename _CharT, typename _Traits>
2059  const chi_squared_distribution<_RealType>& __x)
2060  {
2061  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2062 
2063  const typename __ios_base::fmtflags __flags = __os.flags();
2064  const _CharT __fill = __os.fill();
2065  const std::streamsize __precision = __os.precision();
2066  const _CharT __space = __os.widen(' ');
2068  __os.fill(__space);
2070 
2071  __os << __x.n() << __space << __x._M_gd;
2072 
2073  __os.flags(__flags);
2074  __os.fill(__fill);
2075  __os.precision(__precision);
2076  return __os;
2077  }
2078 
2079  template<typename _RealType, typename _CharT, typename _Traits>
2082  chi_squared_distribution<_RealType>& __x)
2083  {
2084  using param_type
2085  = typename chi_squared_distribution<_RealType>::param_type;
2086  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2087 
2088  const typename __ios_base::fmtflags __flags = __is.flags();
2090 
2091  _RealType __n;
2092  if (__is >> __n >> __x._M_gd)
2093  __x.param(param_type(__n));
2094 
2095  __is.flags(__flags);
2096  return __is;
2097  }
2098 
2099 
2100  template<typename _RealType>
2101  template<typename _UniformRandomNumberGenerator>
2104  operator()(_UniformRandomNumberGenerator& __urng,
2105  const param_type& __p)
2106  {
2107  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2108  __aurng(__urng);
2109  _RealType __u;
2110  do
2111  __u = __aurng();
2112  while (__u == 0.5);
2113 
2114  const _RealType __pi = 3.1415926535897932384626433832795029L;
2115  return __p.a() + __p.b() * std::tan(__pi * __u);
2116  }
2117 
2118  template<typename _RealType>
2119  template<typename _ForwardIterator,
2120  typename _UniformRandomNumberGenerator>
2121  void
2123  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2124  _UniformRandomNumberGenerator& __urng,
2125  const param_type& __p)
2126  {
2127  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2128  const _RealType __pi = 3.1415926535897932384626433832795029L;
2129  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2130  __aurng(__urng);
2131  while (__f != __t)
2132  {
2133  _RealType __u;
2134  do
2135  __u = __aurng();
2136  while (__u == 0.5);
2137 
2138  *__f++ = __p.a() + __p.b() * std::tan(__pi * __u);
2139  }
2140  }
2141 
2142  template<typename _RealType, typename _CharT, typename _Traits>
2145  const cauchy_distribution<_RealType>& __x)
2146  {
2147  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2148 
2149  const typename __ios_base::fmtflags __flags = __os.flags();
2150  const _CharT __fill = __os.fill();
2151  const std::streamsize __precision = __os.precision();
2152  const _CharT __space = __os.widen(' ');
2154  __os.fill(__space);
2156 
2157  __os << __x.a() << __space << __x.b();
2158 
2159  __os.flags(__flags);
2160  __os.fill(__fill);
2161  __os.precision(__precision);
2162  return __os;
2163  }
2164 
2165  template<typename _RealType, typename _CharT, typename _Traits>
2169  {
2170  using param_type = typename cauchy_distribution<_RealType>::param_type;
2171  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2172 
2173  const typename __ios_base::fmtflags __flags = __is.flags();
2175 
2176  _RealType __a, __b;
2177  if (__is >> __a >> __b)
2178  __x.param(param_type(__a, __b));
2179 
2180  __is.flags(__flags);
2181  return __is;
2182  }
2183 
2184 
2185  template<typename _RealType>
2186  template<typename _ForwardIterator,
2187  typename _UniformRandomNumberGenerator>
2188  void
2190  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2191  _UniformRandomNumberGenerator& __urng)
2192  {
2193  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2194  while (__f != __t)
2195  *__f++ = ((_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()));
2196  }
2197 
2198  template<typename _RealType>
2199  template<typename _ForwardIterator,
2200  typename _UniformRandomNumberGenerator>
2201  void
2203  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2204  _UniformRandomNumberGenerator& __urng,
2205  const param_type& __p)
2206  {
2207  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2209  param_type;
2210  param_type __p1(__p.m() / 2);
2211  param_type __p2(__p.n() / 2);
2212  while (__f != __t)
2213  *__f++ = ((_M_gd_x(__urng, __p1) * n())
2214  / (_M_gd_y(__urng, __p2) * m()));
2215  }
2216 
2217  template<typename _RealType, typename _CharT, typename _Traits>
2220  const fisher_f_distribution<_RealType>& __x)
2221  {
2222  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2223 
2224  const typename __ios_base::fmtflags __flags = __os.flags();
2225  const _CharT __fill = __os.fill();
2226  const std::streamsize __precision = __os.precision();
2227  const _CharT __space = __os.widen(' ');
2229  __os.fill(__space);
2231 
2232  __os << __x.m() << __space << __x.n()
2233  << __space << __x._M_gd_x << __space << __x._M_gd_y;
2234 
2235  __os.flags(__flags);
2236  __os.fill(__fill);
2237  __os.precision(__precision);
2238  return __os;
2239  }
2240 
2241  template<typename _RealType, typename _CharT, typename _Traits>
2244  fisher_f_distribution<_RealType>& __x)
2245  {
2246  using param_type
2247  = typename fisher_f_distribution<_RealType>::param_type;
2248  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2249 
2250  const typename __ios_base::fmtflags __flags = __is.flags();
2252 
2253  _RealType __m, __n;
2254  if (__is >> __m >> __n >> __x._M_gd_x >> __x._M_gd_y)
2255  __x.param(param_type(__m, __n));
2256 
2257  __is.flags(__flags);
2258  return __is;
2259  }
2260 
2261 
2262  template<typename _RealType>
2263  template<typename _ForwardIterator,
2264  typename _UniformRandomNumberGenerator>
2265  void
2267  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2268  _UniformRandomNumberGenerator& __urng)
2269  {
2270  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2271  while (__f != __t)
2272  *__f++ = _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng));
2273  }
2274 
2275  template<typename _RealType>
2276  template<typename _ForwardIterator,
2277  typename _UniformRandomNumberGenerator>
2278  void
2280  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2281  _UniformRandomNumberGenerator& __urng,
2282  const param_type& __p)
2283  {
2284  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2286  __p2(__p.n() / 2, 2);
2287  while (__f != __t)
2288  *__f++ = _M_nd(__urng) * std::sqrt(__p.n() / _M_gd(__urng, __p2));
2289  }
2290 
2291  template<typename _RealType, typename _CharT, typename _Traits>
2294  const student_t_distribution<_RealType>& __x)
2295  {
2296  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2297 
2298  const typename __ios_base::fmtflags __flags = __os.flags();
2299  const _CharT __fill = __os.fill();
2300  const std::streamsize __precision = __os.precision();
2301  const _CharT __space = __os.widen(' ');
2303  __os.fill(__space);
2305 
2306  __os << __x.n() << __space << __x._M_nd << __space << __x._M_gd;
2307 
2308  __os.flags(__flags);
2309  __os.fill(__fill);
2310  __os.precision(__precision);
2311  return __os;
2312  }
2313 
2314  template<typename _RealType, typename _CharT, typename _Traits>
2317  student_t_distribution<_RealType>& __x)
2318  {
2319  using param_type
2320  = typename student_t_distribution<_RealType>::param_type;
2321  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2322 
2323  const typename __ios_base::fmtflags __flags = __is.flags();
2325 
2326  _RealType __n;
2327  if (__is >> __n >> __x._M_nd >> __x._M_gd)
2328  __x.param(param_type(__n));
2329 
2330  __is.flags(__flags);
2331  return __is;
2332  }
2333 
2334 
2335  template<typename _RealType>
2336  void
2337  gamma_distribution<_RealType>::param_type::
2338  _M_initialize()
2339  {
2340  _M_malpha = _M_alpha < 1.0 ? _M_alpha + _RealType(1.0) : _M_alpha;
2341 
2342  const _RealType __a1 = _M_malpha - _RealType(1.0) / _RealType(3.0);
2343  _M_a2 = _RealType(1.0) / std::sqrt(_RealType(9.0) * __a1);
2344  }
2345 
2346  /**
2347  * Marsaglia, G. and Tsang, W. W.
2348  * "A Simple Method for Generating Gamma Variables"
2349  * ACM Transactions on Mathematical Software, 26, 3, 363-372, 2000.
2350  */
2351  template<typename _RealType>
2352  template<typename _UniformRandomNumberGenerator>
2355  operator()(_UniformRandomNumberGenerator& __urng,
2356  const param_type& __param)
2357  {
2358  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2359  __aurng(__urng);
2360 
2361  result_type __u, __v, __n;
2362  const result_type __a1 = (__param._M_malpha
2363  - _RealType(1.0) / _RealType(3.0));
2364 
2365  do
2366  {
2367  do
2368  {
2369  __n = _M_nd(__urng);
2370  __v = result_type(1.0) + __param._M_a2 * __n;
2371  }
2372  while (__v <= 0.0);
2373 
2374  __v = __v * __v * __v;
2375  __u = __aurng();
2376  }
2377  while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n
2378  && (std::log(__u) > (0.5 * __n * __n + __a1
2379  * (1.0 - __v + std::log(__v)))));
2380 
2381  if (__param.alpha() == __param._M_malpha)
2382  return __a1 * __v * __param.beta();
2383  else
2384  {
2385  do
2386  __u = __aurng();
2387  while (__u == 0.0);
2388 
2389  return (std::pow(__u, result_type(1.0) / __param.alpha())
2390  * __a1 * __v * __param.beta());
2391  }
2392  }
2393 
2394  template<typename _RealType>
2395  template<typename _ForwardIterator,
2396  typename _UniformRandomNumberGenerator>
2397  void
2399  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2400  _UniformRandomNumberGenerator& __urng,
2401  const param_type& __param)
2402  {
2403  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2404  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2405  __aurng(__urng);
2406 
2407  result_type __u, __v, __n;
2408  const result_type __a1 = (__param._M_malpha
2409  - _RealType(1.0) / _RealType(3.0));
2410 
2411  if (__param.alpha() == __param._M_malpha)
2412  while (__f != __t)
2413  {
2414  do
2415  {
2416  do
2417  {
2418  __n = _M_nd(__urng);
2419  __v = result_type(1.0) + __param._M_a2 * __n;
2420  }
2421  while (__v <= 0.0);
2422 
2423  __v = __v * __v * __v;
2424  __u = __aurng();
2425  }
2426  while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n
2427  && (std::log(__u) > (0.5 * __n * __n + __a1
2428  * (1.0 - __v + std::log(__v)))));
2429 
2430  *__f++ = __a1 * __v * __param.beta();
2431  }
2432  else
2433  while (__f != __t)
2434  {
2435  do
2436  {
2437  do
2438  {
2439  __n = _M_nd(__urng);
2440  __v = result_type(1.0) + __param._M_a2 * __n;
2441  }
2442  while (__v <= 0.0);
2443 
2444  __v = __v * __v * __v;
2445  __u = __aurng();
2446  }
2447  while (__u > result_type(1.0) - 0.0331 * __n * __n * __n * __n
2448  && (std::log(__u) > (0.5 * __n * __n + __a1
2449  * (1.0 - __v + std::log(__v)))));
2450 
2451  do
2452  __u = __aurng();
2453  while (__u == 0.0);
2454 
2455  *__f++ = (std::pow(__u, result_type(1.0) / __param.alpha())
2456  * __a1 * __v * __param.beta());
2457  }
2458  }
2459 
2460  template<typename _RealType, typename _CharT, typename _Traits>
2463  const gamma_distribution<_RealType>& __x)
2464  {
2465  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2466 
2467  const typename __ios_base::fmtflags __flags = __os.flags();
2468  const _CharT __fill = __os.fill();
2469  const std::streamsize __precision = __os.precision();
2470  const _CharT __space = __os.widen(' ');
2472  __os.fill(__space);
2474 
2475  __os << __x.alpha() << __space << __x.beta()
2476  << __space << __x._M_nd;
2477 
2478  __os.flags(__flags);
2479  __os.fill(__fill);
2480  __os.precision(__precision);
2481  return __os;
2482  }
2483 
2484  template<typename _RealType, typename _CharT, typename _Traits>
2487  gamma_distribution<_RealType>& __x)
2488  {
2489  using param_type = typename gamma_distribution<_RealType>::param_type;
2490  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2491 
2492  const typename __ios_base::fmtflags __flags = __is.flags();
2494 
2495  _RealType __alpha_val, __beta_val;
2496  if (__is >> __alpha_val >> __beta_val >> __x._M_nd)
2497  __x.param(param_type(__alpha_val, __beta_val));
2498 
2499  __is.flags(__flags);
2500  return __is;
2501  }
2502 
2503 
2504  template<typename _RealType>
2505  template<typename _UniformRandomNumberGenerator>
2508  operator()(_UniformRandomNumberGenerator& __urng,
2509  const param_type& __p)
2510  {
2511  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2512  __aurng(__urng);
2513  return __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
2514  result_type(1) / __p.a());
2515  }
2516 
2517  template<typename _RealType>
2518  template<typename _ForwardIterator,
2519  typename _UniformRandomNumberGenerator>
2520  void
2522  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2523  _UniformRandomNumberGenerator& __urng,
2524  const param_type& __p)
2525  {
2526  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2527  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2528  __aurng(__urng);
2529  auto __inv_a = result_type(1) / __p.a();
2530 
2531  while (__f != __t)
2532  *__f++ = __p.b() * std::pow(-std::log(result_type(1) - __aurng()),
2533  __inv_a);
2534  }
2535 
2536  template<typename _RealType, typename _CharT, typename _Traits>
2540  {
2541  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2542 
2543  const typename __ios_base::fmtflags __flags = __os.flags();
2544  const _CharT __fill = __os.fill();
2545  const std::streamsize __precision = __os.precision();
2546  const _CharT __space = __os.widen(' ');
2548  __os.fill(__space);
2550 
2551  __os << __x.a() << __space << __x.b();
2552 
2553  __os.flags(__flags);
2554  __os.fill(__fill);
2555  __os.precision(__precision);
2556  return __os;
2557  }
2558 
2559  template<typename _RealType, typename _CharT, typename _Traits>
2563  {
2564  using param_type = typename weibull_distribution<_RealType>::param_type;
2565  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2566 
2567  const typename __ios_base::fmtflags __flags = __is.flags();
2569 
2570  _RealType __a, __b;
2571  if (__is >> __a >> __b)
2572  __x.param(param_type(__a, __b));
2573 
2574  __is.flags(__flags);
2575  return __is;
2576  }
2577 
2578 
2579  template<typename _RealType>
2580  template<typename _UniformRandomNumberGenerator>
2583  operator()(_UniformRandomNumberGenerator& __urng,
2584  const param_type& __p)
2585  {
2586  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2587  __aurng(__urng);
2588  return __p.a() - __p.b() * std::log(-std::log(result_type(1)
2589  - __aurng()));
2590  }
2591 
2592  template<typename _RealType>
2593  template<typename _ForwardIterator,
2594  typename _UniformRandomNumberGenerator>
2595  void
2597  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2598  _UniformRandomNumberGenerator& __urng,
2599  const param_type& __p)
2600  {
2601  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2602  __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
2603  __aurng(__urng);
2604 
2605  while (__f != __t)
2606  *__f++ = __p.a() - __p.b() * std::log(-std::log(result_type(1)
2607  - __aurng()));
2608  }
2609 
2610  template<typename _RealType, typename _CharT, typename _Traits>
2613  const extreme_value_distribution<_RealType>& __x)
2614  {
2615  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2616 
2617  const typename __ios_base::fmtflags __flags = __os.flags();
2618  const _CharT __fill = __os.fill();
2619  const std::streamsize __precision = __os.precision();
2620  const _CharT __space = __os.widen(' ');
2622  __os.fill(__space);
2624 
2625  __os << __x.a() << __space << __x.b();
2626 
2627  __os.flags(__flags);
2628  __os.fill(__fill);
2629  __os.precision(__precision);
2630  return __os;
2631  }
2632 
2633  template<typename _RealType, typename _CharT, typename _Traits>
2637  {
2638  using param_type
2640  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2641 
2642  const typename __ios_base::fmtflags __flags = __is.flags();
2644 
2645  _RealType __a, __b;
2646  if (__is >> __a >> __b)
2647  __x.param(param_type(__a, __b));
2648 
2649  __is.flags(__flags);
2650  return __is;
2651  }
2652 
2653 
2654  template<typename _IntType>
2655  void
2656  discrete_distribution<_IntType>::param_type::
2657  _M_initialize()
2658  {
2659  if (_M_prob.size() < 2)
2660  {
2661  _M_prob.clear();
2662  return;
2663  }
2664 
2665  const double __sum = std::accumulate(_M_prob.begin(),
2666  _M_prob.end(), 0.0);
2667  __glibcxx_assert(__sum > 0);
2668  // Now normalize the probabilites.
2669  __detail::__normalize(_M_prob.begin(), _M_prob.end(), _M_prob.begin(),
2670  __sum);
2671  // Accumulate partial sums.
2672  _M_cp.reserve(_M_prob.size());
2673  std::partial_sum(_M_prob.begin(), _M_prob.end(),
2674  std::back_inserter(_M_cp));
2675  // Make sure the last cumulative probability is one.
2676  _M_cp[_M_cp.size() - 1] = 1.0;
2677  }
2678 
2679  template<typename _IntType>
2680  template<typename _Func>
2681  discrete_distribution<_IntType>::param_type::
2682  param_type(size_t __nw, double __xmin, double __xmax, _Func __fw)
2683  : _M_prob(), _M_cp()
2684  {
2685  const size_t __n = __nw == 0 ? 1 : __nw;
2686  const double __delta = (__xmax - __xmin) / __n;
2687 
2688  _M_prob.reserve(__n);
2689  for (size_t __k = 0; __k < __nw; ++__k)
2690  _M_prob.push_back(__fw(__xmin + __k * __delta + 0.5 * __delta));
2691 
2692  _M_initialize();
2693  }
2694 
2695  template<typename _IntType>
2696  template<typename _UniformRandomNumberGenerator>
2697  typename discrete_distribution<_IntType>::result_type
2698  discrete_distribution<_IntType>::
2699  operator()(_UniformRandomNumberGenerator& __urng,
2700  const param_type& __param)
2701  {
2702  if (__param._M_cp.empty())
2703  return result_type(0);
2704 
2705  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
2706  __aurng(__urng);
2707 
2708  const double __p = __aurng();
2709  auto __pos = std::lower_bound(__param._M_cp.begin(),
2710  __param._M_cp.end(), __p);
2711 
2712  return __pos - __param._M_cp.begin();
2713  }
2714 
2715  template<typename _IntType>
2716  template<typename _ForwardIterator,
2717  typename _UniformRandomNumberGenerator>
2718  void
2719  discrete_distribution<_IntType>::
2720  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2721  _UniformRandomNumberGenerator& __urng,
2722  const param_type& __param)
2723  {
2724  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2725 
2726  if (__param._M_cp.empty())
2727  {
2728  while (__f != __t)
2729  *__f++ = result_type(0);
2730  return;
2731  }
2732 
2733  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
2734  __aurng(__urng);
2735 
2736  while (__f != __t)
2737  {
2738  const double __p = __aurng();
2739  auto __pos = std::lower_bound(__param._M_cp.begin(),
2740  __param._M_cp.end(), __p);
2741 
2742  *__f++ = __pos - __param._M_cp.begin();
2743  }
2744  }
2745 
2746  template<typename _IntType, typename _CharT, typename _Traits>
2749  const discrete_distribution<_IntType>& __x)
2750  {
2751  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2752 
2753  const typename __ios_base::fmtflags __flags = __os.flags();
2754  const _CharT __fill = __os.fill();
2755  const std::streamsize __precision = __os.precision();
2756  const _CharT __space = __os.widen(' ');
2758  __os.fill(__space);
2760 
2761  std::vector<double> __prob = __x.probabilities();
2762  __os << __prob.size();
2763  for (auto __dit = __prob.begin(); __dit != __prob.end(); ++__dit)
2764  __os << __space << *__dit;
2765 
2766  __os.flags(__flags);
2767  __os.fill(__fill);
2768  __os.precision(__precision);
2769  return __os;
2770  }
2771 
2772 namespace __detail
2773 {
2774  template<typename _ValT, typename _CharT, typename _Traits>
2775  basic_istream<_CharT, _Traits>&
2776  __extract_params(basic_istream<_CharT, _Traits>& __is,
2777  vector<_ValT>& __vals, size_t __n)
2778  {
2779  __vals.reserve(__n);
2780  while (__n--)
2781  {
2782  _ValT __val;
2783  if (__is >> __val)
2784  __vals.push_back(__val);
2785  else
2786  break;
2787  }
2788  return __is;
2789  }
2790 } // namespace __detail
2791 
2792  template<typename _IntType, typename _CharT, typename _Traits>
2795  discrete_distribution<_IntType>& __x)
2796  {
2797  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
2798 
2799  const typename __ios_base::fmtflags __flags = __is.flags();
2801 
2802  size_t __n;
2803  if (__is >> __n)
2804  {
2805  std::vector<double> __prob_vec;
2806  if (__detail::__extract_params(__is, __prob_vec, __n))
2807  __x.param({__prob_vec.begin(), __prob_vec.end()});
2808  }
2809 
2810  __is.flags(__flags);
2811  return __is;
2812  }
2813 
2814 
2815  template<typename _RealType>
2816  void
2817  piecewise_constant_distribution<_RealType>::param_type::
2818  _M_initialize()
2819  {
2820  if (_M_int.size() < 2
2821  || (_M_int.size() == 2
2822  && _M_int[0] == _RealType(0)
2823  && _M_int[1] == _RealType(1)))
2824  {
2825  _M_int.clear();
2826  _M_den.clear();
2827  return;
2828  }
2829 
2830  const double __sum = std::accumulate(_M_den.begin(),
2831  _M_den.end(), 0.0);
2832  __glibcxx_assert(__sum > 0);
2833 
2834  __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
2835  __sum);
2836 
2837  _M_cp.reserve(_M_den.size());
2838  std::partial_sum(_M_den.begin(), _M_den.end(),
2839  std::back_inserter(_M_cp));
2840 
2841  // Make sure the last cumulative probability is one.
2842  _M_cp[_M_cp.size() - 1] = 1.0;
2843 
2844  for (size_t __k = 0; __k < _M_den.size(); ++__k)
2845  _M_den[__k] /= _M_int[__k + 1] - _M_int[__k];
2846  }
2847 
2848  template<typename _RealType>
2849  template<typename _InputIteratorB, typename _InputIteratorW>
2850  piecewise_constant_distribution<_RealType>::param_type::
2851  param_type(_InputIteratorB __bbegin,
2852  _InputIteratorB __bend,
2853  _InputIteratorW __wbegin)
2854  : _M_int(), _M_den(), _M_cp()
2855  {
2856  if (__bbegin != __bend)
2857  {
2858  for (;;)
2859  {
2860  _M_int.push_back(*__bbegin);
2861  ++__bbegin;
2862  if (__bbegin == __bend)
2863  break;
2864 
2865  _M_den.push_back(*__wbegin);
2866  ++__wbegin;
2867  }
2868  }
2869 
2870  _M_initialize();
2871  }
2872 
2873  template<typename _RealType>
2874  template<typename _Func>
2875  piecewise_constant_distribution<_RealType>::param_type::
2876  param_type(initializer_list<_RealType> __bl, _Func __fw)
2877  : _M_int(), _M_den(), _M_cp()
2878  {
2879  _M_int.reserve(__bl.size());
2880  for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
2881  _M_int.push_back(*__biter);
2882 
2883  _M_den.reserve(_M_int.size() - 1);
2884  for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
2885  _M_den.push_back(__fw(0.5 * (_M_int[__k + 1] + _M_int[__k])));
2886 
2887  _M_initialize();
2888  }
2889 
2890  template<typename _RealType>
2891  template<typename _Func>
2892  piecewise_constant_distribution<_RealType>::param_type::
2893  param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
2894  : _M_int(), _M_den(), _M_cp()
2895  {
2896  const size_t __n = __nw == 0 ? 1 : __nw;
2897  const _RealType __delta = (__xmax - __xmin) / __n;
2898 
2899  _M_int.reserve(__n + 1);
2900  for (size_t __k = 0; __k <= __nw; ++__k)
2901  _M_int.push_back(__xmin + __k * __delta);
2902 
2903  _M_den.reserve(__n);
2904  for (size_t __k = 0; __k < __nw; ++__k)
2905  _M_den.push_back(__fw(_M_int[__k] + 0.5 * __delta));
2906 
2907  _M_initialize();
2908  }
2909 
2910  template<typename _RealType>
2911  template<typename _UniformRandomNumberGenerator>
2912  typename piecewise_constant_distribution<_RealType>::result_type
2913  piecewise_constant_distribution<_RealType>::
2914  operator()(_UniformRandomNumberGenerator& __urng,
2915  const param_type& __param)
2916  {
2917  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
2918  __aurng(__urng);
2919 
2920  const double __p = __aurng();
2921  if (__param._M_cp.empty())
2922  return __p;
2923 
2924  auto __pos = std::lower_bound(__param._M_cp.begin(),
2925  __param._M_cp.end(), __p);
2926  const size_t __i = __pos - __param._M_cp.begin();
2927 
2928  const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
2929 
2930  return __param._M_int[__i] + (__p - __pref) / __param._M_den[__i];
2931  }
2932 
2933  template<typename _RealType>
2934  template<typename _ForwardIterator,
2935  typename _UniformRandomNumberGenerator>
2936  void
2937  piecewise_constant_distribution<_RealType>::
2938  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
2939  _UniformRandomNumberGenerator& __urng,
2940  const param_type& __param)
2941  {
2942  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
2943  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
2944  __aurng(__urng);
2945 
2946  if (__param._M_cp.empty())
2947  {
2948  while (__f != __t)
2949  *__f++ = __aurng();
2950  return;
2951  }
2952 
2953  while (__f != __t)
2954  {
2955  const double __p = __aurng();
2956 
2957  auto __pos = std::lower_bound(__param._M_cp.begin(),
2958  __param._M_cp.end(), __p);
2959  const size_t __i = __pos - __param._M_cp.begin();
2960 
2961  const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
2962 
2963  *__f++ = (__param._M_int[__i]
2964  + (__p - __pref) / __param._M_den[__i]);
2965  }
2966  }
2967 
2968  template<typename _RealType, typename _CharT, typename _Traits>
2971  const piecewise_constant_distribution<_RealType>& __x)
2972  {
2973  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
2974 
2975  const typename __ios_base::fmtflags __flags = __os.flags();
2976  const _CharT __fill = __os.fill();
2977  const std::streamsize __precision = __os.precision();
2978  const _CharT __space = __os.widen(' ');
2980  __os.fill(__space);
2982 
2983  std::vector<_RealType> __int = __x.intervals();
2984  __os << __int.size() - 1;
2985 
2986  for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
2987  __os << __space << *__xit;
2988 
2989  std::vector<double> __den = __x.densities();
2990  for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
2991  __os << __space << *__dit;
2992 
2993  __os.flags(__flags);
2994  __os.fill(__fill);
2995  __os.precision(__precision);
2996  return __os;
2997  }
2998 
2999  template<typename _RealType, typename _CharT, typename _Traits>
3002  piecewise_constant_distribution<_RealType>& __x)
3003  {
3004  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
3005 
3006  const typename __ios_base::fmtflags __flags = __is.flags();
3008 
3009  size_t __n;
3010  if (__is >> __n)
3011  {
3012  std::vector<_RealType> __int_vec;
3013  if (__detail::__extract_params(__is, __int_vec, __n + 1))
3014  {
3015  std::vector<double> __den_vec;
3016  if (__detail::__extract_params(__is, __den_vec, __n))
3017  {
3018  __x.param({ __int_vec.begin(), __int_vec.end(),
3019  __den_vec.begin() });
3020  }
3021  }
3022  }
3023 
3024  __is.flags(__flags);
3025  return __is;
3026  }
3027 
3028 
3029  template<typename _RealType>
3030  void
3031  piecewise_linear_distribution<_RealType>::param_type::
3032  _M_initialize()
3033  {
3034  if (_M_int.size() < 2
3035  || (_M_int.size() == 2
3036  && _M_int[0] == _RealType(0)
3037  && _M_int[1] == _RealType(1)
3038  && _M_den[0] == _M_den[1]))
3039  {
3040  _M_int.clear();
3041  _M_den.clear();
3042  return;
3043  }
3044 
3045  double __sum = 0.0;
3046  _M_cp.reserve(_M_int.size() - 1);
3047  _M_m.reserve(_M_int.size() - 1);
3048  for (size_t __k = 0; __k < _M_int.size() - 1; ++__k)
3049  {
3050  const _RealType __delta = _M_int[__k + 1] - _M_int[__k];
3051  __sum += 0.5 * (_M_den[__k + 1] + _M_den[__k]) * __delta;
3052  _M_cp.push_back(__sum);
3053  _M_m.push_back((_M_den[__k + 1] - _M_den[__k]) / __delta);
3054  }
3055  __glibcxx_assert(__sum > 0);
3056 
3057  // Now normalize the densities...
3058  __detail::__normalize(_M_den.begin(), _M_den.end(), _M_den.begin(),
3059  __sum);
3060  // ... and partial sums...
3061  __detail::__normalize(_M_cp.begin(), _M_cp.end(), _M_cp.begin(), __sum);
3062  // ... and slopes.
3063  __detail::__normalize(_M_m.begin(), _M_m.end(), _M_m.begin(), __sum);
3064 
3065  // Make sure the last cumulative probablility is one.
3066  _M_cp[_M_cp.size() - 1] = 1.0;
3067  }
3068 
3069  template<typename _RealType>
3070  template<typename _InputIteratorB, typename _InputIteratorW>
3071  piecewise_linear_distribution<_RealType>::param_type::
3072  param_type(_InputIteratorB __bbegin,
3073  _InputIteratorB __bend,
3074  _InputIteratorW __wbegin)
3075  : _M_int(), _M_den(), _M_cp(), _M_m()
3076  {
3077  for (; __bbegin != __bend; ++__bbegin, ++__wbegin)
3078  {
3079  _M_int.push_back(*__bbegin);
3080  _M_den.push_back(*__wbegin);
3081  }
3082 
3083  _M_initialize();
3084  }
3085 
3086  template<typename _RealType>
3087  template<typename _Func>
3088  piecewise_linear_distribution<_RealType>::param_type::
3089  param_type(initializer_list<_RealType> __bl, _Func __fw)
3090  : _M_int(), _M_den(), _M_cp(), _M_m()
3091  {
3092  _M_int.reserve(__bl.size());
3093  _M_den.reserve(__bl.size());
3094  for (auto __biter = __bl.begin(); __biter != __bl.end(); ++__biter)
3095  {
3096  _M_int.push_back(*__biter);
3097  _M_den.push_back(__fw(*__biter));
3098  }
3099 
3100  _M_initialize();
3101  }
3102 
3103  template<typename _RealType>
3104  template<typename _Func>
3105  piecewise_linear_distribution<_RealType>::param_type::
3106  param_type(size_t __nw, _RealType __xmin, _RealType __xmax, _Func __fw)
3107  : _M_int(), _M_den(), _M_cp(), _M_m()
3108  {
3109  const size_t __n = __nw == 0 ? 1 : __nw;
3110  const _RealType __delta = (__xmax - __xmin) / __n;
3111 
3112  _M_int.reserve(__n + 1);
3113  _M_den.reserve(__n + 1);
3114  for (size_t __k = 0; __k <= __nw; ++__k)
3115  {
3116  _M_int.push_back(__xmin + __k * __delta);
3117  _M_den.push_back(__fw(_M_int[__k] + __delta));
3118  }
3119 
3120  _M_initialize();
3121  }
3122 
3123  template<typename _RealType>
3124  template<typename _UniformRandomNumberGenerator>
3125  typename piecewise_linear_distribution<_RealType>::result_type
3126  piecewise_linear_distribution<_RealType>::
3127  operator()(_UniformRandomNumberGenerator& __urng,
3128  const param_type& __param)
3129  {
3130  __detail::_Adaptor<_UniformRandomNumberGenerator, double>
3131  __aurng(__urng);
3132 
3133  const double __p = __aurng();
3134  if (__param._M_cp.empty())
3135  return __p;
3136 
3137  auto __pos = std::lower_bound(__param._M_cp.begin(),
3138  __param._M_cp.end(), __p);
3139  const size_t __i = __pos - __param._M_cp.begin();
3140 
3141  const double __pref = __i > 0 ? __param._M_cp[__i - 1] : 0.0;
3142 
3143  const double __a = 0.5 * __param._M_m[__i];
3144  const double __b = __param._M_den[__i];
3145  const double __cm = __p - __pref;
3146 
3147  _RealType __x = __param._M_int[__i];
3148  if (__a == 0)
3149  __x += __cm / __b;
3150  else
3151  {
3152  const double __d = __b * __b + 4.0 * __a * __cm;
3153  __x += 0.5 * (std::sqrt(__d) - __b) / __a;
3154  }
3155 
3156  return __x;
3157  }
3158 
3159  template<typename _RealType>
3160  template<typename _ForwardIterator,
3161  typename _UniformRandomNumberGenerator>
3162  void
3163  piecewise_linear_distribution<_RealType>::
3164  __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
3165  _UniformRandomNumberGenerator& __urng,
3166  const param_type& __param)
3167  {
3168  __glibcxx_function_requires(_ForwardIteratorConcept<_ForwardIterator>)
3169  // We could duplicate everything from operator()...
3170  while (__f != __t)
3171  *__f++ = this->operator()(__urng, __param);
3172  }
3173 
3174  template<typename _RealType, typename _CharT, typename _Traits>
3177  const piecewise_linear_distribution<_RealType>& __x)
3178  {
3179  using __ios_base = typename basic_ostream<_CharT, _Traits>::ios_base;
3180 
3181  const typename __ios_base::fmtflags __flags = __os.flags();
3182  const _CharT __fill = __os.fill();
3183  const std::streamsize __precision = __os.precision();
3184  const _CharT __space = __os.widen(' ');
3186  __os.fill(__space);
3188 
3189  std::vector<_RealType> __int = __x.intervals();
3190  __os << __int.size() - 1;
3191 
3192  for (auto __xit = __int.begin(); __xit != __int.end(); ++__xit)
3193  __os << __space << *__xit;
3194 
3195  std::vector<double> __den = __x.densities();
3196  for (auto __dit = __den.begin(); __dit != __den.end(); ++__dit)
3197  __os << __space << *__dit;
3198 
3199  __os.flags(__flags);
3200  __os.fill(__fill);
3201  __os.precision(__precision);
3202  return __os;
3203  }
3204 
3205  template<typename _RealType, typename _CharT, typename _Traits>
3208  piecewise_linear_distribution<_RealType>& __x)
3209  {
3210  using __ios_base = typename basic_istream<_CharT, _Traits>::ios_base;
3211 
3212  const typename __ios_base::fmtflags __flags = __is.flags();
3214 
3215  size_t __n;
3216  if (__is >> __n)
3217  {
3218  vector<_RealType> __int_vec;
3219  if (__detail::__extract_params(__is, __int_vec, __n + 1))
3220  {
3221  vector<double> __den_vec;
3222  if (__detail::__extract_params(__is, __den_vec, __n + 1))
3223  {
3224  __x.param({ __int_vec.begin(), __int_vec.end(),
3225  __den_vec.begin() });
3226  }
3227  }
3228  }
3229  __is.flags(__flags);
3230  return __is;
3231  }
3232 
3233 
3234  template<typename _IntType>
3235  seed_seq::seed_seq(std::initializer_list<_IntType> __il)
3236  {
3237  for (auto __iter = __il.begin(); __iter != __il.end(); ++__iter)
3238  _M_v.push_back(__detail::__mod<result_type,
3239  __detail::_Shift<result_type, 32>::__value>(*__iter));
3240  }
3241 
3242  template<typename _InputIterator>
3243  seed_seq::seed_seq(_InputIterator __begin, _InputIterator __end)
3244  {
3245  for (_InputIterator __iter = __begin; __iter != __end; ++__iter)
3246  _M_v.push_back(__detail::__mod<result_type,
3247  __detail::_Shift<result_type, 32>::__value>(*__iter));
3248  }
3249 
3250  template<typename _RandomAccessIterator>
3251  void
3252  seed_seq::generate(_RandomAccessIterator __begin,
3253  _RandomAccessIterator __end)
3254  {
3255  typedef typename iterator_traits<_RandomAccessIterator>::value_type
3256  _Type;
3257 
3258  if (__begin == __end)
3259  return;
3260 
3261  std::fill(__begin, __end, _Type(0x8b8b8b8bu));
3262 
3263  const size_t __n = __end - __begin;
3264  const size_t __s = _M_v.size();
3265  const size_t __t = (__n >= 623) ? 11
3266  : (__n >= 68) ? 7
3267  : (__n >= 39) ? 5
3268  : (__n >= 7) ? 3
3269  : (__n - 1) / 2;
3270  const size_t __p = (__n - __t) / 2;
3271  const size_t __q = __p + __t;
3272  const size_t __m = std::max(size_t(__s + 1), __n);
3273 
3274 #ifndef __UINT32_TYPE__
3275  struct _Up
3276  {
3277  _Up(uint_least32_t v) : _M_v(v & 0xffffffffu) { }
3278 
3279  operator uint_least32_t() const { return _M_v; }
3280 
3281  uint_least32_t _M_v;
3282  };
3283  using uint32_t = _Up;
3284 #endif
3285 
3286  // k == 0, every element in [begin,end) equals 0x8b8b8b8bu
3287  {
3288  uint32_t __r1 = 1371501266u;
3289  uint32_t __r2 = __r1 + __s;
3290  __begin[__p] += __r1;
3291  __begin[__q] = (uint32_t)__begin[__q] + __r2;
3292  __begin[0] = __r2;
3293  }
3294 
3295  for (size_t __k = 1; __k <= __s; ++__k)
3296  {
3297  const size_t __kn = __k % __n;
3298  const size_t __kpn = (__k + __p) % __n;
3299  const size_t __kqn = (__k + __q) % __n;
3300  uint32_t __arg = (__begin[__kn]
3301  ^ __begin[__kpn]
3302  ^ __begin[(__k - 1) % __n]);
3303  uint32_t __r1 = 1664525u * (__arg ^ (__arg >> 27));
3304  uint32_t __r2 = __r1 + (uint32_t)__kn + _M_v[__k - 1];
3305  __begin[__kpn] = (uint32_t)__begin[__kpn] + __r1;
3306  __begin[__kqn] = (uint32_t)__begin[__kqn] + __r2;
3307  __begin[__kn] = __r2;
3308  }
3309 
3310  for (size_t __k = __s + 1; __k < __m; ++__k)
3311  {
3312  const size_t __kn = __k % __n;
3313  const size_t __kpn = (__k + __p) % __n;
3314  const size_t __kqn = (__k + __q) % __n;
3315  uint32_t __arg = (__begin[__kn]
3316  ^ __begin[__kpn]
3317  ^ __begin[(__k - 1) % __n]);
3318  uint32_t __r1 = 1664525u * (__arg ^ (__arg >> 27));
3319  uint32_t __r2 = __r1 + (uint32_t)__kn;
3320  __begin[__kpn] = (uint32_t)__begin[__kpn] + __r1;
3321  __begin[__kqn] = (uint32_t)__begin[__kqn] + __r2;
3322  __begin[__kn] = __r2;
3323  }
3324 
3325  for (size_t __k = __m; __k < __m + __n; ++__k)
3326  {
3327  const size_t __kn = __k % __n;
3328  const size_t __kpn = (__k + __p) % __n;
3329  const size_t __kqn = (__k + __q) % __n;
3330  uint32_t __arg = (__begin[__kn]
3331  + __begin[__kpn]
3332  + __begin[(__k - 1) % __n]);
3333  uint32_t __r3 = 1566083941u * (__arg ^ (__arg >> 27));
3334  uint32_t __r4 = __r3 - __kn;
3335  __begin[__kpn] ^= __r3;
3336  __begin[__kqn] ^= __r4;
3337  __begin[__kn] = __r4;
3338  }
3339  }
3340 
3341  template<typename _RealType, size_t __bits,
3342  typename _UniformRandomNumberGenerator>
3343  _RealType
3344  generate_canonical(_UniformRandomNumberGenerator& __urng)
3345  {
3347  "template argument must be a floating point type");
3348 
3349  const size_t __b
3350  = std::min(static_cast<size_t>(std::numeric_limits<_RealType>::digits),
3351  __bits);
3352  const long double __r = static_cast<long double>(__urng.max())
3353  - static_cast<long double>(__urng.min()) + 1.0L;
3354  const size_t __log2r = std::log(__r) / std::log(2.0L);
3355  const size_t __m = std::max<size_t>(1UL,
3356  (__b + __log2r - 1UL) / __log2r);
3357  _RealType __ret;
3358  _RealType __sum = _RealType(0);
3359  _RealType __tmp = _RealType(1);
3360  for (size_t __k = __m; __k != 0; --__k)
3361  {
3362  __sum += _RealType(__urng() - __urng.min()) * __tmp;
3363  __tmp *= __r;
3364  }
3365  __ret = __sum / __tmp;
3366  if (__builtin_expect(__ret >= _RealType(1), 0))
3367  {
3368 #if _GLIBCXX_USE_C99_MATH_TR1
3369  __ret = std::nextafter(_RealType(1), _RealType(0));
3370 #else
3371  __ret = _RealType(1)
3372  - std::numeric_limits<_RealType>::epsilon() / _RealType(2);
3373 #endif
3374  }
3375  return __ret;
3376  }
3377 
3378 _GLIBCXX_END_NAMESPACE_VERSION
3379 } // namespace
3380 
3381 #endif
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
Definition: complex:824
complex< _Tp > tan(const complex< _Tp > &)
Return complex tangent of z.
Definition: complex:960
_Tp abs(const complex< _Tp > &)
Return magnitude of z.
Definition: complex:630
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
Definition: complex:797
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
Definition: complex:1019
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition: complex:933
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:254
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:230
_RealType generate_canonical(_UniformRandomNumberGenerator &__g)
A function template for converting the output of a (integral) uniform random number generator to a fl...
basic_ostream< _Ch_type, _Ch_traits > & operator<<(basic_ostream< _Ch_type, _Ch_traits > &__os, const sub_match< _Bi_iter > &__m)
Inserts a matched string into an output stream.
Definition: regex.h:1649
constexpr back_insert_iterator< _Container > back_inserter(_Container &__x)
constexpr _Tp accumulate(_InputIterator __first, _InputIterator __last, _Tp __init)
Accumulate values in a range.
Definition: stl_numeric.h:134
constexpr _OutputIterator partial_sum(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
Return list of partial sums.
Definition: stl_numeric.h:256
ISO C++ entities toplevel namespace is std.
std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: bitset:1472
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition: postypes.h:98
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
Definition: bitset:1540
ios_base & scientific(ios_base &__base)
Calls base.setf(ios_base::scientific, ios_base::floatfield).
Definition: ios_base.h:1079
ios_base & dec(ios_base &__base)
Calls base.setf(ios_base::dec, ios_base::basefield).
Definition: ios_base.h:1046
constexpr int __lg(int __n)
This is a helper function for the sort routines and for random.tcc.
ios_base & left(ios_base &__base)
Calls base.setf(ios_base::left, ios_base::adjustfield).
Definition: ios_base.h:1029
ios_base & skipws(ios_base &__base)
Calls base.setf(ios_base::skipws).
Definition: ios_base.h:972
ios_base & fixed(ios_base &__base)
Calls base.setf(ios_base::fixed, ios_base::floatfield).
Definition: ios_base.h:1071
initializer_list
void clear(iostate __state=goodbit)
[Re]sets the error state.
Definition: basic_ios.tcc:41
char_type widen(char __c) const
Widens characters.
Definition: basic_ios.h:449
char_type fill() const
Retrieves the empty character.
Definition: basic_ios.h:370
Template class basic_istream.
Definition: istream:59
Template class basic_ostream.
Definition: ostream:59
static constexpr bool is_integer
Definition: limits:226
static constexpr int digits
Definition: limits:211
static constexpr bool is_signed
Definition: limits:223
Properties of fundamental types.
Definition: limits:313
static constexpr _Tp max() noexcept
Definition: limits:321
static constexpr _Tp epsilon() noexcept
Definition: limits:333
static constexpr _Tp min() noexcept
Definition: limits:317
is_floating_point
Definition: type_traits:398
common_type
Definition: type_traits:2175
streamsize precision() const
Flags access.
Definition: ios_base.h:719
fmtflags flags() const
Access to format flags.
Definition: ios_base.h:649
A model of a linear congruential random number generator.
Definition: random.h:256
static constexpr result_type multiplier
Definition: random.h:271
static constexpr result_type modulus
Definition: random.h:275
void seed(result_type __s=default_seed)
Reseeds the linear_congruential_engine random number generator engine sequence to the seed __s.
static constexpr result_type increment
Definition: random.h:273
The Marsaglia-Zaman generator.
Definition: random.h:693
void seed(result_type __sd=default_seed)
Seeds the initial state of the random number generator.
result_type operator()()
Gets the next random number in the sequence.
result_type operator()()
Gets the next value in the generated random number sequence.
result_type operator()()
Gets the next value in the generated random number sequence.
Produces random numbers by reordering random numbers from some base engine.
Definition: random.h:1327
_RandomNumberEngine::result_type result_type
Definition: random.h:1329
const _RandomNumberEngine & base() const noexcept
Definition: random.h:1433
Uniform continuous distribution for random numbers.
Definition: random.h:1743
param_type param() const
Returns the parameter set of the distribution.
Definition: random.h:1830
A normal continuous distribution for random numbers.
Definition: random.h:1973
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:2090
A gamma continuous distribution for random numbers.
Definition: random.h:2405
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:2532
_RealType result_type
Definition: random.h:2407
A chi_squared_distribution random number distribution.
Definition: random.h:2633
A cauchy_distribution random number distribution.
Definition: random.h:2857
param_type param() const
Returns the parameter set of the distribution.
Definition: random.h:2932
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:2962
A fisher_f_distribution random number distribution.
Definition: random.h:3065
A student_t_distribution random number distribution.
Definition: random.h:3297
A discrete binomial random number distribution.
Definition: random.h:3741
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:3867
A discrete geometric random number distribution.
Definition: random.h:3981
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:4090
param_type param() const
Returns the parameter set of the distribution.
Definition: random.h:4060
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
A discrete Poisson random number distribution.
Definition: random.h:4422
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:4533
friend std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const std::poisson_distribution< _IntType1 > &__x)
Inserts a poisson_distribution random number distribution __x into the output stream __os.
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:4569
friend std::basic_istream< _CharT, _Traits > & operator>>(std::basic_istream< _CharT, _Traits > &__is, std::poisson_distribution< _IntType1 > &__x)
Extracts a poisson_distribution random number distribution __x from the input stream __is.
An exponential continuous distribution for random numbers.
Definition: random.h:4648
param_type param() const
Returns the parameter set of the distribution.
Definition: random.h:4726
A weibull_distribution random number distribution.
Definition: random.h:4863
param_type param() const
Returns the parameter set of the distribution.
Definition: random.h:4941
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:4971
_RealType b() const
Return the parameter of the distribution.
Definition: random.h:4934
_RealType a() const
Return the parameter of the distribution.
Definition: random.h:4927
A extreme_value_distribution random number distribution.
Definition: random.h:5073
result_type operator()(_UniformRandomNumberGenerator &__urng)
Generating functions.
Definition: random.h:5181
param_type param() const
Returns the parameter set of the distribution.
Definition: random.h:5151
iterator begin() noexcept
Definition: stl_vector.h:811
iterator end() noexcept
Definition: stl_vector.h:829
size_type size() const noexcept
Definition: stl_vector.h:918
Uniform discrete distribution for random numbers. A discrete random distribution on the range with e...
param_type param() const
Returns the parameter set of the distribution.