Where Online Learning is simpler!
The C and C++ Include Header Files
cat -n /usr/include/c++/15/ext/random.tcc
1 // Random number extensions -*- C++ -*- 2 3 // Copyright (C) 2012-2025 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 39 namespace __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
