1 // Random number extensions -*- C++ -*- 2 3 // Copyright (C) 2012-2013 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 36 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default) 37 { 38 _GLIBCXX_BEGIN_NAMESPACE_VERSION 39 40 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 41 42 template<typename _UIntType, size_t __m, 43 size_t __pos1, size_t __sl1, size_t __sl2, 44 size_t __sr1, size_t __sr2, 45 uint32_t __msk1, uint32_t __msk2, 46 uint32_t __msk3, uint32_t __msk4, 47 uint32_t __parity1, uint32_t __parity2, 48 uint32_t __parity3, uint32_t __parity4> 49 void simd_fast_mersenne_twister_engine<_UIntType, __m, 50 __pos1, __sl1, __sl2, __sr1, __sr2, 51 __msk1, __msk2, __msk3, __msk4, 52 __parity1, __parity2, __parity3, 53 __parity4>:: 54 seed(_UIntType __seed) 55 { 56 _M_state32[0] = static_cast<uint32_t>(__seed); 57 for (size_t __i = 1; __i < _M_nstate32; ++__i) 58 _M_state32[__i] = (1812433253UL 59 * (_M_state32[__i - 1] ^ (_M_state32[__i - 1] >> 30)) 60 + __i); 61 _M_pos = state_size; 62 _M_period_certification(); 63 } 64 65 66 namespace { 67 68 inline uint32_t _Func1(uint32_t __x) 69 { 70 return (__x ^ (__x >> 27)) * UINT32_C(1664525); 71 } 72 73 inline uint32_t _Func2(uint32_t __x) 74 { 75 return (__x ^ (__x >> 27)) * UINT32_C(1566083941); 76 } 77 78 } 79 80 81 template<typename _UIntType, size_t __m, 82 size_t __pos1, size_t __sl1, size_t __sl2, 83 size_t __sr1, size_t __sr2, 84 uint32_t __msk1, uint32_t __msk2, 85 uint32_t __msk3, uint32_t __msk4, 86 uint32_t __parity1, uint32_t __parity2, 87 uint32_t __parity3, uint32_t __parity4> 88 template<typename _Sseq> 89 typename std::enable_if<std::is_class<_Sseq>::value>::type 90 simd_fast_mersenne_twister_engine<_UIntType, __m, 91 __pos1, __sl1, __sl2, __sr1, __sr2, 92 __msk1, __msk2, __msk3, __msk4, 93 __parity1, __parity2, __parity3, 94 __parity4>:: 95 seed(_Sseq& __q) 96 { 97 size_t __lag; 98 99 if (_M_nstate32 >= 623) 100 __lag = 11; 101 else if (_M_nstate32 >= 68) 102 __lag = 7; 103 else if (_M_nstate32 >= 39) 104 __lag = 5; 105 else 106 __lag = 3; 107 const size_t __mid = (_M_nstate32 - __lag) / 2; 108 109 std::fill(_M_state32, _M_state32 + _M_nstate32, UINT32_C(0x8b8b8b8b)); 110 uint32_t __arr[_M_nstate32]; 111 __q.generate(__arr + 0, __arr + _M_nstate32); 112 113 uint32_t __r = _Func1(_M_state32[0] ^ _M_state32[__mid] 114 ^ _M_state32[_M_nstate32 - 1]); 115 _M_state32[__mid] += __r; 116 __r += _M_nstate32; 117 _M_state32[__mid + __lag] += __r; 118 _M_state32[0] = __r; 119 120 for (size_t __i = 1, __j = 0; __j < _M_nstate32; ++__j) 121 { 122 __r = _Func1(_M_state32[__i] 123 ^ _M_state32[(__i + __mid) % _M_nstate32] 124 ^ _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]); 125 _M_state32[(__i + __mid) % _M_nstate32] += __r; 126 __r += __arr[__j] + __i; 127 _M_state32[(__i + __mid + __lag) % _M_nstate32] += __r; 128 _M_state32[__i] = __r; 129 __i = (__i + 1) % _M_nstate32; 130 } 131 for (size_t __j = 0; __j < _M_nstate32; ++__j) 132 { 133 const size_t __i = (__j + 1) % _M_nstate32; 134 __r = _Func2(_M_state32[__i] 135 + _M_state32[(__i + __mid) % _M_nstate32] 136 + _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]); 137 _M_state32[(__i + __mid) % _M_nstate32] ^= __r; 138 __r -= __i; 139 _M_state32[(__i + __mid + __lag) % _M_nstate32] ^= __r; 140 _M_state32[__i] = __r; 141 } 142 143 _M_pos = state_size; 144 _M_period_certification(); 145 } 146 147 148 template<typename _UIntType, size_t __m, 149 size_t __pos1, size_t __sl1, size_t __sl2, 150 size_t __sr1, size_t __sr2, 151 uint32_t __msk1, uint32_t __msk2, 152 uint32_t __msk3, uint32_t __msk4, 153 uint32_t __parity1, uint32_t __parity2, 154 uint32_t __parity3, uint32_t __parity4> 155 void simd_fast_mersenne_twister_engine<_UIntType, __m, 156 __pos1, __sl1, __sl2, __sr1, __sr2, 157 __msk1, __msk2, __msk3, __msk4, 158 __parity1, __parity2, __parity3, 159 __parity4>:: 160 _M_period_certification(void) 161 { 162 static const uint32_t __parity[4] = { __parity1, __parity2, 163 __parity3, __parity4 }; 164 uint32_t __inner = 0; 165 for (size_t __i = 0; __i < 4; ++__i) 166 if (__parity[__i] != 0) 167 __inner ^= _M_state32[__i] & __parity[__i]; 168 169 if (__builtin_parity(__inner) & 1) 170 return; 171 for (size_t __i = 0; __i < 4; ++__i) 172 if (__parity[__i] != 0) 173 { 174 _M_state32[__i] ^= 1 << (__builtin_ffs(__parity[__i]) - 1); 175 return; 176 } 177 __builtin_unreachable(); 178 } 179 180 181 template<typename _UIntType, size_t __m, 182 size_t __pos1, size_t __sl1, size_t __sl2, 183 size_t __sr1, size_t __sr2, 184 uint32_t __msk1, uint32_t __msk2, 185 uint32_t __msk3, uint32_t __msk4, 186 uint32_t __parity1, uint32_t __parity2, 187 uint32_t __parity3, uint32_t __parity4> 188 void simd_fast_mersenne_twister_engine<_UIntType, __m, 189 __pos1, __sl1, __sl2, __sr1, __sr2, 190 __msk1, __msk2, __msk3, __msk4, 191 __parity1, __parity2, __parity3, 192 __parity4>:: 193 discard(unsigned long long __z) 194 { 195 while (__z > state_size - _M_pos) 196 { 197 __z -= state_size - _M_pos; 198 199 _M_gen_rand(); 200 } 201 202 _M_pos += __z; 203 } 204 205 206 #ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_GEN_READ 207 208 namespace { 209 210 template<size_t __shift> 211 inline void __rshift(uint32_t *__out, const uint32_t *__in) 212 { 213 uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32) 214 | static_cast<uint64_t>(__in[2])); 215 uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32) 216 | static_cast<uint64_t>(__in[0])); 217 218 uint64_t __oh = __th >> (__shift * 8); 219 uint64_t __ol = __tl >> (__shift * 8); 220 __ol |= __th << (64 - __shift * 8); 221 __out[1] = static_cast<uint32_t>(__ol >> 32); 222 __out[0] = static_cast<uint32_t>(__ol); 223 __out[3] = static_cast<uint32_t>(__oh >> 32); 224 __out[2] = static_cast<uint32_t>(__oh); 225 } 226 227 228 template<size_t __shift> 229 inline void __lshift(uint32_t *__out, const uint32_t *__in) 230 { 231 uint64_t __th = ((static_cast<uint64_t>(__in[3]) << 32) 232 | static_cast<uint64_t>(__in[2])); 233 uint64_t __tl = ((static_cast<uint64_t>(__in[1]) << 32) 234 | static_cast<uint64_t>(__in[0])); 235 236 uint64_t __oh = __th << (__shift * 8); 237 uint64_t __ol = __tl << (__shift * 8); 238 __oh |= __tl >> (64 - __shift * 8); 239 __out[1] = static_cast<uint32_t>(__ol >> 32); 240 __out[0] = static_cast<uint32_t>(__ol); 241 __out[3] = static_cast<uint32_t>(__oh >> 32); 242 __out[2] = static_cast<uint32_t>(__oh); 243 } 244 245 246 template<size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2, 247 uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4> 248 inline void __recursion(uint32_t *__r, 249 const uint32_t *__a, const uint32_t *__b, 250 const uint32_t *__c, const uint32_t *__d) 251 { 252 uint32_t __x[4]; 253 uint32_t __y[4]; 254 255 __lshift<__sl2>(__x, __a); 256 __rshift<__sr2>(__y, __c); 257 __r[0] = (__a[0] ^ __x[0] ^ ((__b[0] >> __sr1) & __msk1) 258 ^ __y[0] ^ (__d[0] << __sl1)); 259 __r[1] = (__a[1] ^ __x[1] ^ ((__b[1] >> __sr1) & __msk2) 260 ^ __y[1] ^ (__d[1] << __sl1)); 261 __r[2] = (__a[2] ^ __x[2] ^ ((__b[2] >> __sr1) & __msk3) 262 ^ __y[2] ^ (__d[2] << __sl1)); 263 __r[3] = (__a[3] ^ __x[3] ^ ((__b[3] >> __sr1) & __msk4) 264 ^ __y[3] ^ (__d[3] << __sl1)); 265 } 266 267 } 268 269 270 template<typename _UIntType, size_t __m, 271 size_t __pos1, size_t __sl1, size_t __sl2, 272 size_t __sr1, size_t __sr2, 273 uint32_t __msk1, uint32_t __msk2, 274 uint32_t __msk3, uint32_t __msk4, 275 uint32_t __parity1, uint32_t __parity2, 276 uint32_t __parity3, uint32_t __parity4> 277 void simd_fast_mersenne_twister_engine<_UIntType, __m, 278 __pos1, __sl1, __sl2, __sr1, __sr2, 279 __msk1, __msk2, __msk3, __msk4, 280 __parity1, __parity2, __parity3, 281 __parity4>:: 282 _M_gen_rand(void) 283 { 284 const uint32_t *__r1 = &_M_state32[_M_nstate32 - 8]; 285 const uint32_t *__r2 = &_M_state32[_M_nstate32 - 4]; 286 static constexpr size_t __pos1_32 = __pos1 * 4; 287 288 size_t __i; 289 for (__i = 0; __i < _M_nstate32 - __pos1_32; __i += 4) 290 { 291 __recursion<__sl1, __sl2, __sr1, __sr2, 292 __msk1, __msk2, __msk3, __msk4> 293 (&_M_state32[__i], &_M_state32[__i], 294 &_M_state32[__i + __pos1_32], __r1, __r2); 295 __r1 = __r2; 296 __r2 = &_M_state32[__i]; 297 } 298 299 for (; __i < _M_nstate32; __i += 4) 300 { 301 __recursion<__sl1, __sl2, __sr1, __sr2, 302 __msk1, __msk2, __msk3, __msk4> 303 (&_M_state32[__i], &_M_state32[__i], 304 &_M_state32[__i + __pos1_32 - _M_nstate32], __r1, __r2); 305 __r1 = __r2; 306 __r2 = &_M_state32[__i]; 307 } 308 309 _M_pos = 0; 310 } 311 312 #endif 313 314 #ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_OPERATOREQUAL 315 template<typename _UIntType, size_t __m, 316 size_t __pos1, size_t __sl1, size_t __sl2, 317 size_t __sr1, size_t __sr2, 318 uint32_t __msk1, uint32_t __msk2, 319 uint32_t __msk3, uint32_t __msk4, 320 uint32_t __parity1, uint32_t __parity2, 321 uint32_t __parity3, uint32_t __parity4> 322 bool 323 operator==(const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType, 324 __m, __pos1, __sl1, __sl2, __sr1, __sr2, 325 __msk1, __msk2, __msk3, __msk4, 326 __parity1, __parity2, __parity3, __parity4>& __lhs, 327 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>& __rhs) 331 { 332 typedef __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType, 333 __m, __pos1, __sl1, __sl2, __sr1, __sr2, 334 __msk1, __msk2, __msk3, __msk4, 335 __parity1, __parity2, __parity3, __parity4> __engine; 336 return (std::equal(__lhs._M_stateT, 337 __lhs._M_stateT + __engine::state_size, 338 __rhs._M_stateT) 339 && __lhs._M_pos == __rhs._M_pos); 340 } 341 #endif 342 343 template<typename _UIntType, size_t __m, 344 size_t __pos1, size_t __sl1, size_t __sl2, 345 size_t __sr1, size_t __sr2, 346 uint32_t __msk1, uint32_t __msk2, 347 uint32_t __msk3, uint32_t __msk4, 348 uint32_t __parity1, uint32_t __parity2, 349 uint32_t __parity3, uint32_t __parity4, 350 typename _CharT, typename _Traits> 351 std::basic_ostream<_CharT, _Traits>& 352 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 353 const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType, 354 __m, __pos1, __sl1, __sl2, __sr1, __sr2, 355 __msk1, __msk2, __msk3, __msk4, 356 __parity1, __parity2, __parity3, __parity4>& __x) 357 { 358 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 359 typedef typename __ostream_type::ios_base __ios_base; 360 361 const typename __ios_base::fmtflags __flags = __os.flags(); 362 const _CharT __fill = __os.fill(); 363 const _CharT __space = __os.widen(' '); 364 __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left); 365 __os.fill(__space); 366 367 for (size_t __i = 0; __i < __x._M_nstate32; ++__i) 368 __os << __x._M_state32[__i] << __space; 369 __os << __x._M_pos; 370 371 __os.flags(__flags); 372 __os.fill(__fill); 373 return __os; 374 } 375 376 377 template<typename _UIntType, size_t __m, 378 size_t __pos1, size_t __sl1, size_t __sl2, 379 size_t __sr1, size_t __sr2, 380 uint32_t __msk1, uint32_t __msk2, 381 uint32_t __msk3, uint32_t __msk4, 382 uint32_t __parity1, uint32_t __parity2, 383 uint32_t __parity3, uint32_t __parity4, 384 typename _CharT, typename _Traits> 385 std::basic_istream<_CharT, _Traits>& 386 operator>>(std::basic_istream<_CharT, _Traits>& __is, 387 __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType, 388 __m, __pos1, __sl1, __sl2, __sr1, __sr2, 389 __msk1, __msk2, __msk3, __msk4, 390 __parity1, __parity2, __parity3, __parity4>& __x) 391 { 392 typedef std::basic_istream<_CharT, _Traits> __istream_type; 393 typedef typename __istream_type::ios_base __ios_base; 394 395 const typename __ios_base::fmtflags __flags = __is.flags(); 396 __is.flags(__ios_base::dec | __ios_base::skipws); 397 398 for (size_t __i = 0; __i < __x._M_nstate32; ++__i) 399 __is >> __x._M_state32[__i]; 400 __is >> __x._M_pos; 401 402 __is.flags(__flags); 403 return __is; 404 } 405 406 #endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ 407 408 /** 409 * Iteration method due to M.D. J<o:>hnk. 410 * 411 * M.D. J<o:>hnk, Erzeugung von betaverteilten und gammaverteilten 412 * Zufallszahlen, Metrika, Volume 8, 1964 413 */ 414 template<typename _RealType> 415 template<typename _UniformRandomNumberGenerator> 416 typename beta_distribution<_RealType>::result_type 417 beta_distribution<_RealType>:: 418 operator()(_UniformRandomNumberGenerator& __urng, 419 const param_type& __param) 420 { 421 std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type> 422 __aurng(__urng); 423 424 result_type __x, __y; 425 do 426 { 427 __x = std::exp(std::log(__aurng()) / __param.alpha()); 428 __y = std::exp(std::log(__aurng()) / __param.beta()); 429 } 430 while (__x + __y > result_type(1)); 431 432 return __x / (__x + __y); 433 } 434 435 template<typename _RealType> 436 template<typename _OutputIterator, 437 typename _UniformRandomNumberGenerator> 438 void 439 beta_distribution<_RealType>:: 440 __generate_impl(_OutputIterator __f, _OutputIterator __t, 441 _UniformRandomNumberGenerator& __urng, 442 const param_type& __param) 443 { 444 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 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 731 while (__f != __t) 732 { 733 typename std::normal_distribution<result_type>::param_type 734 __px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma()); 735 result_type __x = this->_M_ndx(__px, __urng); 736 result_type __y = this->_M_ndy(__py, __urng); 737 #if _GLIBCXX_USE_C99_MATH_TR1 738 *__f++ = std::hypot(__x, __y); 739 #else 740 *__f++ = std::sqrt(__x * __x + __y * __y); 741 #endif 742 } 743 } 744 745 template<typename _RealType, typename _CharT, typename _Traits> 746 std::basic_ostream<_CharT, _Traits>& 747 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 748 const rice_distribution<_RealType>& __x) 749 { 750 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 751 typedef typename __ostream_type::ios_base __ios_base; 752 753 const typename __ios_base::fmtflags __flags = __os.flags(); 754 const _CharT __fill = __os.fill(); 755 const std::streamsize __precision = __os.precision(); 756 const _CharT __space = __os.widen(' '); 757 __os.flags(__ios_base::scientific | __ios_base::left); 758 __os.fill(__space); 759 __os.precision(std::numeric_limits<_RealType>::max_digits10); 760 761 __os << __x.nu() << __space << __x.sigma(); 762 __os << __space << __x._M_ndx; 763 __os << __space << __x._M_ndy; 764 765 __os.flags(__flags); 766 __os.fill(__fill); 767 __os.precision(__precision); 768 return __os; 769 } 770 771 template<typename _RealType, typename _CharT, typename _Traits> 772 std::basic_istream<_CharT, _Traits>& 773 operator>>(std::basic_istream<_CharT, _Traits>& __is, 774 rice_distribution<_RealType>& __x) 775 { 776 typedef std::basic_istream<_CharT, _Traits> __istream_type; 777 typedef typename __istream_type::ios_base __ios_base; 778 779 const typename __ios_base::fmtflags __flags = __is.flags(); 780 __is.flags(__ios_base::dec | __ios_base::skipws); 781 782 _RealType __nu_val, __sigma_val; 783 __is >> __nu_val >> __sigma_val; 784 __is >> __x._M_ndx; 785 __is >> __x._M_ndy; 786 __x.param(typename rice_distribution<_RealType>:: 787 param_type(__nu_val, __sigma_val)); 788 789 __is.flags(__flags); 790 return __is; 791 } 792 793 794 template<typename _RealType> 795 template<typename _OutputIterator, 796 typename _UniformRandomNumberGenerator> 797 void 798 nakagami_distribution<_RealType>:: 799 __generate_impl(_OutputIterator __f, _OutputIterator __t, 800 _UniformRandomNumberGenerator& __urng, 801 const param_type& __p) 802 { 803 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 804 805 typename std::gamma_distribution<result_type>::param_type 806 __pg(__p.mu(), __p.omega() / __p.mu()); 807 while (__f != __t) 808 *__f++ = std::sqrt(this->_M_gd(__pg, __urng)); 809 } 810 811 template<typename _RealType, typename _CharT, typename _Traits> 812 std::basic_ostream<_CharT, _Traits>& 813 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 814 const nakagami_distribution<_RealType>& __x) 815 { 816 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 817 typedef typename __ostream_type::ios_base __ios_base; 818 819 const typename __ios_base::fmtflags __flags = __os.flags(); 820 const _CharT __fill = __os.fill(); 821 const std::streamsize __precision = __os.precision(); 822 const _CharT __space = __os.widen(' '); 823 __os.flags(__ios_base::scientific | __ios_base::left); 824 __os.fill(__space); 825 __os.precision(std::numeric_limits<_RealType>::max_digits10); 826 827 __os << __x.mu() << __space << __x.omega(); 828 __os << __space << __x._M_gd; 829 830 __os.flags(__flags); 831 __os.fill(__fill); 832 __os.precision(__precision); 833 return __os; 834 } 835 836 template<typename _RealType, typename _CharT, typename _Traits> 837 std::basic_istream<_CharT, _Traits>& 838 operator>>(std::basic_istream<_CharT, _Traits>& __is, 839 nakagami_distribution<_RealType>& __x) 840 { 841 typedef std::basic_istream<_CharT, _Traits> __istream_type; 842 typedef typename __istream_type::ios_base __ios_base; 843 844 const typename __ios_base::fmtflags __flags = __is.flags(); 845 __is.flags(__ios_base::dec | __ios_base::skipws); 846 847 _RealType __mu_val, __omega_val; 848 __is >> __mu_val >> __omega_val; 849 __is >> __x._M_gd; 850 __x.param(typename nakagami_distribution<_RealType>:: 851 param_type(__mu_val, __omega_val)); 852 853 __is.flags(__flags); 854 return __is; 855 } 856 857 858 template<typename _RealType> 859 template<typename _OutputIterator, 860 typename _UniformRandomNumberGenerator> 861 void 862 pareto_distribution<_RealType>:: 863 __generate_impl(_OutputIterator __f, _OutputIterator __t, 864 _UniformRandomNumberGenerator& __urng, 865 const param_type& __p) 866 { 867 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 868 869 result_type __mu_val = __p.mu(); 870 result_type __malphinv = -result_type(1) / __p.alpha(); 871 while (__f != __t) 872 *__f++ = __mu_val * std::pow(this->_M_ud(__urng), __malphinv); 873 } 874 875 template<typename _RealType, typename _CharT, typename _Traits> 876 std::basic_ostream<_CharT, _Traits>& 877 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 878 const pareto_distribution<_RealType>& __x) 879 { 880 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 881 typedef typename __ostream_type::ios_base __ios_base; 882 883 const typename __ios_base::fmtflags __flags = __os.flags(); 884 const _CharT __fill = __os.fill(); 885 const std::streamsize __precision = __os.precision(); 886 const _CharT __space = __os.widen(' '); 887 __os.flags(__ios_base::scientific | __ios_base::left); 888 __os.fill(__space); 889 __os.precision(std::numeric_limits<_RealType>::max_digits10); 890 891 __os << __x.alpha() << __space << __x.mu(); 892 __os << __space << __x._M_ud; 893 894 __os.flags(__flags); 895 __os.fill(__fill); 896 __os.precision(__precision); 897 return __os; 898 } 899 900 template<typename _RealType, typename _CharT, typename _Traits> 901 std::basic_istream<_CharT, _Traits>& 902 operator>>(std::basic_istream<_CharT, _Traits>& __is, 903 pareto_distribution<_RealType>& __x) 904 { 905 typedef std::basic_istream<_CharT, _Traits> __istream_type; 906 typedef typename __istream_type::ios_base __ios_base; 907 908 const typename __ios_base::fmtflags __flags = __is.flags(); 909 __is.flags(__ios_base::dec | __ios_base::skipws); 910 911 _RealType __alpha_val, __mu_val; 912 __is >> __alpha_val >> __mu_val; 913 __is >> __x._M_ud; 914 __x.param(typename pareto_distribution<_RealType>:: 915 param_type(__alpha_val, __mu_val)); 916 917 __is.flags(__flags); 918 return __is; 919 } 920 921 922 template<typename _RealType> 923 template<typename _UniformRandomNumberGenerator> 924 typename k_distribution<_RealType>::result_type 925 k_distribution<_RealType>:: 926 operator()(_UniformRandomNumberGenerator& __urng) 927 { 928 result_type __x = this->_M_gd1(__urng); 929 result_type __y = this->_M_gd2(__urng); 930 return std::sqrt(__x * __y); 931 } 932 933 template<typename _RealType> 934 template<typename _UniformRandomNumberGenerator> 935 typename k_distribution<_RealType>::result_type 936 k_distribution<_RealType>:: 937 operator()(_UniformRandomNumberGenerator& __urng, 938 const param_type& __p) 939 { 940 typename std::gamma_distribution<result_type>::param_type 941 __p1(__p.lambda(), result_type(1) / __p.lambda()), 942 __p2(__p.nu(), __p.mu() / __p.nu()); 943 result_type __x = this->_M_gd1(__p1, __urng); 944 result_type __y = this->_M_gd2(__p2, __urng); 945 return std::sqrt(__x * __y); 946 } 947 948 template<typename _RealType> 949 template<typename _OutputIterator, 950 typename _UniformRandomNumberGenerator> 951 void 952 k_distribution<_RealType>:: 953 __generate_impl(_OutputIterator __f, _OutputIterator __t, 954 _UniformRandomNumberGenerator& __urng, 955 const param_type& __p) 956 { 957 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 958 959 typename std::gamma_distribution<result_type>::param_type 960 __p1(__p.lambda(), result_type(1) / __p.lambda()), 961 __p2(__p.nu(), __p.mu() / __p.nu()); 962 while (__f != __t) 963 { 964 result_type __x = this->_M_gd1(__p1, __urng); 965 result_type __y = this->_M_gd2(__p2, __urng); 966 *__f++ = std::sqrt(__x * __y); 967 } 968 } 969 970 template<typename _RealType, typename _CharT, typename _Traits> 971 std::basic_ostream<_CharT, _Traits>& 972 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 973 const k_distribution<_RealType>& __x) 974 { 975 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 976 typedef typename __ostream_type::ios_base __ios_base; 977 978 const typename __ios_base::fmtflags __flags = __os.flags(); 979 const _CharT __fill = __os.fill(); 980 const std::streamsize __precision = __os.precision(); 981 const _CharT __space = __os.widen(' '); 982 __os.flags(__ios_base::scientific | __ios_base::left); 983 __os.fill(__space); 984 __os.precision(std::numeric_limits<_RealType>::max_digits10); 985 986 __os << __x.lambda() << __space << __x.mu() << __space << __x.nu(); 987 __os << __space << __x._M_gd1; 988 __os << __space << __x._M_gd2; 989 990 __os.flags(__flags); 991 __os.fill(__fill); 992 __os.precision(__precision); 993 return __os; 994 } 995 996 template<typename _RealType, typename _CharT, typename _Traits> 997 std::basic_istream<_CharT, _Traits>& 998 operator>>(std::basic_istream<_CharT, _Traits>& __is, 999 k_distribution<_RealType>& __x) 1000 { 1001 typedef std::basic_istream<_CharT, _Traits> __istream_type; 1002 typedef typename __istream_type::ios_base __ios_base; 1003 1004 const typename __ios_base::fmtflags __flags = __is.flags(); 1005 __is.flags(__ios_base::dec | __ios_base::skipws); 1006 1007 _RealType __lambda_val, __mu_val, __nu_val; 1008 __is >> __lambda_val >> __mu_val >> __nu_val; 1009 __is >> __x._M_gd1; 1010 __is >> __x._M_gd2; 1011 __x.param(typename k_distribution<_RealType>:: 1012 param_type(__lambda_val, __mu_val, __nu_val)); 1013 1014 __is.flags(__flags); 1015 return __is; 1016 } 1017 1018 1019 template<typename _RealType> 1020 template<typename _OutputIterator, 1021 typename _UniformRandomNumberGenerator> 1022 void 1023 arcsine_distribution<_RealType>:: 1024 __generate_impl(_OutputIterator __f, _OutputIterator __t, 1025 _UniformRandomNumberGenerator& __urng, 1026 const param_type& __p) 1027 { 1028 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 1029 1030 result_type __dif = __p.b() - __p.a(); 1031 result_type __sum = __p.a() + __p.b(); 1032 while (__f != __t) 1033 { 1034 result_type __x = std::sin(this->_M_ud(__urng)); 1035 *__f++ = (__x * __dif + __sum) / result_type(2); 1036 } 1037 } 1038 1039 template<typename _RealType, typename _CharT, typename _Traits> 1040 std::basic_ostream<_CharT, _Traits>& 1041 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1042 const arcsine_distribution<_RealType>& __x) 1043 { 1044 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 1045 typedef typename __ostream_type::ios_base __ios_base; 1046 1047 const typename __ios_base::fmtflags __flags = __os.flags(); 1048 const _CharT __fill = __os.fill(); 1049 const std::streamsize __precision = __os.precision(); 1050 const _CharT __space = __os.widen(' '); 1051 __os.flags(__ios_base::scientific | __ios_base::left); 1052 __os.fill(__space); 1053 __os.precision(std::numeric_limits<_RealType>::max_digits10); 1054 1055 __os << __x.a() << __space << __x.b(); 1056 __os << __space << __x._M_ud; 1057 1058 __os.flags(__flags); 1059 __os.fill(__fill); 1060 __os.precision(__precision); 1061 return __os; 1062 } 1063 1064 template<typename _RealType, typename _CharT, typename _Traits> 1065 std::basic_istream<_CharT, _Traits>& 1066 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1067 arcsine_distribution<_RealType>& __x) 1068 { 1069 typedef std::basic_istream<_CharT, _Traits> __istream_type; 1070 typedef typename __istream_type::ios_base __ios_base; 1071 1072 const typename __ios_base::fmtflags __flags = __is.flags(); 1073 __is.flags(__ios_base::dec | __ios_base::skipws); 1074 1075 _RealType __a, __b; 1076 __is >> __a >> __b; 1077 __is >> __x._M_ud; 1078 __x.param(typename arcsine_distribution<_RealType>:: 1079 param_type(__a, __b)); 1080 1081 __is.flags(__flags); 1082 return __is; 1083 } 1084 1085 1086 template<typename _RealType> 1087 template<typename _UniformRandomNumberGenerator> 1088 typename hoyt_distribution<_RealType>::result_type 1089 hoyt_distribution<_RealType>:: 1090 operator()(_UniformRandomNumberGenerator& __urng) 1091 { 1092 result_type __x = this->_M_ad(__urng); 1093 result_type __y = this->_M_ed(__urng); 1094 return (result_type(2) * this->q() 1095 / (result_type(1) + this->q() * this->q())) 1096 * std::sqrt(this->omega() * __x * __y); 1097 } 1098 1099 template<typename _RealType> 1100 template<typename _UniformRandomNumberGenerator> 1101 typename hoyt_distribution<_RealType>::result_type 1102 hoyt_distribution<_RealType>:: 1103 operator()(_UniformRandomNumberGenerator& __urng, 1104 const param_type& __p) 1105 { 1106 result_type __q2 = __p.q() * __p.q(); 1107 result_type __num = result_type(0.5L) * (result_type(1) + __q2); 1108 typename __gnu_cxx::arcsine_distribution<result_type>::param_type 1109 __pa(__num, __num / __q2); 1110 result_type __x = this->_M_ad(__pa, __urng); 1111 result_type __y = this->_M_ed(__urng); 1112 return (result_type(2) * __p.q() / (result_type(1) + __q2)) 1113 * std::sqrt(__p.omega() * __x * __y); 1114 } 1115 1116 template<typename _RealType> 1117 template<typename _OutputIterator, 1118 typename _UniformRandomNumberGenerator> 1119 void 1120 hoyt_distribution<_RealType>:: 1121 __generate_impl(_OutputIterator __f, _OutputIterator __t, 1122 _UniformRandomNumberGenerator& __urng, 1123 const param_type& __p) 1124 { 1125 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 1126 1127 result_type __2q = result_type(2) * __p.q(); 1128 result_type __q2 = __p.q() * __p.q(); 1129 result_type __q2p1 = result_type(1) + __q2; 1130 result_type __num = result_type(0.5L) * __q2p1; 1131 result_type __omega = __p.omega(); 1132 typename __gnu_cxx::arcsine_distribution<result_type>::param_type 1133 __pa(__num, __num / __q2); 1134 while (__f != __t) 1135 { 1136 result_type __x = this->_M_ad(__pa, __urng); 1137 result_type __y = this->_M_ed(__urng); 1138 *__f++ = (__2q / __q2p1) * std::sqrt(__omega * __x * __y); 1139 } 1140 } 1141 1142 template<typename _RealType, typename _CharT, typename _Traits> 1143 std::basic_ostream<_CharT, _Traits>& 1144 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1145 const hoyt_distribution<_RealType>& __x) 1146 { 1147 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 1148 typedef typename __ostream_type::ios_base __ios_base; 1149 1150 const typename __ios_base::fmtflags __flags = __os.flags(); 1151 const _CharT __fill = __os.fill(); 1152 const std::streamsize __precision = __os.precision(); 1153 const _CharT __space = __os.widen(' '); 1154 __os.flags(__ios_base::scientific | __ios_base::left); 1155 __os.fill(__space); 1156 __os.precision(std::numeric_limits<_RealType>::max_digits10); 1157 1158 __os << __x.q() << __space << __x.omega(); 1159 __os << __space << __x._M_ad; 1160 __os << __space << __x._M_ed; 1161 1162 __os.flags(__flags); 1163 __os.fill(__fill); 1164 __os.precision(__precision); 1165 return __os; 1166 } 1167 1168 template<typename _RealType, typename _CharT, typename _Traits> 1169 std::basic_istream<_CharT, _Traits>& 1170 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1171 hoyt_distribution<_RealType>& __x) 1172 { 1173 typedef std::basic_istream<_CharT, _Traits> __istream_type; 1174 typedef typename __istream_type::ios_base __ios_base; 1175 1176 const typename __ios_base::fmtflags __flags = __is.flags(); 1177 __is.flags(__ios_base::dec | __ios_base::skipws); 1178 1179 _RealType __q, __omega; 1180 __is >> __q >> __omega; 1181 __is >> __x._M_ad; 1182 __is >> __x._M_ed; 1183 __x.param(typename hoyt_distribution<_RealType>:: 1184 param_type(__q, __omega)); 1185 1186 __is.flags(__flags); 1187 return __is; 1188 } 1189 1190 1191 template<typename _RealType> 1192 template<typename _OutputIterator, 1193 typename _UniformRandomNumberGenerator> 1194 void 1195 triangular_distribution<_RealType>:: 1196 __generate_impl(_OutputIterator __f, _OutputIterator __t, 1197 _UniformRandomNumberGenerator& __urng, 1198 const param_type& __param) 1199 { 1200 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 1201 1202 while (__f != __t) 1203 *__f++ = this->operator()(__urng, __param); 1204 } 1205 1206 template<typename _RealType, typename _CharT, typename _Traits> 1207 std::basic_ostream<_CharT, _Traits>& 1208 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1209 const __gnu_cxx::triangular_distribution<_RealType>& __x) 1210 { 1211 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 1212 typedef typename __ostream_type::ios_base __ios_base; 1213 1214 const typename __ios_base::fmtflags __flags = __os.flags(); 1215 const _CharT __fill = __os.fill(); 1216 const std::streamsize __precision = __os.precision(); 1217 const _CharT __space = __os.widen(' '); 1218 __os.flags(__ios_base::scientific | __ios_base::left); 1219 __os.fill(__space); 1220 __os.precision(std::numeric_limits<_RealType>::max_digits10); 1221 1222 __os << __x.a() << __space << __x.b() << __space << __x.c(); 1223 1224 __os.flags(__flags); 1225 __os.fill(__fill); 1226 __os.precision(__precision); 1227 return __os; 1228 } 1229 1230 template<typename _RealType, typename _CharT, typename _Traits> 1231 std::basic_istream<_CharT, _Traits>& 1232 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1233 __gnu_cxx::triangular_distribution<_RealType>& __x) 1234 { 1235 typedef std::basic_istream<_CharT, _Traits> __istream_type; 1236 typedef typename __istream_type::ios_base __ios_base; 1237 1238 const typename __ios_base::fmtflags __flags = __is.flags(); 1239 __is.flags(__ios_base::dec | __ios_base::skipws); 1240 1241 _RealType __a, __b, __c; 1242 __is >> __a >> __b >> __c; 1243 __x.param(typename __gnu_cxx::triangular_distribution<_RealType>:: 1244 param_type(__a, __b, __c)); 1245 1246 __is.flags(__flags); 1247 return __is; 1248 } 1249 1250 1251 template<typename _RealType> 1252 template<typename _OutputIterator, 1253 typename _UniformRandomNumberGenerator> 1254 void 1255 von_mises_distribution<_RealType>:: 1256 __generate_impl(_OutputIterator __f, _OutputIterator __t, 1257 _UniformRandomNumberGenerator& __urng, 1258 const param_type& __param) 1259 { 1260 __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>) 1261 1262 while (__f != __t) 1263 *__f++ = this->operator()(__urng, __param); 1264 } 1265 1266 template<typename _RealType, typename _CharT, typename _Traits> 1267 std::basic_ostream<_CharT, _Traits>& 1268 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1269 const __gnu_cxx::von_mises_distribution<_RealType>& __x) 1270 { 1271 typedef std::basic_ostream<_CharT, _Traits> __ostream_type; 1272 typedef typename __ostream_type::ios_base __ios_base; 1273 1274 const typename __ios_base::fmtflags __flags = __os.flags(); 1275 const _CharT __fill = __os.fill(); 1276 const std::streamsize __precision = __os.precision(); 1277 const _CharT __space = __os.widen(' '); 1278 __os.flags(__ios_base::scientific | __ios_base::left); 1279 __os.fill(__space); 1280 __os.precision(std::numeric_limits<_RealType>::max_digits10); 1281 1282 __os << __x.mu() << __space << __x.kappa(); 1283 1284 __os.flags(__flags); 1285 __os.fill(__fill); 1286 __os.precision(__precision); 1287 return __os; 1288 } 1289 1290 template<typename _RealType, typename _CharT, typename _Traits> 1291 std::basic_istream<_CharT, _Traits>& 1292 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1293 __gnu_cxx::von_mises_distribution<_RealType>& __x) 1294 { 1295 typedef std::basic_istream<_CharT, _Traits> __istream_type; 1296 typedef typename __istream_type::ios_base __ios_base; 1297 1298 const typename __ios_base::fmtflags __flags = __is.flags(); 1299 __is.flags(__ios_base::dec | __ios_base::skipws); 1300 1301 _RealType __mu, __kappa; 1302 __is >> __mu >> __kappa; 1303 __x.param(typename __gnu_cxx::von_mises_distribution<_RealType>:: 1304 param_type(__mu, __kappa)); 1305 1306 __is.flags(__flags); 1307 return __is; 1308 } 1309 1310 _GLIBCXX_END_NAMESPACE_VERSION 1311 } // namespace 1312 1313 1314 #endif // _EXT_RANDOM_TCC 1315
