Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

  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.