l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.8/include/ext/random.tcc

   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