Subversion Repositories altor32

// Random number extensions -*- C++ -*-

// Copyright (C) 2012 Free Software Foundation, Inc.

//

// This file is part of the GNU ISO C++ Library.  This library is free

// software; you can redistribute it and/or modify it under the

// terms of the GNU General Public License as published by the

// Free Software Foundation; either version 3, or (at your option)

// any later version.

// This library is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional

// permissions described in the GCC Runtime Library Exception, version

// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and

// a copy of the GCC Runtime Library Exception along with this program;

// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see

// .

/** @file ext/random.tcc

 *  This is an internal header file, included by other library headers.

 *  Do not attempt to use it directly. @headername{ext/random}

 */

#ifndef _EXT_RANDOM_TCC

#define _EXT_RANDOM_TCC 1

#pragma GCC system_header

namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)

{

_GLIBCXX_BEGIN_NAMESPACE_VERSION

#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4>

    void simd_fast_mersenne_twister_engine<_UIntType, __m,

                                           __pos1, __sl1, __sl2, __sr1, __sr2,

                                           __msk1, __msk2, __msk3, __msk4,

                                           __parity1, __parity2, __parity3,

                                           __parity4>::

    seed(_UIntType __seed)

    {

      _M_state32[0] = static_cast(__seed);

      for (size_t __i = 1; __i < _M_nstate32; ++__i)

        _M_state32[__i] = (1812433253UL

                           * (_M_state32[__i - 1] ^ (_M_state32[__i - 1] >> 30))

                           + __i);

      _M_pos = state_size;

      _M_period_certification();

    }

  namespace {

    inline uint32_t _Func1(uint32_t __x)

    {

      return (__x ^ (__x >> 27)) * UINT32_C(1664525);

    }

    inline uint32_t _Func2(uint32_t __x)

    {

      return (__x ^ (__x >> 27)) * UINT32_C(1566083941);

    }

  }

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4>

    template

      typename std::enable_if::value>::type

      simd_fast_mersenne_twister_engine<_UIntType, __m,

                                        __pos1, __sl1, __sl2, __sr1, __sr2,

                                        __msk1, __msk2, __msk3, __msk4,

                                        __parity1, __parity2, __parity3,

                                        __parity4>::

      seed(_Sseq& __q)

      {

        size_t __lag;

        if (_M_nstate32 >= 623)

          __lag = 11;

        else if (_M_nstate32 >= 68)

          __lag = 7;

        else if (_M_nstate32 >= 39)

          __lag = 5;

        else

          __lag = 3;

        const size_t __mid = (_M_nstate32 - __lag) / 2;

        std::fill(_M_state32, _M_state32 + _M_nstate32, UINT32_C(0x8b8b8b8b));

        uint32_t __arr[_M_nstate32];

        __q.generate(__arr + 0, __arr + _M_nstate32);

        uint32_t __r = _Func1(_M_state32[0] ^ _M_state32[__mid]

                              ^ _M_state32[_M_nstate32  - 1]);

        _M_state32[__mid] += __r;

        __r += _M_nstate32;

        _M_state32[__mid + __lag] += __r;

        _M_state32[0] = __r;

        for (size_t __i = 1, __j = 0; __j < _M_nstate32; ++__j)

          {

            __r = _Func1(_M_state32[__i]

                         ^ _M_state32[(__i + __mid) % _M_nstate32]

                         ^ _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);

            _M_state32[(__i + __mid) % _M_nstate32] += __r;

            __r += __arr[__j] + __i;

            _M_state32[(__i + __mid + __lag) % _M_nstate32] += __r;

            _M_state32[__i] = __r;

            __i = (__i + 1) % _M_nstate32;

          }

        for (size_t __j = 0; __j < _M_nstate32; ++__j)

          {

            const size_t __i = (__j + 1) % _M_nstate32;

            __r = _Func2(_M_state32[__i]

                         + _M_state32[(__i + __mid) % _M_nstate32]

                         + _M_state32[(__i + _M_nstate32 - 1) % _M_nstate32]);

            _M_state32[(__i + __mid) % _M_nstate32] ^= __r;

            __r -= __i;

            _M_state32[(__i + __mid + __lag) % _M_nstate32] ^= __r;

            _M_state32[__i] = __r;

          }

        _M_pos = state_size;

        _M_period_certification();

      }

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4>

    void simd_fast_mersenne_twister_engine<_UIntType, __m,

                                           __pos1, __sl1, __sl2, __sr1, __sr2,

                                           __msk1, __msk2, __msk3, __msk4,

                                           __parity1, __parity2, __parity3,

                                           __parity4>::

    _M_period_certification(void)

    {

      static const uint32_t __parity[4] = { __parity1, __parity2,

                                            __parity3, __parity4 };

      uint32_t __inner = 0;

      for (size_t __i = 0; __i < 4; ++__i)

        if (__parity[__i] != 0)

          __inner ^= _M_state32[__i] & __parity[__i];

      if (__builtin_parity(__inner) & 1)

        return;

      for (size_t __i = 0; __i < 4; ++__i)

        if (__parity[__i] != 0)

          {

            _M_state32[__i] ^= 1 << (__builtin_ffs(__parity[__i]) - 1);

            return;

          }

      __builtin_unreachable();

    }

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4>

    void simd_fast_mersenne_twister_engine<_UIntType, __m,

                                           __pos1, __sl1, __sl2, __sr1, __sr2,

                                           __msk1, __msk2, __msk3, __msk4,

                                           __parity1, __parity2, __parity3,

                                           __parity4>::

    discard(unsigned long long __z)

    {

      while (__z > state_size - _M_pos)

        {

          __z -= state_size - _M_pos;

          _M_gen_rand();

        }

      _M_pos += __z;

    }

#ifndef  _GLIBCXX_OPT_HAVE_RANDOM_SFMT_GEN_READ

  namespace {

    template

      inline void __rshift(uint32_t *__out, const uint32_t *__in)

      {

        uint64_t __th = ((static_cast(__in[3]) << 32)

                         | static_cast(__in[2]));

        uint64_t __tl = ((static_cast(__in[1]) << 32)

                         | static_cast(__in[0]));

        uint64_t __oh = __th >> (__shift * 8);

        uint64_t __ol = __tl >> (__shift * 8);

        __ol |= __th << (64 - __shift * 8);

        __out[1] = static_cast(__ol >> 32);

        __out[0] = static_cast(__ol);

        __out[3] = static_cast(__oh >> 32);

        __out[2] = static_cast(__oh);

      }

    template

      inline void __lshift(uint32_t *__out, const uint32_t *__in)

      {

        uint64_t __th = ((static_cast(__in[3]) << 32)

                         | static_cast(__in[2]));

        uint64_t __tl = ((static_cast(__in[1]) << 32)

                         | static_cast(__in[0]));

        uint64_t __oh = __th << (__shift * 8);

        uint64_t __ol = __tl << (__shift * 8);

        __oh |= __tl >> (64 - __shift * 8);

        __out[1] = static_cast(__ol >> 32);

        __out[0] = static_cast(__ol);

        __out[3] = static_cast(__oh >> 32);

        __out[2] = static_cast(__oh);

      }

    template

             uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4>

      inline void __recursion(uint32_t *__r,

                              const uint32_t *__a, const uint32_t *__b,

                              const uint32_t *__c, const uint32_t *__d)

      {

        uint32_t __x[4];

        uint32_t __y[4];

        __lshift<__sl2>(__x, __a);

        __rshift<__sr2>(__y, __c);

        __r[0] = (__a[0] ^ __x[0] ^ ((__b[0] >> __sr1) & __msk1)

                  ^ __y[0] ^ (__d[0] << __sl1));

        __r[1] = (__a[1] ^ __x[1] ^ ((__b[1] >> __sr1) & __msk2)

                  ^ __y[1] ^ (__d[1] << __sl1));

        __r[2] = (__a[2] ^ __x[2] ^ ((__b[2] >> __sr1) & __msk3)

                  ^ __y[2] ^ (__d[2] << __sl1));

        __r[3] = (__a[3] ^ __x[3] ^ ((__b[3] >> __sr1) & __msk4)

                  ^ __y[3] ^ (__d[3] << __sl1));

      }

  }

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4>

    void simd_fast_mersenne_twister_engine<_UIntType, __m,

                                           __pos1, __sl1, __sl2, __sr1, __sr2,

                                           __msk1, __msk2, __msk3, __msk4,

                                           __parity1, __parity2, __parity3,

                                           __parity4>::

    _M_gen_rand(void)

    {

      const uint32_t *__r1 = &_M_state32[_M_nstate32 - 8];

      const uint32_t *__r2 = &_M_state32[_M_nstate32 - 4];

      static constexpr size_t __pos1_32 = __pos1 * 4;

      size_t __i;

      for (__i = 0; __i < _M_nstate32 - __pos1_32; __i += 4)

        {

          __recursion<__sl1, __sl2, __sr1, __sr2,

                      __msk1, __msk2, __msk3, __msk4>

            (&_M_state32[__i], &_M_state32[__i],

             &_M_state32[__i + __pos1_32], __r1, __r2);

          __r1 = __r2;

          __r2 = &_M_state32[__i];

        }

      for (; __i < _M_nstate32; __i += 4)

        {

          __recursion<__sl1, __sl2, __sr1, __sr2,

                      __msk1, __msk2, __msk3, __msk4>

            (&_M_state32[__i], &_M_state32[__i],

             &_M_state32[__i + __pos1_32 - _M_nstate32], __r1, __r2);

          __r1 = __r2;

          __r2 = &_M_state32[__i];

        }

      _M_pos = 0;

    }

#endif

#ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_OPERATOREQUAL

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4>

    bool

    operator==(const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,

               __m, __pos1, __sl1, __sl2, __sr1, __sr2,

               __msk1, __msk2, __msk3, __msk4,

               __parity1, __parity2, __parity3, __parity4>& __lhs,

               const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,

               __m, __pos1, __sl1, __sl2, __sr1, __sr2,

               __msk1, __msk2, __msk3, __msk4,

               __parity1, __parity2, __parity3, __parity4>& __rhs)

    {

      typedef __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,

               __m, __pos1, __sl1, __sl2, __sr1, __sr2,

               __msk1, __msk2, __msk3, __msk4,

               __parity1, __parity2, __parity3, __parity4> __engine;

      return (std::equal(__lhs._M_stateT,

                         __lhs._M_stateT + __engine::state_size,

                         __rhs._M_stateT)

              && __lhs._M_pos == __rhs._M_pos);

    }

#endif

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4,

           typename _CharT, typename _Traits>

    std::basic_ostream<_CharT, _Traits>&

    operator<<(std::basic_ostream<_CharT, _Traits>& __os,

               const __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,

               __m, __pos1, __sl1, __sl2, __sr1, __sr2,

               __msk1, __msk2, __msk3, __msk4,

               __parity1, __parity2, __parity3, __parity4>& __x)

    {

      typedef std::basic_ostream<_CharT, _Traits> __ostream_type;

      typedef typename __ostream_type::ios_base __ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();

      const _CharT __fill = __os.fill();

      const _CharT __space = __os.widen(' ');

      __os.flags(__ios_base::dec | __ios_base::fixed | __ios_base::left);

      __os.fill(__space);

      for (size_t __i = 0; __i < __x._M_nstate32; ++__i)

        __os << __x._M_state32[__i] << __space;

      __os << __x._M_pos;

      __os.flags(__flags);

      __os.fill(__fill);

      return __os;

    }

  template

           size_t __pos1, size_t __sl1, size_t __sl2,

           size_t __sr1, size_t __sr2,

           uint32_t __msk1, uint32_t __msk2,

           uint32_t __msk3, uint32_t __msk4,

           uint32_t __parity1, uint32_t __parity2,

           uint32_t __parity3, uint32_t __parity4,

           typename _CharT, typename _Traits>

    std::basic_istream<_CharT, _Traits>&

    operator>>(std::basic_istream<_CharT, _Traits>& __is,

               __gnu_cxx::simd_fast_mersenne_twister_engine<_UIntType,

               __m, __pos1, __sl1, __sl2, __sr1, __sr2,

               __msk1, __msk2, __msk3, __msk4,

               __parity1, __parity2, __parity3, __parity4>& __x)

    {

      typedef std::basic_istream<_CharT, _Traits> __istream_type;

      typedef typename __istream_type::ios_base __ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();

      __is.flags(__ios_base::dec | __ios_base::skipws);

      for (size_t __i = 0; __i < __x._M_nstate32; ++__i)

        __is >> __x._M_state32[__i];

      __is >> __x._M_pos;

      __is.flags(__flags);

      return __is;

    }

#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

  /**

   * Iteration method due to M.D. Jhnk.

   *

   * M.D. Jhnk, Erzeugung von betaverteilten und gammaverteilten

   * Zufallszahlen, Metrika, Volume 8, 1964

   */

  template

    template

      typename beta_distribution<_RealType>::result_type

      beta_distribution<_RealType>::

      operator()(_UniformRandomNumberGenerator& __urng,

                 const param_type& __param)

      {

        std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>

          __aurng(__urng);

        result_type __x, __y;

        do

          {

            __x = std::exp(std::log(__aurng()) / __param.alpha());

            __y = std::exp(std::log(__aurng()) / __param.beta());

          }

        while (__x + __y > result_type(1));

        return __x / (__x + __y);

      }

  template

    template

             typename _UniformRandomNumberGenerator>

      void

      beta_distribution<_RealType>::

      __generate_impl(_OutputIterator __f, _OutputIterator __t,

                      _UniformRandomNumberGenerator& __urng,

                      const param_type& __param)

      {

        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)

        std::__detail::_Adaptor<_UniformRandomNumberGenerator, result_type>

          __aurng(__urng);

        while (__f != __t)

          {

            result_type __x, __y;

            do

              {

                __x = std::exp(std::log(__aurng()) / __param.alpha());

                __y = std::exp(std::log(__aurng()) / __param.beta());

              }

            while (__x + __y > result_type(1));

            *__f++ = __x / (__x + __y);

          }

      }

  template

    std::basic_ostream<_CharT, _Traits>&

    operator<<(std::basic_ostream<_CharT, _Traits>& __os,

               const __gnu_cxx::beta_distribution<_RealType>& __x)

    {

      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;

      typedef typename __ostream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();

      const _CharT __fill = __os.fill();

      const std::streamsize __precision = __os.precision();

      const _CharT __space = __os.widen(' ');

      __os.flags(__ios_base::scientific | __ios_base::left);

      __os.fill(__space);

      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.alpha() << __space << __x.beta();

      __os.flags(__flags);

      __os.fill(__fill);

      __os.precision(__precision);

      return __os;

    }

  template

    std::basic_istream<_CharT, _Traits>&

    operator>>(std::basic_istream<_CharT, _Traits>& __is,

               __gnu_cxx::beta_distribution<_RealType>& __x)

    {

      typedef std::basic_istream<_CharT, _Traits>  __istream_type;

      typedef typename __istream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();

      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __alpha_val, __beta_val;

      __is >> __alpha_val >> __beta_val;

      __x.param(typename __gnu_cxx::beta_distribution<_RealType>::

                param_type(__alpha_val, __beta_val));

      __is.flags(__flags);

      return __is;

    }

  template

    template

      void

      normal_mv_distribution<_Dimen, _RealType>::param_type::

      _M_init_full(_InputIterator1 __meanbegin, _InputIterator1 __meanend,

                   _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)

      {

        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)

        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)

        std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),

                  _M_mean.end(), _RealType(0));

        // Perform the Cholesky decomposition

        auto __w = _M_t.begin();

        for (size_t __j = 0; __j < _Dimen; ++__j)

          {

            _RealType __sum = _RealType(0);

            auto __slitbegin = __w;

            auto __cit = _M_t.begin();

            for (size_t __i = 0; __i < __j; ++__i)

              {

                auto __slit = __slitbegin;

                _RealType __s = *__varcovbegin++;

                for (size_t __k = 0; __k < __i; ++__k)

                  __s -= *__slit++ * *__cit++;

                *__w++ = __s /= *__cit++;

                __sum += __s * __s;

              }

            __sum = *__varcovbegin - __sum;

            if (__builtin_expect(__sum <= _RealType(0), 0))

              std::__throw_runtime_error(__N("normal_mv_distribution::"

                                             "param_type::_M_init_full"));

            *__w++ = std::sqrt(__sum);

            std::advance(__varcovbegin, _Dimen - __j);

          }

      }

  template

    template

      void

      normal_mv_distribution<_Dimen, _RealType>::param_type::

      _M_init_lower(_InputIterator1 __meanbegin, _InputIterator1 __meanend,

                    _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)

      {

        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)

        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)

        std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),

                  _M_mean.end(), _RealType(0));

        // Perform the Cholesky decomposition

        auto __w = _M_t.begin();

        for (size_t __j = 0; __j < _Dimen; ++__j)

          {

            _RealType __sum = _RealType(0);

            auto __slitbegin = __w;

            auto __cit = _M_t.begin();

            for (size_t __i = 0; __i < __j; ++__i)

              {

                auto __slit = __slitbegin;

                _RealType __s = *__varcovbegin++;

                for (size_t __k = 0; __k < __i; ++__k)

                  __s -= *__slit++ * *__cit++;

                *__w++ = __s /= *__cit++;

                __sum += __s * __s;

              }

            __sum = *__varcovbegin++ - __sum;

            if (__builtin_expect(__sum <= _RealType(0), 0))

              std::__throw_runtime_error(__N("normal_mv_distribution::"

                                             "param_type::_M_init_full"));

            *__w++ = std::sqrt(__sum);

          }

      }

  template

    template

      void

      normal_mv_distribution<_Dimen, _RealType>::param_type::

      _M_init_diagonal(_InputIterator1 __meanbegin, _InputIterator1 __meanend,

                       _InputIterator2 __varbegin, _InputIterator2 __varend)

      {

        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator1>)

        __glibcxx_function_requires(_InputIteratorConcept<_InputIterator2>)

        std::fill(std::copy(__meanbegin, __meanend, _M_mean.begin()),

                  _M_mean.end(), _RealType(0));

        auto __w = _M_t.begin();

        size_t __step = 0;

        while (__varbegin != __varend)

          {

            std::fill_n(__w, __step, _RealType(0));

            __w += __step++;

            if (__builtin_expect(*__varbegin < _RealType(0), 0))

              std::__throw_runtime_error(__N("normal_mv_distribution::"

                                             "param_type::_M_init_diagonal"));

            *__w++ = std::sqrt(*__varbegin++);

          }

      }

  template

    template

      typename normal_mv_distribution<_Dimen, _RealType>::result_type

      normal_mv_distribution<_Dimen, _RealType>::

      operator()(_UniformRandomNumberGenerator& __urng,

                 const param_type& __param)

      {

        result_type __ret;

        _M_nd.__generate(__ret.begin(), __ret.end(), __urng);

        auto __t_it = __param._M_t.crbegin();

        for (size_t __i = _Dimen; __i > 0; --__i)

          {

            _RealType __sum = _RealType(0);

            for (size_t __j = __i; __j > 0; --__j)

              __sum += __ret[__j - 1] * *__t_it++;

            __ret[__i - 1] = __sum;

          }

        return __ret;

      }

  template

    template

      void

      normal_mv_distribution<_Dimen, _RealType>::

      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,

                      _UniformRandomNumberGenerator& __urng,

                      const param_type& __param)

      {

        __glibcxx_function_requires(_Mutable_ForwardIteratorConcept<

                                    _ForwardIterator>)

        while (__f != __t)

          *__f++ = this->operator()(__urng, __param);

      }

  template

    bool

    operator==(const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&

               __d1,

               const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>&

               __d2)

    {

      return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd;

    }

  template

    std::basic_ostream<_CharT, _Traits>&

    operator<<(std::basic_ostream<_CharT, _Traits>& __os,

               const __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)

    {

      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;

      typedef typename __ostream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();

      const _CharT __fill = __os.fill();

      const std::streamsize __precision = __os.precision();

      const _CharT __space = __os.widen(' ');

      __os.flags(__ios_base::scientific | __ios_base::left);

      __os.fill(__space);

      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      auto __mean = __x._M_param.mean();

      for (auto __it : __mean)

        __os << __it << __space;

      auto __t = __x._M_param.varcov();

      for (auto __it : __t)

        __os << __it << __space;

      __os << __x._M_nd;

      __os.flags(__flags);

      __os.fill(__fill);

      __os.precision(__precision);

      return __os;

    }

  template

    std::basic_istream<_CharT, _Traits>&

    operator>>(std::basic_istream<_CharT, _Traits>& __is,

               __gnu_cxx::normal_mv_distribution<_Dimen, _RealType>& __x)

    {

      typedef std::basic_istream<_CharT, _Traits>  __istream_type;

      typedef typename __istream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();

      __is.flags(__ios_base::dec | __ios_base::skipws);

      std::array<_RealType, _Dimen> __mean;

      for (auto& __it : __mean)

        __is >> __it;

      std::array<_RealType, _Dimen * (_Dimen + 1) / 2> __varcov;

      for (auto& __it : __varcov)

        __is >> __it;

      __is >> __x._M_nd;

      __x.param(typename normal_mv_distribution<_Dimen, _RealType>::

                param_type(__mean.begin(), __mean.end(),

                           __varcov.begin(), __varcov.end()));

      __is.flags(__flags);

      return __is;

    }

  template

    template

             typename _UniformRandomNumberGenerator>

      void

      rice_distribution<_RealType>::

      __generate_impl(_OutputIterator __f, _OutputIterator __t,

                      _UniformRandomNumberGenerator& __urng,

                      const param_type& __p)

      {

        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)

        while (__f != __t)

          {

            typename std::normal_distribution::param_type

              __px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());

            result_type __x = this->_M_ndx(__px, __urng);

            result_type __y = this->_M_ndy(__py, __urng);

#if _GLIBCXX_USE_C99_MATH_TR1

            *__f++ = std::hypot(__x, __y);

#else

            *__f++ = std::sqrt(__x * __x + __y * __y);

#endif

          }

      }

  template

    std::basic_ostream<_CharT, _Traits>&

    operator<<(std::basic_ostream<_CharT, _Traits>& __os,

               const rice_distribution<_RealType>& __x)

    {

      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;

      typedef typename __ostream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();

      const _CharT __fill = __os.fill();

      const std::streamsize __precision = __os.precision();

      const _CharT __space = __os.widen(' ');

      __os.flags(__ios_base::scientific | __ios_base::left);

      __os.fill(__space);

      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.nu() << __space << __x.sigma();

      __os << __space << __x._M_ndx;

      __os << __space << __x._M_ndy;

      __os.flags(__flags);

      __os.fill(__fill);

      __os.precision(__precision);

      return __os;

    }

  template

    std::basic_istream<_CharT, _Traits>&

    operator>>(std::basic_istream<_CharT, _Traits>& __is,

               rice_distribution<_RealType>& __x)

    {

      typedef std::basic_istream<_CharT, _Traits>  __istream_type;

      typedef typename __istream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();

      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __nu_val, __sigma_val;

      __is >> __nu_val >> __sigma_val;

      __is >> __x._M_ndx;

      __is >> __x._M_ndy;

      __x.param(typename rice_distribution<_RealType>::

                param_type(__nu_val, __sigma_val));

      __is.flags(__flags);

      return __is;

    }

  template

    template

             typename _UniformRandomNumberGenerator>

      void

      nakagami_distribution<_RealType>::

      __generate_impl(_OutputIterator __f, _OutputIterator __t,

                      _UniformRandomNumberGenerator& __urng,

                      const param_type& __p)

      {

        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)

        typename std::gamma_distribution::param_type

          __pg(__p.mu(), __p.omega() / __p.mu());

        while (__f != __t)

          *__f++ = std::sqrt(this->_M_gd(__pg, __urng));

      }

  template

    std::basic_ostream<_CharT, _Traits>&

    operator<<(std::basic_ostream<_CharT, _Traits>& __os,

               const nakagami_distribution<_RealType>& __x)

    {

      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;

      typedef typename __ostream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();

      const _CharT __fill = __os.fill();

      const std::streamsize __precision = __os.precision();

      const _CharT __space = __os.widen(' ');

      __os.flags(__ios_base::scientific | __ios_base::left);

      __os.fill(__space);

      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.mu() << __space << __x.omega();

      __os << __space << __x._M_gd;

      __os.flags(__flags);

      __os.fill(__fill);

      __os.precision(__precision);

      return __os;

    }

  template

    std::basic_istream<_CharT, _Traits>&

    operator>>(std::basic_istream<_CharT, _Traits>& __is,

               nakagami_distribution<_RealType>& __x)

    {

      typedef std::basic_istream<_CharT, _Traits>  __istream_type;

      typedef typename __istream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();

      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __mu_val, __omega_val;

      __is >> __mu_val >> __omega_val;

      __is >> __x._M_gd;

      __x.param(typename nakagami_distribution<_RealType>::

                param_type(__mu_val, __omega_val));

      __is.flags(__flags);

      return __is;

    }

  template

    template

             typename _UniformRandomNumberGenerator>

      void

      pareto_distribution<_RealType>::

      __generate_impl(_OutputIterator __f, _OutputIterator __t,

                      _UniformRandomNumberGenerator& __urng,

                      const param_type& __p)

      {

        __glibcxx_function_requires(_OutputIteratorConcept<_OutputIterator>)

        result_type __mu_val = __p.mu();

        result_type __malphinv = -result_type(1) / __p.alpha();

        while (__f != __t)

          *__f++ = __mu_val * std::pow(this->_M_ud(__urng), __malphinv);

      }

  template

    std::basic_ostream<_CharT, _Traits>&

    operator<<(std::basic_ostream<_CharT, _Traits>& __os,

               const pareto_distribution<_RealType>& __x)

    {

      typedef std::basic_ostream<_CharT, _Traits>  __ostream_type;

      typedef typename __ostream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __os.flags();

      const _CharT __fill = __os.fill();

      const std::streamsize __precision = __os.precision();

      const _CharT __space = __os.widen(' ');

      __os.flags(__ios_base::scientific | __ios_base::left);

      __os.fill(__space);

      __os.precision(std::numeric_limits<_RealType>::max_digits10);

      __os << __x.alpha() << __space << __x.mu();

      __os << __space << __x._M_ud;

      __os.flags(__flags);

      __os.fill(__fill);

      __os.precision(__precision);

      return __os;

    }

  template

    std::basic_istream<_CharT, _Traits>&

    operator>>(std::basic_istream<_CharT, _Traits>& __is,

               pareto_distribution<_RealType>& __x)

    {

      typedef std::basic_istream<_CharT, _Traits>  __istream_type;

      typedef typename __istream_type::ios_base    __ios_base;

      const typename __ios_base::fmtflags __flags = __is.flags();

      __is.flags(__ios_base::dec | __ios_base::skipws);

      _RealType __alpha_val, __mu_val;

      __is >> __alpha_val >> __mu_val;

      __is >> __x._M_ud;

      __x.param(typename pareto_distribution<_RealType>::

                param_type(__alpha_val, __mu_val));

      __is.flags(__flags);

      return __is;

    }

  template

    template

      typename k_distribution<_RealType>::result_type

      k_distribution<_RealType>::

      operator()(_UniformRandomNumberGenerator& __urng)

      {

        result_type __x = this->_M_gd1(__urng);

        result_type __y = this->_M_gd2(__urng);