libstdc++: random.tcc Source File

libstdc++

ext/random.tcc
Go to the documentation of this file.
1// Random number extensions -*- C++ -*-
2
3// Copyright (C) 2012-2026 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 ext/random.tcc
26 * This is an internal header file, included by other library headers.
27 * Do not attempt to use it directly. @headername{ext/random}
28 */
29
30#ifndef _EXT_RANDOM_TCC
31#define _EXT_RANDOM_TCC 1
32
33#ifdef _GLIBCXX_SYSHDR
34#pragma GCC system_header
35#endif
36
37#include <bits/requires_hosted.h> // GNU extensions are currently omitted
38
39namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
40{
41_GLIBCXX_BEGIN_NAMESPACE_VERSION
42
43#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
44
45 template<typename _UIntType, size_t __m,
46 size_t __pos1, size_t __sl1, size_t __sl2,
47 size_t __sr1, size_t __sr2,
48 uint32_t __msk1, uint32_t __msk2,
49 uint32_t __msk3, uint32_t __msk4,
50 uint32_t __parity1, uint32_t __parity2,
51 uint32_t __parity3, uint32_t __parity4>
52 void simd_fast_mersenne_twister_engine<_UIntType, __m,
53 __pos1, __sl1, __sl2, __sr1, __sr2,
54 __msk1, __msk2, __msk3, __msk4,
55 __parity1, __parity2, __parity3,
56 __parity4>::
57 seed(_UIntType __seed)
58 {
59 _M_state32[0] = static_cast<uint32_t>(__seed);
60 for (size_t __i = 1; __i < _M_nstate32; ++__i)
61 _M_state32[__i] = (1812433253UL
62 * (_M_state32[__i - 1] ^ (_M_state32[__i - 1] >> 30))
63 + __i);
64 _M_pos = state_size;
65 _M_period_certification();
66 }
67
68
69 namespace {
70
71 inline uint32_t _Func1(uint32_t __x)
72 {
73 return (__x ^ (__x >> 27)) * UINT32_C(1664525);
74 }
75
76 inline uint32_t _Func2(uint32_t __x)
77 {
78 return (__x ^ (__x >> 27)) * UINT32_C(1566083941);
79 }
80
81 }
82
83
84 template<typename _UIntType, size_t __m,
85 size_t __pos1, size_t __sl1, size_t __sl2,
86 size_t __sr1, size_t __sr2,
87 uint32_t __msk1, uint32_t __msk2,
88 uint32_t __msk3, uint32_t __msk4,
89 uint32_t __parity1, uint32_t __parity2,
90 uint32_t __parity3, uint32_t __parity4>
91 template<typename _Sseq>
92 auto
93 simd_fast_mersenne_twister_engine<_UIntType, __m,
94 __pos1, __sl1, __sl2, __sr1, __sr2,
95 __msk1, __msk2, __msk3, __msk4,
96 __parity1, __parity2, __parity3,
97 __parity4>::
98 seed(_Sseq& __q)
99 -> _If_seed_seq<_Sseq>
100 {
101 size_t __lag;
102
103 if (_M_nstate32 >= 623)
104 __lag = 11;
105 else if (_M_nstate32 >= 68)
106 __lag = 7;
107 else if (_M_nstate32 >= 39)
108 __lag = 5;
109 else
110 __lag = 3;
111 const size_t __mid = (_M_nstate32 - __lag) / 2;
112
113 std::fill(_M_state32, _M_state32 + _M_nstate32, UINT32_C(0x8b8b8b8b));
114 uint32_t __arr[_M_nstate32];
115 __q.generate(__arr + 0, __arr + _M_nstate32);
116
117 uint32_t __r = _Func1(_M_state32[0] ^ _M_state32[__mid]
118 ^ _M_state32[_M_nstate32 - 1]);
119 _M_state32[__mid] += __r;
120 __r += _M_nstate32;
121 _M_state32[__mid + __lag] += __r;
122 _M_state32[0] = __r;
123
124 for (size_t __i = 1, __j = 0; __j < _M_nstate32; ++__j)
125 {
126 __r = _Func1(_M_state32[__i]
127 ^ _M_state32[(__i + __mid) % _M_nstate32]
128 ^ _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);
129 _M_state32[(__i + __mid) % _M_nstate32] += __r;
130 __r += __arr[__j] + __i;
131 _M_state32[(__i + __mid + __lag) % _M_nstate32] += __r;
132 _M_state32[__i] = __r;
133 __i = (__i + 1) % _M_nstate32;
134 }
135 for (size_t __j = 0; __j < _M_nstate32; ++__j)
136 {
137 const size_t __i = (__j + 1) % _M_nstate32;
138 __r = _Func2(_M_state32[__i]
139 + _M_state32[(__i + __mid) % _M_nstate32]
140 + _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);
141 _M_state32[(__i + __mid) % _M_nstate32] ^= __r;
142 __r -= __i;
143 _M_state32[(__i + __mid + __lag) % _M_nstate32] ^= __r;
144 _M_state32[__i] = __r;
145 }
146
147 _M_pos = state_size;
148 _M_period_certification();
149 }
150
151
152 template<typename _UIntType, size_t __m,
153 size_t __pos1, size_t __sl1, size_t __sl2,
154 size_t __sr1, size_t __sr2,
155 uint32_t __msk1, uint32_t __msk2,
156 uint32_t __msk3, uint32_t __msk4,
157 uint32_t __parity1, uint32_t __parity2,
158 uint32_t __parity3, uint32_t __parity4>
159 void simd_fast_mersenne_twister_engine<_UIntType, __m,
160 __pos1, __sl1, __sl2, __sr1, __sr2,
161 __msk1, __msk2, __msk3, __msk4,
162 __parity1, __parity2, __parity3,
163 __parity4>::
164 _M_period_certification(void)
165 {
166 static const uint32_t __parity[4] = { __parity1, __parity2,
167 __parity3, __parity4 };
168 uint32_t __inner = 0;
169 for (size_t __i = 0; __i < 4; ++__i)
170 if (__parity[__i] != 0)
171 __inner ^= _M_state32[__i] & __parity[__i];
172
173 if (__builtin_parity(__inner) & 1)
174 return;
175 for (size_t __i = 0; __i < 4; ++__i)
176 if (__parity[__i] != 0)
177 {
178 _M_state32[__i] ^= 1 << (__builtin_ffs(__parity[__i]) - 1);
179 return;
180 }
181 __builtin_unreachable();
182 }
183
184
185 template<typename _UIntType, size_t __m,
186 size_t __pos1, size_t __sl1, size_t __sl2,
187 size_t __sr1, size_t __sr2,
188 uint32_t __msk1, uint32_t __msk2,
189 uint32_t __msk3, uint32_t __msk4,
190 uint32_t __parity1, uint32_t __parity2,
191 uint32_t __parity3, uint32_t __parity4>
192 void simd_fast_mersenne_twister_engine<_UIntType, __m,
193 __pos1, __sl1, __sl2, __sr1, __sr2,
194 __msk1, __msk2, __msk3, __msk4,
195 __parity1, __parity2, __parity3,
196 __parity4>::
197 discard(unsigned long long __z)
198 {
199 while (__z > state_size - _M_pos)
200 {
201 __z -= state_size - _M_pos;
202
203 _M_gen_rand();
204 }
205
206 _M_pos += __z;
207 }
208
209
210#ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_GEN_READ
211
212 namespace {
213
214 template<size_t __shift>
215 inline void __rshift(uint32_t *__out, const uint32_t *__in)
216 {
217 uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
218 | static_cast<uint64_t>(__in[2]));
219 uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
220 | static_cast<uint64_t>(__in[0]));
221
222 uint64_t __oh = __th >> (__shift * 8);
223 uint64_t __ol = __tl >> (__shift * 8);
224 __ol |= __th << (64 - __shift * 8);
225 __out[1] = static_cast<uint32_t>(__ol >> 32);
226 __out[0] = static_cast<uint32_t>(__ol);
227 __out[3] = static_cast<uint32_t>(__oh >> 32);
228 __out[2] = static_cast<uint32_t>(__oh);
229 }
230
231
232 template<size_t __shift>
233 inline void __lshift(uint32_t *__out, const uint32_t *__in)
234 {
235 uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32)
236 | static_cast<uint64_t>(__in[2]));
237 uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32)
238 | static_cast<uint64_t>(__in[0]));
239
240 uint64_t __oh = __th << (__shift * 8);
241 uint64_t __ol = __tl << (__shift * 8);
242 __oh |= __tl >> (64 - __shift * 8);
243 __out[1] = static_cast<uint32_t>(__ol >> 32);
244 __out[0] = static_cast<uint32_t>(__ol);
245 __out[3] = static_cast<uint32_t>(__oh >> 32);
246 __out[2] = static_cast<uint32_t>(__oh);
247 }
248
249
250 template<size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2,
251 uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4>
252 inline void __recursion(uint32_t *__r,
253 const uint32_t *__a, const uint32_t *__b,
254 const uint32_t *__c, const uint32_t *__d)
255 {
256 uint32_t __x[4];
257 uint32_t __y[4];
258
259 __lshift<__sl2>(__x, __a);
260 __rshift<__sr2>(__y, __c);
261 __r[0] = (__a[0] ^ __x[0] ^ ((__b[0] >> __sr1) & __msk1)
262 ^ __y[0] ^ (__d[0] << __sl1));
263 __r[1] = (__a[1] ^ __x[1] ^ ((__b[1] >> __sr1) & __msk2)
264 ^ __y[1] ^ (__d[1] << __sl1));
265 __r[2] = (__a[2] ^ __x[2] ^ ((__b[2] >> __sr1) & __msk3)
266 ^ __y[2] ^ (__d[2] << __sl1));
267 __r[3] = (__a[3] ^ __x[3] ^ ((__b[3] >> __sr1) & __msk4)
268 ^ __y[3] ^ (__d[3] << __sl1));
269 }
270
271 }
272
273
274 template<typename _UIntType, size_t __m,
275 size_t __pos1, size_t __sl1, size_t __sl2,
276 size_t __sr1, size_t __sr2,
277 uint32_t __msk1, uint32_t __msk2,
278 uint32_t __msk3, uint32_t __msk4,
279 uint32_t __parity1, uint32_t __parity2,
280 uint32_t __parity3, uint32_t __parity4>
281 void simd_fast_mersenne_twister_engine<_UIntType, __m,
282 __pos1, __sl1, __sl2, __sr1, __sr2,
283 __msk1, __msk2, __msk3, __msk4,
284 __parity1, __parity2, __parity3,
285 __parity4>::
286 _M_gen_rand(void)
287 {
288 const uint32_t *__r1 = &_M_state32[_M_nstate32 - 8];
289 const uint32_t *__r2 = &_M_state32[_M_nstate32 - 4];
290 static constexpr size_t __pos1_32 = __pos1 * 4;
291
292 size_t __i;
293 for (__i = 0; __i < _M_nstate32 - __pos1_32; __i += 4)
294 {
295 __recursion<__sl1, __sl2, __sr1, __sr2,
296 __msk1, __msk2, __msk3, __msk4>
297 (&_M_state32[__i], &_M_state32[__i],
298 &_M_state32[__i + __pos1_32], __r1, __r2);
299 __r1 = __r2;
300 __r2 = &_M_state32[__i];
301 }
302
303 for (; __i < _M_nstate32; __i += 4)
304 {
305 __recursion<__sl1, __sl2, __sr1, __sr2,
306 __msk1, __msk2, __msk3, __msk4>
307 (&_M_state32[__i], &_M_state32[__i],
308 &_M_state32[__i + __pos1_32 - _M_nstate32], __r1, __r2);
309 __r1 = __r2;
310 __r2 = &_M_state32[__i];
311 }
312
313 _M_pos = 0;
314 }
315
316#endif
317
318#ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_OPERATOREQUAL
319 template<typename _UIntType, size_t __m,
320 size_t __pos1, size_t __sl1, size_t __sl2,
321 size_t __sr1, size_t __sr2,
322 uint32_t __msk1, uint32_t __msk2,
323 uint32_t __msk3, uint32_t __msk4,
324 uint32_t __parity1, uint32_t __parity2,
325 uint32_t __parity3, uint32_t __parity4>
326 bool
327 operator==(const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
328 __m, __pos1, __sl1, __sl2, __sr1, __sr2,
329 __msk1, __msk2, __msk3, __msk4,
330 __parity1, __parity2, __parity3, __parity4>& __lhs,
331 const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
332 __m, __pos1, __sl1, __sl2, __sr1, __sr2,
333 __msk1, __msk2, __msk3, __msk4,
334 __parity1, __parity2, __parity3, __parity4>& __rhs)
335 {
336 typedef __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
337 __m, __pos1, __sl1, __sl2, __sr1, __sr2,
338 __msk1, __msk2, __msk3, __msk4,
339 __parity1, __parity2, __parity3, __parity4> __engine;
340 return (std::equal(__lhs._M_stateT,
341 __lhs._M_stateT + __engine::state_size,
342 __rhs._M_stateT)
343 && __lhs._M_pos == __rhs._M_pos);
344 }
345#endif
346
347 template<typename _UIntType, size_t __m,
348 size_t __pos1, size_t __sl1, size_t __sl2,
349 size_t __sr1, size_t __sr2,
350 uint32_t __msk1, uint32_t __msk2,
351 uint32_t __msk3, uint32_t __msk4,
352 uint32_t __parity1, uint32_t __parity2,
353 uint32_t __parity3, uint32_t __parity4,
354 typename _CharT, typename _Traits>
355 std::basic_ostream<_CharT, _Traits>&
356 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
357 const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
358 __m, __pos1, __sl1, __sl2, __sr1, __sr2,
359 __msk1, __msk2, __msk3, __msk4,
360 __parity1, __parity2, __parity3, __parity4>& __x)
361 {
362 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
363 typedef typename __ostream_type::ios_base __ios_base;
364
365 const typename __ios_base::fmtflags __flags = __os.flags();
366 const _CharT __fill = __os.fill();
367 const _CharT __space = __os.widen(' ');
368 __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);
369 __os.fill(__space);
370
371 for (size_t __i = 0; __i < __x._M_nstate32; ++__i)
372 __os << __x._M_state32[__i] << __space;
373 __os << __x._M_pos;
374
375 __os.flags(__flags);
376 __os.fill(__fill);
377 return __os;
378 }
379
380
381 template<typename _UIntType, size_t __m,
382 size_t __pos1, size_t __sl1, size_t __sl2,
383 size_t __sr1, size_t __sr2,
384 uint32_t __msk1, uint32_t __msk2,
385 uint32_t __msk3, uint32_t __msk4,
386 uint32_t __parity1, uint32_t __parity2,
387 uint32_t __parity3, uint32_t __parity4,
388 typename _CharT, typename _Traits>
389 std::basic_istream<_CharT, _Traits>&
390 operator>>(std::basic_istream<_CharT, _Traits>& __is,
391 __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,
392 __m, __pos1, __sl1, __sl2, __sr1, __sr2,
393 __msk1, __msk2, __msk3, __msk4,
394 __parity1, __parity2, __parity3, __parity4>& __x)
395 {
396 typedef std::basic_istream<_CharT, _Traits> __istream_type;
397 typedef typename __istream_type::ios_base __ios_base;
398
399 const typename __ios_base::fmtflags __flags = __is.flags();
400 __is.flags(__ios_base::dec | __ios_base::skipws);
401
402 for (size_t __i = 0; __i < __x._M_nstate32; ++__i)
403 __is >> __x._M_state32[__i];
404 __is >> __x._M_pos;
405
406 __is.flags(__flags);
407 return __is;
408 }
409
410#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
411
412 /**
413 * Iteration method due to M.D. J<o:>hnk.
414 *
415 * M.D. J<o:>hnk, Erzeugung von betaverteilten und gammaverteilten
416 * Zufallszahlen, Metrika, Volume 8, 1964
417 */
418 template<typename _RealType>
419 template<typename _UniformRandomNumberGenerator>
420 typename beta_distribution<_RealType>::result_type
421 beta_distribution<_RealType>::
422 operator()(_UniformRandomNumberGenerator& __urng,
423 const param_type& __param)
424 {
425 std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
426 __aurng(__urng);
427
428 result_type __x, __y;
429 do
430 {
431 __x = std::exp(std::log(__aurng()) / __param.alpha());
432 __y = std::exp(std::log(__aurng()) / __param.beta());
433 }
434 while (__x + __y > result_type(1));
435
436 return __x / (__x + __y);
437 }
438
439 template<typename _RealType>
440 template<typename _OutputIterator,
441 typename _UniformRandomNumberGenerator>
442 void
443 beta_distribution<_RealType>::
444 __generate_impl(_OutputIterator __f, _OutputIterator __t,
445 _UniformRandomNumberGenerator& __urng,
446 const param_type& __param)
447 {
448 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
449 result_type>)
450
451 std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
452 __aurng(__urng);
453
454 while (__f != __t)
455 {
456 result_type __x, __y;
457 do
458 {
459 __x = std::exp(std::log(__aurng()) / __param.alpha());
460 __y = std::exp(std::log(__aurng()) / __param.beta());
461 }
462 while (__x + __y > result_type(1));
463
464 *__f++ = __x / (__x + __y);
465 }
466 }
467
468 template<typename _RealType, typename _CharT, typename _Traits>
469 std::basic_ostream<_CharT, _Traits>&
470 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
471 const __gnu_cxx::beta_distribution<_RealType>& __x)
472 {
473 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
474 typedef typename __ostream_type::ios_base __ios_base;
475
476 const typename __ios_base::fmtflags __flags = __os.flags();
477 const _CharT __fill = __os.fill();
478 const std::streamsize __precision = __os.precision();
479 const _CharT __space = __os.widen(' ');
480 __os.flags(__ios_base::scientific | __ios_base::left);
481 __os.fill(__space);
482 __os.precision(std::numeric_limits<_RealType>::max_digits10);
483
484 __os << __x.alpha() << __space << __x.beta();
485
486 __os.flags(__flags);
487 __os.fill(__fill);
488 __os.precision(__precision);
489 return __os;
490 }
491
492 template<typename _RealType, typename _CharT, typename _Traits>
493 std::basic_istream<_CharT, _Traits>&
494 operator>>(std::basic_istream<_CharT, _Traits>& __is,
495 __gnu_cxx::beta_distribution<_RealType>& __x)
496 {
497 typedef std::basic_istream<_CharT, _Traits> __istream_type;
498 typedef typename __istream_type::ios_base __ios_base;
499
500 const typename __ios_base::fmtflags __flags = __is.flags();
501 __is.flags(__ios_base::dec | __ios_base::skipws);
502
503 _RealType __alpha_val, __beta_val;
504 __is >> __alpha_val >> __beta_val;
505 __x.param(typename __gnu_cxx::beta_distribution<_RealType>::
506 param_type(__alpha_val, __beta_val));
507
508 __is.flags(__flags);
509 return __is;
510 }
511
512
513 template<std::size_t _Dimen, typename _RealType>
514 template<typename _InputIterator1, typename _InputIterator2>
515 void
516 normal_mv_distribution<_Dimen, _RealType>::param_type::
517 _M_init_full(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
518 _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
519 {
520 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
521 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
522 std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
523 _M_mean.end(), _RealType(0));
524
525 // Perform the Cholesky decomposition
526 auto __w = _M_t.begin();
527 for (size_t __j = 0; __j < _Dimen; ++__j)
528 {
529 _RealType __sum = _RealType(0);
530
531 auto __slitbegin = __w;
532 auto __cit = _M_t.begin();
533 for (size_t __i = 0; __i < __j; ++__i)
534 {
535 auto __slit = __slitbegin;
536 _RealType __s = *__varcovbegin++;
537 for (size_t __k = 0; __k < __i; ++__k)
538 __s -= *__slit++ * *__cit++;
539
540 *__w++ = __s /= *__cit++;
541 __sum += __s * __s;
542 }
543
544 __sum = *__varcovbegin - __sum;
545 if (__builtin_expect(__sum <= _RealType(0), 0))
546 std::__throw_runtime_error(__N("normal_mv_distribution::"
547 "param_type::_M_init_full"));
548 *__w++ = std::sqrt(__sum);
549
550 std::advance(__varcovbegin, _Dimen - __j);
551 }
552 }
553
554 template<std::size_t _Dimen, typename _RealType>
555 template<typename _InputIterator1, typename _InputIterator2>
556 void
557 normal_mv_distribution<_Dimen, _RealType>::param_type::
558 _M_init_lower(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
559 _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
560 {
561 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
562 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
563 std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
564 _M_mean.end(), _RealType(0));
565
566 // Perform the Cholesky decomposition
567 auto __w = _M_t.begin();
568 for (size_t __j = 0; __j < _Dimen; ++__j)
569 {
570 _RealType __sum = _RealType(0);
571
572 auto __slitbegin = __w;
573 auto __cit = _M_t.begin();
574 for (size_t __i = 0; __i < __j; ++__i)
575 {
576 auto __slit = __slitbegin;
577 _RealType __s = *__varcovbegin++;
578 for (size_t __k = 0; __k < __i; ++__k)
579 __s -= *__slit++ * *__cit++;
580
581 *__w++ = __s /= *__cit++;
582 __sum += __s * __s;
583 }
584
585 __sum = *__varcovbegin++ - __sum;
586 if (__builtin_expect(__sum <= _RealType(0), 0))
587 std::__throw_runtime_error(__N("normal_mv_distribution::"
588 "param_type::_M_init_lower"));
589 *__w++ = std::sqrt(__sum);
590 }
591 }
592
593 template<std::size_t _Dimen, typename _RealType>
594 template<typename _InputIterator1, typename _InputIterator2>
595 void
596 normal_mv_distribution<_Dimen, _RealType>::param_type::
597 _M_init_diagonal(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
598 _InputIterator2 __varbegin, _InputIterator2 __varend)
599 {
600 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)
601 __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)
602 std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),
603 _M_mean.end(), _RealType(0));
604
605 auto __w = _M_t.begin();
606 size_t __step = 0;
607 while (__varbegin != __varend)
608 {
609 std::fill_n(__w, __step, _RealType(0));
610 __w += __step++;
611 if (__builtin_expect(*__varbegin < _RealType(0), 0))
612 std::__throw_runtime_error(__N("normal_mv_distribution::"
613 "param_type::_M_init_diagonal"));
614 *__w++ = std::sqrt(*__varbegin++);
615 }
616 }
617
618 template<std::size_t _Dimen, typename _RealType>
619 template<typename _UniformRandomNumberGenerator>
620 typename normal_mv_distribution<_Dimen, _RealType>::result_type
621 normal_mv_distribution<_Dimen, _RealType>::
622 operator()(_UniformRandomNumberGenerator& __urng,
623 const param_type& __param)
624 {
625 result_type __ret;
626
627 _M_nd.__generate(__ret.begin(), __ret.end(), __urng);
628
629 auto __t_it = __param._M_t.crbegin();
630 for (size_t __i = _Dimen; __i > 0; --__i)
631 {
632 _RealType __sum = _RealType(0);
633 for (size_t __j = __i; __j > 0; --__j)
634 __sum += __ret[__j - 1] * *__t_it++;
635 __ret[__i - 1] = __sum;
636 }
637
638 return __ret;
639 }
640
641 template<std::size_t _Dimen, typename _RealType>
642 template<typename _ForwardIterator, typename _UniformRandomNumberGenerator>
643 void
644 normal_mv_distribution<_Dimen, _RealType>::
645 __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
646 _UniformRandomNumberGenerator& __urng,
647 const param_type& __param)
648 {
649 __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<
650 _ForwardIterator>)
651 while (__f != __t)
652 *__f++ = this->operator()(__urng, __param);
653 }
654
655 template<size_t _Dimen, typename _RealType>
656 bool
657 operator==(const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
658 __d1,
659 const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&
660 __d2)
661 {
662 return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd;
663 }
664
665 template<size_t _Dimen, typename _RealType, typename _CharT, typename _Traits>
666 std::basic_ostream<_CharT, _Traits>&
667 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
668 const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)
669 {
670 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
671 typedef typename __ostream_type::ios_base __ios_base;
672
673 const typename __ios_base::fmtflags __flags = __os.flags();
674 const _CharT __fill = __os.fill();
675 const std::streamsize __precision = __os.precision();
676 const _CharT __space = __os.widen(' ');
677 __os.flags(__ios_base::scientific | __ios_base::left);
678 __os.fill(__space);
679 __os.precision(std::numeric_limits<_RealType>::max_digits10);
680
681 auto __mean = __x._M_param.mean();
682 for (auto __it : __mean)
683 __os << __it << __space;
684 auto __t = __x._M_param.varcov();
685 for (auto __it : __t)
686 __os << __it << __space;
687
688 __os << __x._M_nd;
689
690 __os.flags(__flags);
691 __os.fill(__fill);
692 __os.precision(__precision);
693 return __os;
694 }
695
696 template<size_t _Dimen, typename _RealType, typename _CharT, typename _Traits>
697 std::basic_istream<_CharT, _Traits>&
698 operator>>(std::basic_istream<_CharT, _Traits>& __is,
699 __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)
700 {
701 typedef std::basic_istream<_CharT, _Traits> __istream_type;
702 typedef typename __istream_type::ios_base __ios_base;
703
704 const typename __ios_base::fmtflags __flags = __is.flags();
705 __is.flags(__ios_base::dec | __ios_base::skipws);
706
707 std::array<_RealType, _Dimen> __mean;
708 for (auto& __it : __mean)
709 __is >> __it;
710 std::array<_RealType, _Dimen * (_Dimen + 1) / 2> __varcov;
711 for (auto& __it : __varcov)
712 __is >> __it;
713
714 __is >> __x._M_nd;
715
716 // The param_type temporary is built with a private constructor,
717 // to skip the Cholesky decomposition that would be performed
718 // otherwise.
719 __x.param(typename normal_mv_distribution<_Dimen, _RealType>::
720 param_type(__mean, __varcov));
721
722 __is.flags(__flags);
723 return __is;
724 }
725
726
727 template<typename _RealType>
728 template<typename _OutputIterator,
729 typename _UniformRandomNumberGenerator>
730 void
731 rice_distribution<_RealType>::
732 __generate_impl(_OutputIterator __f, _OutputIterator __t,
733 _UniformRandomNumberGenerator& __urng,
734 const param_type& __p)
735 {
736 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
737 result_type>)
738
739 while (__f != __t)
740 {
741 typename std::normal_distribution<result_type>::param_type
742 __px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());
743 result_type __x = this->_M_ndx(__px, __urng);
744 result_type __y = this->_M_ndy(__py, __urng);
745#if _GLIBCXX_USE_C99_MATH_FUNCS
746 *__f++ = std::hypot(__x, __y);
747#else
748 *__f++ = std::sqrt(__x * __x + __y * __y);
749#endif
750 }
751 }
752
753 template<typename _RealType, typename _CharT, typename _Traits>
754 std::basic_ostream<_CharT, _Traits>&
755 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
756 const rice_distribution<_RealType>& __x)
757 {
758 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
759 typedef typename __ostream_type::ios_base __ios_base;
760
761 const typename __ios_base::fmtflags __flags = __os.flags();
762 const _CharT __fill = __os.fill();
763 const std::streamsize __precision = __os.precision();
764 const _CharT __space = __os.widen(' ');
765 __os.flags(__ios_base::scientific | __ios_base::left);
766 __os.fill(__space);
767 __os.precision(std::numeric_limits<_RealType>::max_digits10);
768
769 __os << __x.nu() << __space << __x.sigma();
770 __os << __space << __x._M_ndx;
771 __os << __space << __x._M_ndy;
772
773 __os.flags(__flags);
774 __os.fill(__fill);
775 __os.precision(__precision);
776 return __os;
777 }
778
779 template<typename _RealType, typename _CharT, typename _Traits>
780 std::basic_istream<_CharT, _Traits>&
781 operator>>(std::basic_istream<_CharT, _Traits>& __is,
782 rice_distribution<_RealType>& __x)
783 {
784 typedef std::basic_istream<_CharT, _Traits> __istream_type;
785 typedef typename __istream_type::ios_base __ios_base;
786
787 const typename __ios_base::fmtflags __flags = __is.flags();
788 __is.flags(__ios_base::dec | __ios_base::skipws);
789
790 _RealType __nu_val, __sigma_val;
791 __is >> __nu_val >> __sigma_val;
792 __is >> __x._M_ndx;
793 __is >> __x._M_ndy;
794 __x.param(typename rice_distribution<_RealType>::
795 param_type(__nu_val, __sigma_val));
796
797 __is.flags(__flags);
798 return __is;
799 }
800
801
802 template<typename _RealType>
803 template<typename _OutputIterator,
804 typename _UniformRandomNumberGenerator>
805 void
806 nakagami_distribution<_RealType>::
807 __generate_impl(_OutputIterator __f, _OutputIterator __t,
808 _UniformRandomNumberGenerator& __urng,
809 const param_type& __p)
810 {
811 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
812 result_type>)
813
814 typename std::gamma_distribution<result_type>::param_type
815 __pg(__p.mu(), __p.omega() / __p.mu());
816 while (__f != __t)
817 *__f++ = std::sqrt(this->_M_gd(__pg, __urng));
818 }
819
820 template<typename _RealType, typename _CharT, typename _Traits>
821 std::basic_ostream<_CharT, _Traits>&
822 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
823 const nakagami_distribution<_RealType>& __x)
824 {
825 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
826 typedef typename __ostream_type::ios_base __ios_base;
827
828 const typename __ios_base::fmtflags __flags = __os.flags();
829 const _CharT __fill = __os.fill();
830 const std::streamsize __precision = __os.precision();
831 const _CharT __space = __os.widen(' ');
832 __os.flags(__ios_base::scientific | __ios_base::left);
833 __os.fill(__space);
834 __os.precision(std::numeric_limits<_RealType>::max_digits10);
835
836 __os << __x.mu() << __space << __x.omega();
837 __os << __space << __x._M_gd;
838
839 __os.flags(__flags);
840 __os.fill(__fill);
841 __os.precision(__precision);
842 return __os;
843 }
844
845 template<typename _RealType, typename _CharT, typename _Traits>
846 std::basic_istream<_CharT, _Traits>&
847 operator>>(std::basic_istream<_CharT, _Traits>& __is,
848 nakagami_distribution<_RealType>& __x)
849 {
850 typedef std::basic_istream<_CharT, _Traits> __istream_type;
851 typedef typename __istream_type::ios_base __ios_base;
852
853 const typename __ios_base::fmtflags __flags = __is.flags();
854 __is.flags(__ios_base::dec | __ios_base::skipws);
855
856 _RealType __mu_val, __omega_val;
857 __is >> __mu_val >> __omega_val;
858 __is >> __x._M_gd;
859 __x.param(typename nakagami_distribution<_RealType>::
860 param_type(__mu_val, __omega_val));
861
862 __is.flags(__flags);
863 return __is;
864 }
865
866
867 template<typename _RealType>
868 template<typename _OutputIterator,
869 typename _UniformRandomNumberGenerator>
870 void
871 pareto_distribution<_RealType>::
872 __generate_impl(_OutputIterator __f, _OutputIterator __t,
873 _UniformRandomNumberGenerator& __urng,
874 const param_type& __p)
875 {
876 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
877 result_type>)
878
879 result_type __mu_val = __p.mu();
880 result_type __malphinv = -result_type(1) / __p.alpha();
881 while (__f != __t)
882 *__f++ = __mu_val * std::pow(this->_M_ud(__urng), __malphinv);
883 }
884
885 template<typename _RealType, typename _CharT, typename _Traits>
886 std::basic_ostream<_CharT, _Traits>&
887 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
888 const pareto_distribution<_RealType>& __x)
889 {
890 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
891 typedef typename __ostream_type::ios_base __ios_base;
892
893 const typename __ios_base::fmtflags __flags = __os.flags();
894 const _CharT __fill = __os.fill();
895 const std::streamsize __precision = __os.precision();
896 const _CharT __space = __os.widen(' ');
897 __os.flags(__ios_base::scientific | __ios_base::left);
898 __os.fill(__space);
899 __os.precision(std::numeric_limits<_RealType>::max_digits10);
900
901 __os << __x.alpha() << __space << __x.mu();
902 __os << __space << __x._M_ud;
903
904 __os.flags(__flags);
905 __os.fill(__fill);
906 __os.precision(__precision);
907 return __os;
908 }
909
910 template<typename _RealType, typename _CharT, typename _Traits>
911 std::basic_istream<_CharT, _Traits>&
912 operator>>(std::basic_istream<_CharT, _Traits>& __is,
913 pareto_distribution<_RealType>& __x)
914 {
915 typedef std::basic_istream<_CharT, _Traits> __istream_type;
916 typedef typename __istream_type::ios_base __ios_base;
917
918 const typename __ios_base::fmtflags __flags = __is.flags();
919 __is.flags(__ios_base::dec | __ios_base::skipws);
920
921 _RealType __alpha_val, __mu_val;
922 __is >> __alpha_val >> __mu_val;
923 __is >> __x._M_ud;
924 __x.param(typename pareto_distribution<_RealType>::
925 param_type(__alpha_val, __mu_val));
926
927 __is.flags(__flags);
928 return __is;
929 }
930
931
932 template<typename _RealType>
933 template<typename _UniformRandomNumberGenerator>
934 typename k_distribution<_RealType>::result_type
935 k_distribution<_RealType>::
936 operator()(_UniformRandomNumberGenerator& __urng)
937 {
938 result_type __x = this->_M_gd1(__urng);
939 result_type __y = this->_M_gd2(__urng);
940 return std::sqrt(__x * __y);
941 }
942
943 template<typename _RealType>
944 template<typename _UniformRandomNumberGenerator>
945 typename k_distribution<_RealType>::result_type
946 k_distribution<_RealType>::
947 operator()(_UniformRandomNumberGenerator& __urng,
948 const param_type& __p)
949 {
950 typename std::gamma_distribution<result_type>::param_type
951 __p1(__p.lambda(), result_type(1) / __p.lambda()),
952 __p2(__p.nu(), __p.mu() / __p.nu());
953 result_type __x = this->_M_gd1(__p1, __urng);
954 result_type __y = this->_M_gd2(__p2, __urng);
955 return std::sqrt(__x * __y);
956 }
957
958 template<typename _RealType>
959 template<typename _OutputIterator,
960 typename _UniformRandomNumberGenerator>
961 void
962 k_distribution<_RealType>::
963 __generate_impl(_OutputIterator __f, _OutputIterator __t,
964 _UniformRandomNumberGenerator& __urng,
965 const param_type& __p)
966 {
967 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
968 result_type>)
969
970 typename std::gamma_distribution<result_type>::param_type
971 __p1(__p.lambda(), result_type(1) / __p.lambda()),
972 __p2(__p.nu(), __p.mu() / __p.nu());
973 while (__f != __t)
974 {
975 result_type __x = this->_M_gd1(__p1, __urng);
976 result_type __y = this->_M_gd2(__p2, __urng);
977 *__f++ = std::sqrt(__x * __y);
978 }
979 }
980
981 template<typename _RealType, typename _CharT, typename _Traits>
982 std::basic_ostream<_CharT, _Traits>&
983 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
984 const k_distribution<_RealType>& __x)
985 {
986 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
987 typedef typename __ostream_type::ios_base __ios_base;
988
989 const typename __ios_base::fmtflags __flags = __os.flags();
990 const _CharT __fill = __os.fill();
991 const std::streamsize __precision = __os.precision();
992 const _CharT __space = __os.widen(' ');
993 __os.flags(__ios_base::scientific | __ios_base::left);
994 __os.fill(__space);
995 __os.precision(std::numeric_limits<_RealType>::max_digits10);
996
997 __os << __x.lambda() << __space << __x.mu() << __space << __x.nu();
998 __os << __space << __x._M_gd1;
999 __os << __space << __x._M_gd2;
1000
1001 __os.flags(__flags);
1002 __os.fill(__fill);
1003 __os.precision(__precision);
1004 return __os;
1005 }
1006
1007 template<typename _RealType, typename _CharT, typename _Traits>
1008 std::basic_istream<_CharT, _Traits>&
1009 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1010 k_distribution<_RealType>& __x)
1011 {
1012 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1013 typedef typename __istream_type::ios_base __ios_base;
1014
1015 const typename __ios_base::fmtflags __flags = __is.flags();
1016 __is.flags(__ios_base::dec | __ios_base::skipws);
1017
1018 _RealType __lambda_val, __mu_val, __nu_val;
1019 __is >> __lambda_val >> __mu_val >> __nu_val;
1020 __is >> __x._M_gd1;
1021 __is >> __x._M_gd2;
1022 __x.param(typename k_distribution<_RealType>::
1023 param_type(__lambda_val, __mu_val, __nu_val));
1024
1025 __is.flags(__flags);
1026 return __is;
1027 }
1028
1029
1030 template<typename _RealType>
1031 template<typename _OutputIterator,
1032 typename _UniformRandomNumberGenerator>
1033 void
1034 arcsine_distribution<_RealType>::
1035 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1036 _UniformRandomNumberGenerator& __urng,
1037 const param_type& __p)
1038 {
1039 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1040 result_type>)
1041
1042 result_type __dif = __p.b() - __p.a();
1043 result_type __sum = __p.a() + __p.b();
1044 while (__f != __t)
1045 {
1046 result_type __x = std::sin(this->_M_ud(__urng));
1047 *__f++ = (__x * __dif + __sum) / result_type(2);
1048 }
1049 }
1050
1051 template<typename _RealType, typename _CharT, typename _Traits>
1052 std::basic_ostream<_CharT, _Traits>&
1053 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1054 const arcsine_distribution<_RealType>& __x)
1055 {
1056 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
1057 typedef typename __ostream_type::ios_base __ios_base;
1058
1059 const typename __ios_base::fmtflags __flags = __os.flags();
1060 const _CharT __fill = __os.fill();
1061 const std::streamsize __precision = __os.precision();
1062 const _CharT __space = __os.widen(' ');
1063 __os.flags(__ios_base::scientific | __ios_base::left);
1064 __os.fill(__space);
1065 __os.precision(std::numeric_limits<_RealType>::max_digits10);
1066
1067 __os << __x.a() << __space << __x.b();
1068 __os << __space << __x._M_ud;
1069
1070 __os.flags(__flags);
1071 __os.fill(__fill);
1072 __os.precision(__precision);
1073 return __os;
1074 }
1075
1076 template<typename _RealType, typename _CharT, typename _Traits>
1077 std::basic_istream<_CharT, _Traits>&
1078 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1079 arcsine_distribution<_RealType>& __x)
1080 {
1081 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1082 typedef typename __istream_type::ios_base __ios_base;
1083
1084 const typename __ios_base::fmtflags __flags = __is.flags();
1085 __is.flags(__ios_base::dec | __ios_base::skipws);
1086
1087 _RealType __a, __b;
1088 __is >> __a >> __b;
1089 __is >> __x._M_ud;
1090 __x.param(typename arcsine_distribution<_RealType>::
1091 param_type(__a, __b));
1092
1093 __is.flags(__flags);
1094 return __is;
1095 }
1096
1097
1098 template<typename _RealType>
1099 template<typename _UniformRandomNumberGenerator>
1100 typename hoyt_distribution<_RealType>::result_type
1101 hoyt_distribution<_RealType>::
1102 operator()(_UniformRandomNumberGenerator& __urng)
1103 {
1104 result_type __x = this->_M_ad(__urng);
1105 result_type __y = this->_M_ed(__urng);
1106 return (result_type(2) * this->q()
1107 / (result_type(1) + this->q() * this->q()))
1108 * std::sqrt(this->omega() * __x * __y);
1109 }
1110
1111 template<typename _RealType>
1112 template<typename _UniformRandomNumberGenerator>
1113 typename hoyt_distribution<_RealType>::result_type
1114 hoyt_distribution<_RealType>::
1115 operator()(_UniformRandomNumberGenerator& __urng,
1116 const param_type& __p)
1117 {
1118 result_type __q2 = __p.q() * __p.q();
1119 result_type __num = result_type(0.5L) * (result_type(1) + __q2);
1120 typename __gnu_cxx::arcsine_distribution<result_type>::param_type
1121 __pa(__num, __num / __q2);
1122 result_type __x = this->_M_ad(__pa, __urng);
1123 result_type __y = this->_M_ed(__urng);
1124 return (result_type(2) * __p.q() / (result_type(1) + __q2))
1125 * std::sqrt(__p.omega() * __x * __y);
1126 }
1127
1128 template<typename _RealType>
1129 template<typename _OutputIterator,
1130 typename _UniformRandomNumberGenerator>
1131 void
1132 hoyt_distribution<_RealType>::
1133 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1134 _UniformRandomNumberGenerator& __urng,
1135 const param_type& __p)
1136 {
1137 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1138 result_type>)
1139
1140 result_type __2q = result_type(2) * __p.q();
1141 result_type __q2 = __p.q() * __p.q();
1142 result_type __q2p1 = result_type(1) + __q2;
1143 result_type __num = result_type(0.5L) * __q2p1;
1144 result_type __omega = __p.omega();
1145 typename __gnu_cxx::arcsine_distribution<result_type>::param_type
1146 __pa(__num, __num / __q2);
1147 while (__f != __t)
1148 {
1149 result_type __x = this->_M_ad(__pa, __urng);
1150 result_type __y = this->_M_ed(__urng);
1151 *__f++ = (__2q / __q2p1) * std::sqrt(__omega * __x * __y);
1152 }
1153 }
1154
1155 template<typename _RealType, typename _CharT, typename _Traits>
1156 std::basic_ostream<_CharT, _Traits>&
1157 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1158 const hoyt_distribution<_RealType>& __x)
1159 {
1160 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
1161 typedef typename __ostream_type::ios_base __ios_base;
1162
1163 const typename __ios_base::fmtflags __flags = __os.flags();
1164 const _CharT __fill = __os.fill();
1165 const std::streamsize __precision = __os.precision();
1166 const _CharT __space = __os.widen(' ');
1167 __os.flags(__ios_base::scientific | __ios_base::left);
1168 __os.fill(__space);
1169 __os.precision(std::numeric_limits<_RealType>::max_digits10);
1170
1171 __os << __x.q() << __space << __x.omega();
1172 __os << __space << __x._M_ad;
1173 __os << __space << __x._M_ed;
1174
1175 __os.flags(__flags);
1176 __os.fill(__fill);
1177 __os.precision(__precision);
1178 return __os;
1179 }
1180
1181 template<typename _RealType, typename _CharT, typename _Traits>
1182 std::basic_istream<_CharT, _Traits>&
1183 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1184 hoyt_distribution<_RealType>& __x)
1185 {
1186 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1187 typedef typename __istream_type::ios_base __ios_base;
1188
1189 const typename __ios_base::fmtflags __flags = __is.flags();
1190 __is.flags(__ios_base::dec | __ios_base::skipws);
1191
1192 _RealType __q, __omega;
1193 __is >> __q >> __omega;
1194 __is >> __x._M_ad;
1195 __is >> __x._M_ed;
1196 __x.param(typename hoyt_distribution<_RealType>::
1197 param_type(__q, __omega));
1198
1199 __is.flags(__flags);
1200 return __is;
1201 }
1202
1203
1204 template<typename _RealType>
1205 template<typename _OutputIterator,
1206 typename _UniformRandomNumberGenerator>
1207 void
1208 triangular_distribution<_RealType>::
1209 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1210 _UniformRandomNumberGenerator& __urng,
1211 const param_type& __param)
1212 {
1213 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1214 result_type>)
1215
1216 while (__f != __t)
1217 *__f++ = this->operator()(__urng, __param);
1218 }
1219
1220 template<typename _RealType, typename _CharT, typename _Traits>
1221 std::basic_ostream<_CharT, _Traits>&
1222 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1223 const __gnu_cxx::triangular_distribution<_RealType>& __x)
1224 {
1225 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
1226 typedef typename __ostream_type::ios_base __ios_base;
1227
1228 const typename __ios_base::fmtflags __flags = __os.flags();
1229 const _CharT __fill = __os.fill();
1230 const std::streamsize __precision = __os.precision();
1231 const _CharT __space = __os.widen(' ');
1232 __os.flags(__ios_base::scientific | __ios_base::left);
1233 __os.fill(__space);
1234 __os.precision(std::numeric_limits<_RealType>::max_digits10);
1235
1236 __os << __x.a() << __space << __x.b() << __space << __x.c();
1237
1238 __os.flags(__flags);
1239 __os.fill(__fill);
1240 __os.precision(__precision);
1241 return __os;
1242 }
1243
1244 template<typename _RealType, typename _CharT, typename _Traits>
1245 std::basic_istream<_CharT, _Traits>&
1246 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1247 __gnu_cxx::triangular_distribution<_RealType>& __x)
1248 {
1249 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1250 typedef typename __istream_type::ios_base __ios_base;
1251
1252 const typename __ios_base::fmtflags __flags = __is.flags();
1253 __is.flags(__ios_base::dec | __ios_base::skipws);
1254
1255 _RealType __a, __b, __c;
1256 __is >> __a >> __b >> __c;
1257 __x.param(typename __gnu_cxx::triangular_distribution<_RealType>::
1258 param_type(__a, __b, __c));
1259
1260 __is.flags(__flags);
1261 return __is;
1262 }
1263
1264
1265 template<typename _RealType>
1266 template<typename _UniformRandomNumberGenerator>
1267 typename von_mises_distribution<_RealType>::result_type
1268 von_mises_distribution<_RealType>::
1269 operator()(_UniformRandomNumberGenerator& __urng,
1270 const param_type& __p)
1271 {
1272 const result_type __pi
1273 = __gnu_cxx::__math_constants<result_type>::__pi;
1274 std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1275 __aurng(__urng);
1276
1277 result_type __f;
1278 while (1)
1279 {
1280 result_type __rnd = std::cos(__pi * __aurng());
1281 __f = (result_type(1) + __p._M_r * __rnd) / (__p._M_r + __rnd);
1282 result_type __c = __p._M_kappa * (__p._M_r - __f);
1283
1284 result_type __rnd2 = __aurng();
1285 if (__c * (result_type(2) - __c) > __rnd2)
1286 break;
1287 if (std::log(__c / __rnd2) >= __c - result_type(1))
1288 break;
1289 }
1290
1291 result_type __res = std::acos(__f);
1292#if _GLIBCXX_USE_C99_MATH_FUNCS
1293 __res = std::copysign(__res, __aurng() - result_type(0.5));
1294#else
1295 if (__aurng() < result_type(0.5))
1296 __res = -__res;
1297#endif
1298 __res += __p._M_mu;
1299 if (__res > __pi)
1300 __res -= result_type(2) * __pi;
1301 else if (__res < -__pi)
1302 __res += result_type(2) * __pi;
1303 return __res;
1304 }
1305
1306 template<typename _RealType>
1307 template<typename _OutputIterator,
1308 typename _UniformRandomNumberGenerator>
1309 void
1310 von_mises_distribution<_RealType>::
1311 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1312 _UniformRandomNumberGenerator& __urng,
1313 const param_type& __param)
1314 {
1315 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1316 result_type>)
1317
1318 while (__f != __t)
1319 *__f++ = this->operator()(__urng, __param);
1320 }
1321
1322 template<typename _RealType, typename _CharT, typename _Traits>
1323 std::basic_ostream<_CharT, _Traits>&
1324 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1325 const __gnu_cxx::von_mises_distribution<_RealType>& __x)
1326 {
1327 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
1328 typedef typename __ostream_type::ios_base __ios_base;
1329
1330 const typename __ios_base::fmtflags __flags = __os.flags();
1331 const _CharT __fill = __os.fill();
1332 const std::streamsize __precision = __os.precision();
1333 const _CharT __space = __os.widen(' ');
1334 __os.flags(__ios_base::scientific | __ios_base::left);
1335 __os.fill(__space);
1336 __os.precision(std::numeric_limits<_RealType>::max_digits10);
1337
1338 __os << __x.mu() << __space << __x.kappa();
1339
1340 __os.flags(__flags);
1341 __os.fill(__fill);
1342 __os.precision(__precision);
1343 return __os;
1344 }
1345
1346 template<typename _RealType, typename _CharT, typename _Traits>
1347 std::basic_istream<_CharT, _Traits>&
1348 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1349 __gnu_cxx::von_mises_distribution<_RealType>& __x)
1350 {
1351 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1352 typedef typename __istream_type::ios_base __ios_base;
1353
1354 const typename __ios_base::fmtflags __flags = __is.flags();
1355 __is.flags(__ios_base::dec | __ios_base::skipws);
1356
1357 _RealType __mu, __kappa;
1358 __is >> __mu >> __kappa;
1359 __x.param(typename __gnu_cxx::von_mises_distribution<_RealType>::
1360 param_type(__mu, __kappa));
1361
1362 __is.flags(__flags);
1363 return __is;
1364 }
1365
1366
1367 template<typename _UIntType>
1368 template<typename _UniformRandomNumberGenerator>
1369 typename hypergeometric_distribution<_UIntType>::result_type
1370 hypergeometric_distribution<_UIntType>::
1371 operator()(_UniformRandomNumberGenerator& __urng,
1372 const param_type& __param)
1373 {
1374 std::__detail::_Adaptor<_UniformRandomNumberGenerator, double>
1375 __aurng(__urng);
1376
1377 result_type __a = __param.successful_size();
1378 result_type __b = __param.total_size();
1379 result_type __k = 0;
1380
1381 if (__param.total_draws() < __param.total_size() / 2)
1382 {
1383 for (result_type __i = 0; __i < __param.total_draws(); ++__i)
1384 {
1385 if (__b * __aurng() < __a)
1386 {
1387 ++__k;
1388 if (__k == __param.successful_size())
1389 return __k;
1390 --__a;
1391 }
1392 --__b;
1393 }
1394 return __k;
1395 }
1396 else
1397 {
1398 for (result_type __i = 0; __i < __param.unsuccessful_size(); ++__i)
1399 {
1400 if (__b * __aurng() < __a)
1401 {
1402 ++__k;
1403 if (__k == __param.successful_size())
1404 return __param.successful_size() - __k;
1405 --__a;
1406 }
1407 --__b;
1408 }
1409 return __param.successful_size() - __k;
1410 }
1411 }
1412
1413 template<typename _UIntType>
1414 template<typename _OutputIterator,
1415 typename _UniformRandomNumberGenerator>
1416 void
1417 hypergeometric_distribution<_UIntType>::
1418 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1419 _UniformRandomNumberGenerator& __urng,
1420 const param_type& __param)
1421 {
1422 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1423 result_type>)
1424
1425 while (__f != __t)
1426 *__f++ = this->operator()(__urng);
1427 }
1428
1429 template<typename _UIntType, typename _CharT, typename _Traits>
1430 std::basic_ostream<_CharT, _Traits>&
1431 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1432 const __gnu_cxx::hypergeometric_distribution<_UIntType>& __x)
1433 {
1434 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
1435 typedef typename __ostream_type::ios_base __ios_base;
1436
1437 const typename __ios_base::fmtflags __flags = __os.flags();
1438 const _CharT __fill = __os.fill();
1439 const std::streamsize __precision = __os.precision();
1440 const _CharT __space = __os.widen(' ');
1441 __os.flags(__ios_base::scientific | __ios_base::left);
1442 __os.fill(__space);
1443 __os.precision(std::numeric_limits<_UIntType>::max_digits10);
1444
1445 __os << __x.total_size() << __space << __x.successful_size() << __space
1446 << __x.total_draws();
1447
1448 __os.flags(__flags);
1449 __os.fill(__fill);
1450 __os.precision(__precision);
1451 return __os;
1452 }
1453
1454 template<typename _UIntType, typename _CharT, typename _Traits>
1455 std::basic_istream<_CharT, _Traits>&
1456 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1457 __gnu_cxx::hypergeometric_distribution<_UIntType>& __x)
1458 {
1459 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1460 typedef typename __istream_type::ios_base __ios_base;
1461
1462 const typename __ios_base::fmtflags __flags = __is.flags();
1463 __is.flags(__ios_base::dec | __ios_base::skipws);
1464
1465 _UIntType __total_size, __successful_size, __total_draws;
1466 __is >> __total_size >> __successful_size >> __total_draws;
1467 __x.param(typename __gnu_cxx::hypergeometric_distribution<_UIntType>::
1468 param_type(__total_size, __successful_size, __total_draws));
1469
1470 __is.flags(__flags);
1471 return __is;
1472 }
1473
1474
1475 template<typename _RealType>
1476 template<typename _UniformRandomNumberGenerator>
1477 typename logistic_distribution<_RealType>::result_type
1478 logistic_distribution<_RealType>::
1479 operator()(_UniformRandomNumberGenerator& __urng,
1480 const param_type& __p)
1481 {
1482 std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1483 __aurng(__urng);
1484
1485 result_type __arg = result_type(1);
1486 while (__arg == result_type(1) || __arg == result_type(0))
1487 __arg = __aurng();
1488 return __p.a()
1489 + __p.b() * std::log(__arg / (result_type(1) - __arg));
1490 }
1491
1492 template<typename _RealType>
1493 template<typename _OutputIterator,
1494 typename _UniformRandomNumberGenerator>
1495 void
1496 logistic_distribution<_RealType>::
1497 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1498 _UniformRandomNumberGenerator& __urng,
1499 const param_type& __p)
1500 {
1501 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1502 result_type>)
1503
1504 std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
1505 __aurng(__urng);
1506
1507 while (__f != __t)
1508 {
1509 result_type __arg = result_type(1);
1510 while (__arg == result_type(1) || __arg == result_type(0))
1511 __arg = __aurng();
1512 *__f++ = __p.a()
1513 + __p.b() * std::log(__arg / (result_type(1) - __arg));
1514 }
1515 }
1516
1517 template<typename _RealType, typename _CharT, typename _Traits>
1518 std::basic_ostream<_CharT, _Traits>&
1519 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1520 const logistic_distribution<_RealType>& __x)
1521 {
1522 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
1523 typedef typename __ostream_type::ios_base __ios_base;
1524
1525 const typename __ios_base::fmtflags __flags = __os.flags();
1526 const _CharT __fill = __os.fill();
1527 const std::streamsize __precision = __os.precision();
1528 const _CharT __space = __os.widen(' ');
1529 __os.flags(__ios_base::scientific | __ios_base::left);
1530 __os.fill(__space);
1531 __os.precision(std::numeric_limits<_RealType>::max_digits10);
1532
1533 __os << __x.a() << __space << __x.b();
1534
1535 __os.flags(__flags);
1536 __os.fill(__fill);
1537 __os.precision(__precision);
1538 return __os;
1539 }
1540
1541 template<typename _RealType, typename _CharT, typename _Traits>
1542 std::basic_istream<_CharT, _Traits>&
1543 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1544 logistic_distribution<_RealType>& __x)
1545 {
1546 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1547 typedef typename __istream_type::ios_base __ios_base;
1548
1549 const typename __ios_base::fmtflags __flags = __is.flags();
1550 __is.flags(__ios_base::dec | __ios_base::skipws);
1551
1552 _RealType __a, __b;
1553 __is >> __a >> __b;
1554 __x.param(typename logistic_distribution<_RealType>::
1555 param_type(__a, __b));
1556
1557 __is.flags(__flags);
1558 return __is;
1559 }
1560
1561
1562 namespace {
1563
1564 // Helper class for the uniform_on_sphere_distribution generation
1565 // function.
1566 template<std::size_t _Dimen, typename _RealType>
1567 class uniform_on_sphere_helper
1568 {
1569 typedef typename uniform_on_sphere_distribution<_Dimen, _RealType>::
1570 result_type result_type;
1571
1572 public:
1573 template<typename _NormalDistribution,
1574 typename _UniformRandomNumberGenerator>
1575 result_type operator()(_NormalDistribution& __nd,
1576 _UniformRandomNumberGenerator& __urng)
1577 {
1578 result_type __ret;
1579 typename result_type::value_type __norm;
1580
1581 do
1582 {
1583 auto __sum = _RealType(0);
1584
1585 std::generate(__ret.begin(), __ret.end(),
1586 [&__nd, &__urng, &__sum](){
1587 _RealType __t = __nd(__urng);
1588 __sum += __t * __t;
1589 return __t; });
1590 __norm = std::sqrt(__sum);
1591 }
1592 while (__norm == _RealType(0) || ! __builtin_isfinite(__norm));
1593
1594 std::transform(__ret.begin(), __ret.end(), __ret.begin(),
1595 [__norm](_RealType __val){ return __val / __norm; });
1596
1597 return __ret;
1598 }
1599 };
1600
1601
1602 template<typename _RealType>
1603 class uniform_on_sphere_helper<2, _RealType>
1604 {
1605 typedef typename uniform_on_sphere_distribution<2, _RealType>::
1606 result_type result_type;
1607
1608 public:
1609 template<typename _NormalDistribution,
1610 typename _UniformRandomNumberGenerator>
1611 result_type operator()(_NormalDistribution&,
1612 _UniformRandomNumberGenerator& __urng)
1613 {
1614 result_type __ret;
1615 _RealType __sq;
1616 std::__detail::_Adaptor<_UniformRandomNumberGenerator,
1617 _RealType> __aurng(__urng);
1618
1619 do
1620 {
1621 __ret[0] = _RealType(2) * __aurng() - _RealType(1);
1622 __ret[1] = _RealType(2) * __aurng() - _RealType(1);
1623
1624 __sq = __ret[0] * __ret[0] + __ret[1] * __ret[1];
1625 }
1626 while (__sq == _RealType(0) || __sq > _RealType(1));
1627
1628#if _GLIBCXX_USE_C99_MATH_FUNCS
1629 // Yes, we do not just use sqrt(__sq) because hypot() is more
1630 // accurate.
1631 auto __norm = std::hypot(__ret[0], __ret[1]);
1632#else
1633 auto __norm = std::sqrt(__sq);
1634#endif
1635 __ret[0] /= __norm;
1636 __ret[1] /= __norm;
1637
1638 return __ret;
1639 }
1640 };
1641
1642 }
1643
1644
1645 template<std::size_t _Dimen, typename _RealType>
1646 template<typename _UniformRandomNumberGenerator>
1647 typename uniform_on_sphere_distribution<_Dimen, _RealType>::result_type
1648 uniform_on_sphere_distribution<_Dimen, _RealType>::
1649 operator()(_UniformRandomNumberGenerator& __urng,
1650 const param_type& __p)
1651 {
1652 uniform_on_sphere_helper<_Dimen, _RealType> __helper;
1653 return __helper(_M_nd, __urng);
1654 }
1655
1656 template<std::size_t _Dimen, typename _RealType>
1657 template<typename _OutputIterator,
1658 typename _UniformRandomNumberGenerator>
1659 void
1660 uniform_on_sphere_distribution<_Dimen, _RealType>::
1661 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1662 _UniformRandomNumberGenerator& __urng,
1663 const param_type& __param)
1664 {
1665 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1666 result_type>)
1667
1668 while (__f != __t)
1669 *__f++ = this->operator()(__urng, __param);
1670 }
1671
1672 template<std::size_t _Dimen, typename _RealType, typename _CharT,
1673 typename _Traits>
1674 std::basic_ostream<_CharT, _Traits>&
1675 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1676 const __gnu_cxx::uniform_on_sphere_distribution<_Dimen,
1677 _RealType>& __x)
1678 {
1679 return __os << __x._M_nd;
1680 }
1681
1682 template<std::size_t _Dimen, typename _RealType, typename _CharT,
1683 typename _Traits>
1684 std::basic_istream<_CharT, _Traits>&
1685 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1686 __gnu_cxx::uniform_on_sphere_distribution<_Dimen,
1687 _RealType>& __x)
1688 {
1689 return __is >> __x._M_nd;
1690 }
1691
1692
1693 namespace {
1694
1695 // Helper class for the uniform_inside_sphere_distribution generation
1696 // function.
1697 template<std::size_t _Dimen, bool _SmallDimen, typename _RealType>
1698 class uniform_inside_sphere_helper;
1699
1700 template<std::size_t _Dimen, typename _RealType>
1701 class uniform_inside_sphere_helper<_Dimen, false, _RealType>
1702 {
1703 using result_type
1704 = typename uniform_inside_sphere_distribution<_Dimen, _RealType>::
1705 result_type;
1706
1707 public:
1708 template<typename _UniformOnSphereDistribution,
1709 typename _UniformRandomNumberGenerator>
1710 result_type
1711 operator()(_UniformOnSphereDistribution& __uosd,
1712 _UniformRandomNumberGenerator& __urng,
1713 _RealType __radius)
1714 {
1715 std::__detail::_Adaptor<_UniformRandomNumberGenerator,
1716 _RealType> __aurng(__urng);
1717
1718 _RealType __pow = 1 / _RealType(_Dimen);
1719 _RealType __urt = __radius * std::pow(__aurng(), __pow);
1720 result_type __ret = __uosd(__aurng);
1721
1722 std::transform(__ret.begin(), __ret.end(), __ret.begin(),
1723 [__urt](_RealType __val)
1724 { return __val * __urt; });
1725
1726 return __ret;
1727 }
1728 };
1729
1730 // Helper class for the uniform_inside_sphere_distribution generation
1731 // function specialized for small dimensions.
1732 template<std::size_t _Dimen, typename _RealType>
1733 class uniform_inside_sphere_helper<_Dimen, true, _RealType>
1734 {
1735 using result_type
1736 = typename uniform_inside_sphere_distribution<_Dimen, _RealType>::
1737 result_type;
1738
1739 public:
1740 template<typename _UniformOnSphereDistribution,
1741 typename _UniformRandomNumberGenerator>
1742 result_type
1743 operator()(_UniformOnSphereDistribution&,
1744 _UniformRandomNumberGenerator& __urng,
1745 _RealType __radius)
1746 {
1747 result_type __ret;
1748 _RealType __sq;
1749 _RealType __radsq = __radius * __radius;
1750 std::__detail::_Adaptor<_UniformRandomNumberGenerator,
1751 _RealType> __aurng(__urng);
1752
1753 do
1754 {
1755 __sq = _RealType(0);
1756 for (int i = 0; i < _Dimen; ++i)
1757 {
1758 __ret[i] = _RealType(2) * __aurng() - _RealType(1);
1759 __sq += __ret[i] * __ret[i];
1760 }
1761 }
1762 while (__sq > _RealType(1));
1763
1764 for (int i = 0; i < _Dimen; ++i)
1765 __ret[i] *= __radius;
1766
1767 return __ret;
1768 }
1769 };
1770 } // namespace
1771
1772 //
1773 // Experiments have shown that rejection is more efficient than transform
1774 // for dimensions less than 8.
1775 //
1776 template<std::size_t _Dimen, typename _RealType>
1777 template<typename _UniformRandomNumberGenerator>
1778 typename uniform_inside_sphere_distribution<_Dimen, _RealType>::result_type
1779 uniform_inside_sphere_distribution<_Dimen, _RealType>::
1780 operator()(_UniformRandomNumberGenerator& __urng,
1781 const param_type& __p)
1782 {
1783 uniform_inside_sphere_helper<_Dimen, _Dimen < 8, _RealType> __helper;
1784 return __helper(_M_uosd, __urng, __p.radius());
1785 }
1786
1787 template<std::size_t _Dimen, typename _RealType>
1788 template<typename _OutputIterator,
1789 typename _UniformRandomNumberGenerator>
1790 void
1791 uniform_inside_sphere_distribution<_Dimen, _RealType>::
1792 __generate_impl(_OutputIterator __f, _OutputIterator __t,
1793 _UniformRandomNumberGenerator& __urng,
1794 const param_type& __param)
1795 {
1796 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator,
1797 result_type>)
1798
1799 while (__f != __t)
1800 *__f++ = this->operator()(__urng, __param);
1801 }
1802
1803 template<std::size_t _Dimen, typename _RealType, typename _CharT,
1804 typename _Traits>
1805 std::basic_ostream<_CharT, _Traits>&
1806 operator<<(std::basic_ostream<_CharT, _Traits>& __os,
1807 const __gnu_cxx::uniform_inside_sphere_distribution<_Dimen,
1808 _RealType>& __x)
1809 {
1810 typedef std::basic_ostream<_CharT, _Traits> __ostream_type;
1811 typedef typename __ostream_type::ios_base __ios_base;
1812
1813 const typename __ios_base::fmtflags __flags = __os.flags();
1814 const _CharT __fill = __os.fill();
1815 const std::streamsize __precision = __os.precision();
1816 const _CharT __space = __os.widen(' ');
1817 __os.flags(__ios_base::scientific | __ios_base::left);
1818 __os.fill(__space);
1819 __os.precision(std::numeric_limits<_RealType>::max_digits10);
1820
1821 __os << __x.radius() << __space << __x._M_uosd;
1822
1823 __os.flags(__flags);
1824 __os.fill(__fill);
1825 __os.precision(__precision);
1826
1827 return __os;
1828 }
1829
1830 template<std::size_t _Dimen, typename _RealType, typename _CharT,
1831 typename _Traits>
1832 std::basic_istream<_CharT, _Traits>&
1833 operator>>(std::basic_istream<_CharT, _Traits>& __is,
1834 __gnu_cxx::uniform_inside_sphere_distribution<_Dimen,
1835 _RealType>& __x)
1836 {
1837 typedef std::basic_istream<_CharT, _Traits> __istream_type;
1838 typedef typename __istream_type::ios_base __ios_base;
1839
1840 const typename __ios_base::fmtflags __flags = __is.flags();
1841 __is.flags(__ios_base::dec | __ios_base::skipws);
1842
1843 _RealType __radius_val;
1844 __is >> __radius_val >> __x._M_uosd;
1845 __x.param(typename uniform_inside_sphere_distribution<_Dimen, _RealType>::
1846 param_type(__radius_val));
1847
1848 __is.flags(__flags);
1849
1850 return __is;
1851 }
1852
1853_GLIBCXX_END_NAMESPACE_VERSION
1854} // namespace __gnu_cxx
1855
1856
1857#endif // _EXT_RANDOM_TCC
pow
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
Definition complex:1357
sqrt
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition complex:1271
requires_hosted.h
std::sin
complex< _Tp > sin(const complex< _Tp > &)
Return complex sine of z.
Definition complex:1197
std::log
complex< _Tp > log(const complex< _Tp > &)
Return complex natural logarithm of z.
Definition complex:1162
std::exp
complex< _Tp > exp(const complex< _Tp > &)
Return complex base e exponential of z.
Definition complex:1135
std::pow
complex< _Tp > pow(const complex< _Tp > &, int)
Return x to the y'th power.
Definition complex:1357
std::cos
complex< _Tp > cos(const complex< _Tp > &)
Return complex cosine of z.
Definition complex:1079
std::sqrt
complex< _Tp > sqrt(const complex< _Tp > &)
Return complex square root of z.
Definition complex:1271
std::streamsize
ptrdiff_t streamsize
Integral type for I/O operation counts and buffer sizes.
Definition postypes.h:73
std::advance
constexpr void advance(_InputIterator &__i, _Distance __n)
A generalization of pointer arithmetic.
Definition stl_iterator_base_funcs.h:271
__gnu_cxx
GNU extensions for public use.
__gnu_cxx::__detail
Implementation details not part of the namespace __gnu_cxx interface.
std::__numeric_limits_base::max_digits10
static constexpr int max_digits10
Definition limits:232
std::basic_ios::widen
char_type widen(char __c) const
Widens characters.
Definition basic_ios.h:465
std::basic_ios::fill
char_type fill() const
Retrieves the empty character.
Definition basic_ios.h:388
std::ios_base::precision
streamsize precision() const
Flags access.
Definition ios_base.h:765
std::ios_base::flags
fmtflags flags() const
Access to format flags.
Definition ios_base.h:694