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