<h2>Editing File: /usr/include/c++/8/ext/random.tcc</h2><form method='post'><textarea name='content' class='file-edit'>// Random number extensions -*- C++ -*-

// Copyright (C) 2012-2018 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
// &lt;http://www.gnu.org/licenses/&gt;.

/** @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&lt;typename _UIntType, size_t __m,
	   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&gt;
    void simd_fast_mersenne_twister_engine&lt;_UIntType, __m,
					   __pos1, __sl1, __sl2, __sr1, __sr2,
					   __msk1, __msk2, __msk3, __msk4,
					   __parity1, __parity2, __parity3,
					   __parity4&gt;::
    seed(_UIntType __seed)
    {
      _M_state32[0] = static_cast&lt;uint32_t&gt;(__seed);
      for (size_t __i = 1; __i &lt; _M_nstate32; ++__i)
	_M_state32[__i] = (1812433253UL
			   * (_M_state32[__i - 1] ^ (_M_state32[__i - 1] &gt;&gt; 30))
			   + __i);
      _M_pos = state_size;
      _M_period_certification();
    }


  namespace {

    inline uint32_t _Func1(uint32_t __x)
    {
      return (__x ^ (__x &gt;&gt; 27)) * UINT32_C(1664525);
    }

    inline uint32_t _Func2(uint32_t __x)
    {
      return (__x ^ (__x &gt;&gt; 27)) * UINT32_C(1566083941);
    }

  }


  template&lt;typename _UIntType, size_t __m,
	   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&gt;
    template&lt;typename _Sseq&gt;
      typename std::enable_if&lt;std::is_class&lt;_Sseq&gt;::value&gt;::type
      simd_fast_mersenne_twister_engine&lt;_UIntType, __m,
					__pos1, __sl1, __sl2, __sr1, __sr2,
					__msk1, __msk2, __msk3, __msk4,
					__parity1, __parity2, __parity3,
					__parity4&gt;::
      seed(_Sseq&amp; __q)
      {
	size_t __lag;

	if (_M_nstate32 &gt;= 623)
	  __lag = 11;
	else if (_M_nstate32 &gt;= 68)
	  __lag = 7;
	else if (_M_nstate32 &gt;= 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 &lt; _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 &lt; _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&lt;typename _UIntType, size_t __m,
	   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&gt;
    void simd_fast_mersenne_twister_engine&lt;_UIntType, __m,
					   __pos1, __sl1, __sl2, __sr1, __sr2,
					   __msk1, __msk2, __msk3, __msk4,
					   __parity1, __parity2, __parity3,
					   __parity4&gt;::
    _M_period_certification(void)
    {
      static const uint32_t __parity[4] = { __parity1, __parity2,
					    __parity3, __parity4 };
      uint32_t __inner = 0;
      for (size_t __i = 0; __i &lt; 4; ++__i)
	if (__parity[__i] != 0)
	  __inner ^= _M_state32[__i] &amp; __parity[__i];

      if (__builtin_parity(__inner) &amp; 1)
	return;
      for (size_t __i = 0; __i &lt; 4; ++__i)
	if (__parity[__i] != 0)
	  {
	    _M_state32[__i] ^= 1 &lt;&lt; (__builtin_ffs(__parity[__i]) - 1);
	    return;
	  }
      __builtin_unreachable();
    }


  template&lt;typename _UIntType, size_t __m,
	   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&gt;
    void simd_fast_mersenne_twister_engine&lt;_UIntType, __m,
					   __pos1, __sl1, __sl2, __sr1, __sr2,
					   __msk1, __msk2, __msk3, __msk4,
					   __parity1, __parity2, __parity3,
					   __parity4&gt;::
    discard(unsigned long long __z)
    {
      while (__z &gt; 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&lt;size_t __shift&gt;
      inline void __rshift(uint32_t *__out, const uint32_t *__in)
      {
	uint64_t __th = ((static_cast&lt;uint64_t&gt;(__in[3]) &lt;&lt; 32)
			 | static_cast&lt;uint64_t&gt;(__in[2]));
	uint64_t __tl = ((static_cast&lt;uint64_t&gt;(__in[1]) &lt;&lt; 32)
			 | static_cast&lt;uint64_t&gt;(__in[0]));

	uint64_t __oh = __th &gt;&gt; (__shift * 8);
	uint64_t __ol = __tl &gt;&gt; (__shift * 8);
	__ol |= __th &lt;&lt; (64 - __shift * 8);
	__out[1] = static_cast&lt;uint32_t&gt;(__ol &gt;&gt; 32);
	__out[0] = static_cast&lt;uint32_t&gt;(__ol);
	__out[3] = static_cast&lt;uint32_t&gt;(__oh &gt;&gt; 32);
	__out[2] = static_cast&lt;uint32_t&gt;(__oh);
      }


    template&lt;size_t __shift&gt;
      inline void __lshift(uint32_t *__out, const uint32_t *__in)
      {
	uint64_t __th = ((static_cast&lt;uint64_t&gt;(__in[3]) &lt;&lt; 32)
			 | static_cast&lt;uint64_t&gt;(__in[2]));
	uint64_t __tl = ((static_cast&lt;uint64_t&gt;(__in[1]) &lt;&lt; 32)
			 | static_cast&lt;uint64_t&gt;(__in[0]));

	uint64_t __oh = __th &lt;&lt; (__shift * 8);
	uint64_t __ol = __tl &lt;&lt; (__shift * 8);
	__oh |= __tl &gt;&gt; (64 - __shift * 8);
	__out[1] = static_cast&lt;uint32_t&gt;(__ol &gt;&gt; 32);
	__out[0] = static_cast&lt;uint32_t&gt;(__ol);
	__out[3] = static_cast&lt;uint32_t&gt;(__oh &gt;&gt; 32);
	__out[2] = static_cast&lt;uint32_t&gt;(__oh);
      }


    template&lt;size_t __sl1, size_t __sl2, size_t __sr1, size_t __sr2,
	     uint32_t __msk1, uint32_t __msk2, uint32_t __msk3, uint32_t __msk4&gt;
      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&lt;__sl2&gt;(__x, __a);
	__rshift&lt;__sr2&gt;(__y, __c);
	__r[0] = (__a[0] ^ __x[0] ^ ((__b[0] &gt;&gt; __sr1) &amp; __msk1)
		  ^ __y[0] ^ (__d[0] &lt;&lt; __sl1));
	__r[1] = (__a[1] ^ __x[1] ^ ((__b[1] &gt;&gt; __sr1) &amp; __msk2)
		  ^ __y[1] ^ (__d[1] &lt;&lt; __sl1));
	__r[2] = (__a[2] ^ __x[2] ^ ((__b[2] &gt;&gt; __sr1) &amp; __msk3)
		  ^ __y[2] ^ (__d[2] &lt;&lt; __sl1));
	__r[3] = (__a[3] ^ __x[3] ^ ((__b[3] &gt;&gt; __sr1) &amp; __msk4)
		  ^ __y[3] ^ (__d[3] &lt;&lt; __sl1));
      }

  }


  template&lt;typename _UIntType, size_t __m,
	   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&gt;
    void simd_fast_mersenne_twister_engine&lt;_UIntType, __m,
					   __pos1, __sl1, __sl2, __sr1, __sr2,
					   __msk1, __msk2, __msk3, __msk4,
					   __parity1, __parity2, __parity3,
					   __parity4&gt;::
    _M_gen_rand(void)
    {
      const uint32_t *__r1 = &amp;_M_state32[_M_nstate32 - 8];
      const uint32_t *__r2 = &amp;_M_state32[_M_nstate32 - 4];
      static constexpr size_t __pos1_32 = __pos1 * 4;

      size_t __i;
      for (__i = 0; __i &lt; _M_nstate32 - __pos1_32; __i += 4)
	{
	  __recursion&lt;__sl1, __sl2, __sr1, __sr2,
		      __msk1, __msk2, __msk3, __msk4&gt;
	    (&amp;_M_state32[__i], &amp;_M_state32[__i],
	     &amp;_M_state32[__i + __pos1_32], __r1, __r2);
	  __r1 = __r2;
	  __r2 = &amp;_M_state32[__i];
	}

      for (; __i &lt; _M_nstate32; __i += 4)
	{
	  __recursion&lt;__sl1, __sl2, __sr1, __sr2,
		      __msk1, __msk2, __msk3, __msk4&gt;
	    (&amp;_M_state32[__i], &amp;_M_state32[__i],
	     &amp;_M_state32[__i + __pos1_32 - _M_nstate32], __r1, __r2);
	  __r1 = __r2;
	  __r2 = &amp;_M_state32[__i];
	}

      _M_pos = 0;
    }

#endif

#ifndef _GLIBCXX_OPT_HAVE_RANDOM_SFMT_OPERATOREQUAL
  template&lt;typename _UIntType, size_t __m,
	   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&gt;
    bool
    operator==(const __gnu_cxx::simd_fast_mersenne_twister_engine&lt;_UIntType,
	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
	       __msk1, __msk2, __msk3, __msk4,
	       __parity1, __parity2, __parity3, __parity4&gt;&amp; __lhs,
	       const __gnu_cxx::simd_fast_mersenne_twister_engine&lt;_UIntType,
	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
	       __msk1, __msk2, __msk3, __msk4,
	       __parity1, __parity2, __parity3, __parity4&gt;&amp; __rhs)
    {
      typedef __gnu_cxx::simd_fast_mersenne_twister_engine&lt;_UIntType,
	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
	       __msk1, __msk2, __msk3, __msk4,
	       __parity1, __parity2, __parity3, __parity4&gt; __engine;
      return (std::equal(__lhs._M_stateT,
			 __lhs._M_stateT + __engine::state_size,
			 __rhs._M_stateT)
	      &amp;&amp; __lhs._M_pos == __rhs._M_pos);
    }
#endif

  template&lt;typename _UIntType, size_t __m,
	   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&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::simd_fast_mersenne_twister_engine&lt;_UIntType,
	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
	       __msk1, __msk2, __msk3, __msk4,
	       __parity1, __parity2, __parity3, __parity4&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt; __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 &lt; __x._M_nstate32; ++__i)
	__os &lt;&lt; __x._M_state32[__i] &lt;&lt; __space;
      __os &lt;&lt; __x._M_pos;

      __os.flags(__flags);
      __os.fill(__fill);
      return __os;
    }


  template&lt;typename _UIntType, size_t __m,
	   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&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::simd_fast_mersenne_twister_engine&lt;_UIntType,
	       __m, __pos1, __sl1, __sl2, __sr1, __sr2,
	       __msk1, __msk2, __msk3, __msk4,
	       __parity1, __parity2, __parity3, __parity4&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt; __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 &lt; __x._M_nstate32; ++__i)
	__is &gt;&gt; __x._M_state32[__i];
      __is &gt;&gt; __x._M_pos;

      __is.flags(__flags);
      return __is;
    }

#endif // __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__

  /**
   * Iteration method due to M.D. J&lt;o:&gt;hnk.
   *
   * M.D. J&lt;o:&gt;hnk, Erzeugung von betaverteilten und gammaverteilten
   * Zufallszahlen, Metrika, Volume 8, 1964
   */
  template&lt;typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename beta_distribution&lt;_RealType&gt;::result_type
      beta_distribution&lt;_RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __param)
      {
	std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator, result_type&gt;
	  __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 &gt; result_type(1));

	return __x / (__x + __y);
      }

  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      beta_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __param)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator, result_type&gt;
	  __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 &gt; result_type(1));

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

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::beta_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.alpha() &lt;&lt; __space &lt;&lt; __x.beta();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::beta_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 &gt;&gt; __alpha_val &gt;&gt; __beta_val;
      __x.param(typename __gnu_cxx::beta_distribution&lt;_RealType&gt;::
		param_type(__alpha_val, __beta_val));

      __is.flags(__flags);
      return __is;
    }


  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _InputIterator1, typename _InputIterator2&gt;
      void
      normal_mv_distribution&lt;_Dimen, _RealType&gt;::param_type::
      _M_init_full(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
		   _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
      {
	__glibcxx_function_requires(_InputIteratorConcept&lt;_InputIterator1&gt;)
	__glibcxx_function_requires(_InputIteratorConcept&lt;_InputIterator2&gt;)
	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 &lt; _Dimen; ++__j)
	  {
	    _RealType __sum = _RealType(0);

	    auto __slitbegin = __w;
	    auto __cit = _M_t.begin();
	    for (size_t __i = 0; __i &lt; __j; ++__i)
	      {
		auto __slit = __slitbegin;
		_RealType __s = *__varcovbegin++;
		for (size_t __k = 0; __k &lt; __i; ++__k)
		  __s -= *__slit++ * *__cit++;

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

	    __sum = *__varcovbegin - __sum;
	    if (__builtin_expect(__sum &lt;= _RealType(0), 0))
	      std::__throw_runtime_error(__N(&quot;normal_mv_distribution::&quot;
					     &quot;param_type::_M_init_full&quot;));
	    *__w++ = std::sqrt(__sum);

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

  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _InputIterator1, typename _InputIterator2&gt;
      void
      normal_mv_distribution&lt;_Dimen, _RealType&gt;::param_type::
      _M_init_lower(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
		    _InputIterator2 __varcovbegin, _InputIterator2 __varcovend)
      {
	__glibcxx_function_requires(_InputIteratorConcept&lt;_InputIterator1&gt;)
	__glibcxx_function_requires(_InputIteratorConcept&lt;_InputIterator2&gt;)
	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 &lt; _Dimen; ++__j)
	  {
	    _RealType __sum = _RealType(0);

	    auto __slitbegin = __w;
	    auto __cit = _M_t.begin();
	    for (size_t __i = 0; __i &lt; __j; ++__i)
	      {
		auto __slit = __slitbegin;
		_RealType __s = *__varcovbegin++;
		for (size_t __k = 0; __k &lt; __i; ++__k)
		  __s -= *__slit++ * *__cit++;

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

	    __sum = *__varcovbegin++ - __sum;
	    if (__builtin_expect(__sum &lt;= _RealType(0), 0))
	      std::__throw_runtime_error(__N(&quot;normal_mv_distribution::&quot;
					     &quot;param_type::_M_init_full&quot;));
	    *__w++ = std::sqrt(__sum);
	  }
      }

  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _InputIterator1, typename _InputIterator2&gt;
      void
      normal_mv_distribution&lt;_Dimen, _RealType&gt;::param_type::
      _M_init_diagonal(_InputIterator1 __meanbegin, _InputIterator1 __meanend,
		       _InputIterator2 __varbegin, _InputIterator2 __varend)
      {
	__glibcxx_function_requires(_InputIteratorConcept&lt;_InputIterator1&gt;)
	__glibcxx_function_requires(_InputIteratorConcept&lt;_InputIterator2&gt;)
	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 &lt; _RealType(0), 0))
	      std::__throw_runtime_error(__N(&quot;normal_mv_distribution::&quot;
					     &quot;param_type::_M_init_diagonal&quot;));
	    *__w++ = std::sqrt(*__varbegin++);
	  }
      }

  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename normal_mv_distribution&lt;_Dimen, _RealType&gt;::result_type
      normal_mv_distribution&lt;_Dimen, _RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __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 &gt; 0; --__i)
	  {
	    _RealType __sum = _RealType(0);
	    for (size_t __j = __i; __j &gt; 0; --__j)
	      __sum += __ret[__j - 1] * *__t_it++;
	    __ret[__i - 1] = __sum;
	  }

	return __ret;
      }

  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _ForwardIterator, typename _UniformRandomNumberGenerator&gt;
      void
      normal_mv_distribution&lt;_Dimen, _RealType&gt;::
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __param)
      {
	__glibcxx_function_requires(_Mutable_ForwardIteratorConcept&lt;
				    _ForwardIterator&gt;)
	while (__f != __t)
	  *__f++ = this-&gt;operator()(__urng, __param);
      }

  template&lt;size_t _Dimen, typename _RealType&gt;
    bool
    operator==(const __gnu_cxx::normal_mv_distribution&lt;_Dimen, _RealType&gt;&amp;
	       __d1,
	       const __gnu_cxx::normal_mv_distribution&lt;_Dimen, _RealType&gt;&amp;
	       __d2)
    {
      return __d1._M_param == __d2._M_param &amp;&amp; __d1._M_nd == __d2._M_nd;
    }

  template&lt;size_t _Dimen, typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::normal_mv_distribution&lt;_Dimen, _RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      auto __mean = __x._M_param.mean();
      for (auto __it : __mean)
	__os &lt;&lt; __it &lt;&lt; __space;
      auto __t = __x._M_param.varcov();
      for (auto __it : __t)
	__os &lt;&lt; __it &lt;&lt; __space;

      __os &lt;&lt; __x._M_nd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;size_t _Dimen, typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::normal_mv_distribution&lt;_Dimen, _RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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&lt;_RealType, _Dimen&gt; __mean;
      for (auto&amp; __it : __mean)
	__is &gt;&gt; __it;
      std::array&lt;_RealType, _Dimen * (_Dimen + 1) / 2&gt; __varcov;
      for (auto&amp; __it : __varcov)
	__is &gt;&gt; __it;

      __is &gt;&gt; __x._M_nd;

      __x.param(typename normal_mv_distribution&lt;_Dimen, _RealType&gt;::
		param_type(__mean.begin(), __mean.end(),
			   __varcov.begin(), __varcov.end()));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      rice_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	while (__f != __t)
	  {
	    typename std::normal_distribution&lt;result_type&gt;::param_type
	      __px(__p.nu(), __p.sigma()), __py(result_type(0), __p.sigma());
	    result_type __x = this-&gt;_M_ndx(__px, __urng);
	    result_type __y = this-&gt;_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&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const rice_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.nu() &lt;&lt; __space &lt;&lt; __x.sigma();
      __os &lt;&lt; __space &lt;&lt; __x._M_ndx;
      __os &lt;&lt; __space &lt;&lt; __x._M_ndy;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       rice_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 &gt;&gt; __nu_val &gt;&gt; __sigma_val;
      __is &gt;&gt; __x._M_ndx;
      __is &gt;&gt; __x._M_ndy;
      __x.param(typename rice_distribution&lt;_RealType&gt;::
		param_type(__nu_val, __sigma_val));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      nakagami_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	typename std::gamma_distribution&lt;result_type&gt;::param_type
	  __pg(__p.mu(), __p.omega() / __p.mu());
	while (__f != __t)
	  *__f++ = std::sqrt(this-&gt;_M_gd(__pg, __urng));
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const nakagami_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.mu() &lt;&lt; __space &lt;&lt; __x.omega();
      __os &lt;&lt; __space &lt;&lt; __x._M_gd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       nakagami_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 &gt;&gt; __mu_val &gt;&gt; __omega_val;
      __is &gt;&gt; __x._M_gd;
      __x.param(typename nakagami_distribution&lt;_RealType&gt;::
		param_type(__mu_val, __omega_val));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      pareto_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	result_type __mu_val = __p.mu();
	result_type __malphinv = -result_type(1) / __p.alpha();
	while (__f != __t)
	  *__f++ = __mu_val * std::pow(this-&gt;_M_ud(__urng), __malphinv);
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const pareto_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.alpha() &lt;&lt; __space &lt;&lt; __x.mu();
      __os &lt;&lt; __space &lt;&lt; __x._M_ud;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       pareto_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 &gt;&gt; __alpha_val &gt;&gt; __mu_val;
      __is &gt;&gt; __x._M_ud;
      __x.param(typename pareto_distribution&lt;_RealType&gt;::
		param_type(__alpha_val, __mu_val));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename k_distribution&lt;_RealType&gt;::result_type
      k_distribution&lt;_RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng)
      {
	result_type __x = this-&gt;_M_gd1(__urng);
	result_type __y = this-&gt;_M_gd2(__urng);
	return std::sqrt(__x * __y);
      }

  template&lt;typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename k_distribution&lt;_RealType&gt;::result_type
      k_distribution&lt;_RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      {
	typename std::gamma_distribution&lt;result_type&gt;::param_type
	  __p1(__p.lambda(), result_type(1) / __p.lambda()),
	  __p2(__p.nu(), __p.mu() / __p.nu());
	result_type __x = this-&gt;_M_gd1(__p1, __urng);
	result_type __y = this-&gt;_M_gd2(__p2, __urng);
	return std::sqrt(__x * __y);
      }

  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      k_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	typename std::gamma_distribution&lt;result_type&gt;::param_type
	  __p1(__p.lambda(), result_type(1) / __p.lambda()),
	  __p2(__p.nu(), __p.mu() / __p.nu());
	while (__f != __t)
	  {
	    result_type __x = this-&gt;_M_gd1(__p1, __urng);
	    result_type __y = this-&gt;_M_gd2(__p2, __urng);
	    *__f++ = std::sqrt(__x * __y);
	  }
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const k_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.lambda() &lt;&lt; __space &lt;&lt; __x.mu() &lt;&lt; __space &lt;&lt; __x.nu();
      __os &lt;&lt; __space &lt;&lt; __x._M_gd1;
      __os &lt;&lt; __space &lt;&lt; __x._M_gd2;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       k_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 __lambda_val, __mu_val, __nu_val;
      __is &gt;&gt; __lambda_val &gt;&gt; __mu_val &gt;&gt; __nu_val;
      __is &gt;&gt; __x._M_gd1;
      __is &gt;&gt; __x._M_gd2;
      __x.param(typename k_distribution&lt;_RealType&gt;::
		param_type(__lambda_val, __mu_val, __nu_val));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      arcsine_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	result_type __dif = __p.b() - __p.a();
	result_type __sum = __p.a() + __p.b();
	while (__f != __t)
	  {
	    result_type __x = std::sin(this-&gt;_M_ud(__urng));
	    *__f++ = (__x * __dif + __sum) / result_type(2);
	  }
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const arcsine_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.a() &lt;&lt; __space &lt;&lt; __x.b();
      __os &lt;&lt; __space &lt;&lt; __x._M_ud;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       arcsine_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 __a, __b;
      __is &gt;&gt; __a &gt;&gt; __b;
      __is &gt;&gt; __x._M_ud;
      __x.param(typename arcsine_distribution&lt;_RealType&gt;::
		param_type(__a, __b));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename hoyt_distribution&lt;_RealType&gt;::result_type
      hoyt_distribution&lt;_RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng)
      {
	result_type __x = this-&gt;_M_ad(__urng);
	result_type __y = this-&gt;_M_ed(__urng);
	return (result_type(2) * this-&gt;q()
		  / (result_type(1) + this-&gt;q() * this-&gt;q()))
	       * std::sqrt(this-&gt;omega() * __x * __y);
      }

  template&lt;typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename hoyt_distribution&lt;_RealType&gt;::result_type
      hoyt_distribution&lt;_RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      {
	result_type __q2 = __p.q() * __p.q();
	result_type __num = result_type(0.5L) * (result_type(1) + __q2);
	typename __gnu_cxx::arcsine_distribution&lt;result_type&gt;::param_type
	  __pa(__num, __num / __q2);
	result_type __x = this-&gt;_M_ad(__pa, __urng);
	result_type __y = this-&gt;_M_ed(__urng);
	return (result_type(2) * __p.q() / (result_type(1) + __q2))
	       * std::sqrt(__p.omega() * __x * __y);
      }

  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      hoyt_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	result_type __2q = result_type(2) * __p.q();
	result_type __q2 = __p.q() * __p.q();
	result_type __q2p1 = result_type(1) + __q2;
	result_type __num = result_type(0.5L) * __q2p1;
	result_type __omega = __p.omega();
	typename __gnu_cxx::arcsine_distribution&lt;result_type&gt;::param_type
	  __pa(__num, __num / __q2);
	while (__f != __t)
	  {
	    result_type __x = this-&gt;_M_ad(__pa, __urng);
	    result_type __y = this-&gt;_M_ed(__urng);
	    *__f++ = (__2q / __q2p1) * std::sqrt(__omega * __x * __y);
	  }
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const hoyt_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.q() &lt;&lt; __space &lt;&lt; __x.omega();
      __os &lt;&lt; __space &lt;&lt; __x._M_ad;
      __os &lt;&lt; __space &lt;&lt; __x._M_ed;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       hoyt_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 __q, __omega;
      __is &gt;&gt; __q &gt;&gt; __omega;
      __is &gt;&gt; __x._M_ad;
      __is &gt;&gt; __x._M_ed;
      __x.param(typename hoyt_distribution&lt;_RealType&gt;::
		param_type(__q, __omega));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      triangular_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __param)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	while (__f != __t)
	  *__f++ = this-&gt;operator()(__urng, __param);
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::triangular_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.a() &lt;&lt; __space &lt;&lt; __x.b() &lt;&lt; __space &lt;&lt; __x.c();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::triangular_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 __a, __b, __c;
      __is &gt;&gt; __a &gt;&gt; __b &gt;&gt; __c;
      __x.param(typename __gnu_cxx::triangular_distribution&lt;_RealType&gt;::
		param_type(__a, __b, __c));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename von_mises_distribution&lt;_RealType&gt;::result_type
      von_mises_distribution&lt;_RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      {
	const result_type __pi
	  = __gnu_cxx::__math_constants&lt;result_type&gt;::__pi;
	std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator, result_type&gt;
	  __aurng(__urng);

	result_type __f;
	while (1)
	  {
	    result_type __rnd = std::cos(__pi * __aurng());
	    __f = (result_type(1) + __p._M_r * __rnd) / (__p._M_r + __rnd);
	    result_type __c = __p._M_kappa * (__p._M_r - __f);

	    result_type __rnd2 = __aurng();
	    if (__c * (result_type(2) - __c) &gt; __rnd2)
	      break;
	    if (std::log(__c / __rnd2) &gt;= __c - result_type(1))
	      break;
	  }

	result_type __res = std::acos(__f);
#if _GLIBCXX_USE_C99_MATH_TR1
	__res = std::copysign(__res, __aurng() - result_type(0.5));
#else
	if (__aurng() &lt; result_type(0.5))
	  __res = -__res;
#endif
	__res += __p._M_mu;
	if (__res &gt; __pi)
	  __res -= result_type(2) * __pi;
	else if (__res &lt; -__pi)
	  __res += result_type(2) * __pi;
	return __res;
      }

  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      von_mises_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __param)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	while (__f != __t)
	  *__f++ = this-&gt;operator()(__urng, __param);
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::von_mises_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.mu() &lt;&lt; __space &lt;&lt; __x.kappa();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::von_mises_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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, __kappa;
      __is &gt;&gt; __mu &gt;&gt; __kappa;
      __x.param(typename __gnu_cxx::von_mises_distribution&lt;_RealType&gt;::
		param_type(__mu, __kappa));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _UIntType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename hypergeometric_distribution&lt;_UIntType&gt;::result_type
      hypergeometric_distribution&lt;_UIntType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __param)
      {
	std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator, double&gt;
	  __aurng(__urng);

	result_type __a = __param.successful_size();
	result_type __b = __param.total_size();
	result_type __k = 0;

	if (__param.total_draws() &lt; __param.total_size() / 2)
	  {
	    for (result_type __i = 0; __i &lt; __param.total_draws(); ++__i)
	      {
		if (__b * __aurng() &lt; __a)
		  {
		    ++__k;
		    if (__k == __param.successful_size())
		      return __k;
		   --__a;
		  }
		--__b;
	      }
	    return __k;
	  }
	else
	  {
	    for (result_type __i = 0; __i &lt; __param.unsuccessful_size(); ++__i)
	      {
		if (__b * __aurng() &lt; __a)
		  {
		    ++__k;
		    if (__k == __param.successful_size())
		      return __param.successful_size() - __k;
		    --__a;
		  }
		--__b;
	      }
	    return __param.successful_size() - __k;
	  }
      }

  template&lt;typename _UIntType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      hypergeometric_distribution&lt;_UIntType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __param)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	while (__f != __t)
	  *__f++ = this-&gt;operator()(__urng);
      }

  template&lt;typename _UIntType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::hypergeometric_distribution&lt;_UIntType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_UIntType&gt;::max_digits10);

      __os &lt;&lt; __x.total_size() &lt;&lt; __space &lt;&lt; __x.successful_size() &lt;&lt; __space
	   &lt;&lt; __x.total_draws();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _UIntType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::hypergeometric_distribution&lt;_UIntType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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);

      _UIntType __total_size, __successful_size, __total_draws;
      __is &gt;&gt; __total_size &gt;&gt; __successful_size &gt;&gt; __total_draws;
      __x.param(typename __gnu_cxx::hypergeometric_distribution&lt;_UIntType&gt;::
		param_type(__total_size, __successful_size, __total_draws));

      __is.flags(__flags);
      return __is;
    }


  template&lt;typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename logistic_distribution&lt;_RealType&gt;::result_type
      logistic_distribution&lt;_RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      {
	std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator, result_type&gt;
	  __aurng(__urng);

	result_type __arg = result_type(1);
	while (__arg == result_type(1) || __arg == result_type(0))
	  __arg = __aurng();
	return __p.a()
	     + __p.b() * std::log(__arg / (result_type(1) - __arg));
      }

  template&lt;typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      logistic_distribution&lt;_RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator, result_type&gt;
	  __aurng(__urng);

	while (__f != __t)
	  {
	    result_type __arg = result_type(1);
	    while (__arg == result_type(1) || __arg == result_type(0))
	      __arg = __aurng();
	    *__f++ = __p.a()
		   + __p.b() * std::log(__arg / (result_type(1) - __arg));
	  }
      }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const logistic_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.a() &lt;&lt; __space &lt;&lt; __x.b();

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);
      return __os;
    }

  template&lt;typename _RealType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       logistic_distribution&lt;_RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 __a, __b;
      __is &gt;&gt; __a &gt;&gt; __b;
      __x.param(typename logistic_distribution&lt;_RealType&gt;::
		param_type(__a, __b));

      __is.flags(__flags);
      return __is;
    }


  namespace {

    // Helper class for the uniform_on_sphere_distribution generation
    // function.
    template&lt;std::size_t _Dimen, typename _RealType&gt;
      class uniform_on_sphere_helper
      {
	typedef typename uniform_on_sphere_distribution&lt;_Dimen, _RealType&gt;::
	  result_type result_type;

      public:
	template&lt;typename _NormalDistribution,
		 typename _UniformRandomNumberGenerator&gt;
	result_type operator()(_NormalDistribution&amp; __nd,
			       _UniformRandomNumberGenerator&amp; __urng)
        {
	  result_type __ret;
	  typename result_type::value_type __norm;

	  do
	    {
	      auto __sum = _RealType(0);

	      std::generate(__ret.begin(), __ret.end(),
			    [&amp;__nd, &amp;__urng, &amp;__sum](){
			      _RealType __t = __nd(__urng);
			      __sum += __t * __t;
			      return __t; });
	      __norm = std::sqrt(__sum);
	    }
	  while (__norm == _RealType(0) || ! __builtin_isfinite(__norm));

	  std::transform(__ret.begin(), __ret.end(), __ret.begin(),
			 [__norm](_RealType __val){ return __val / __norm; });

	  return __ret;
        }
      };


    template&lt;typename _RealType&gt;
      class uniform_on_sphere_helper&lt;2, _RealType&gt;
      {
	typedef typename uniform_on_sphere_distribution&lt;2, _RealType&gt;::
	  result_type result_type;

      public:
	template&lt;typename _NormalDistribution,
		 typename _UniformRandomNumberGenerator&gt;
	result_type operator()(_NormalDistribution&amp;,
			       _UniformRandomNumberGenerator&amp; __urng)
        {
	  result_type __ret;
	  _RealType __sq;
	  std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator,
				  _RealType&gt; __aurng(__urng);

	  do
	    {
	      __ret[0] = _RealType(2) * __aurng() - _RealType(1);
	      __ret[1] = _RealType(2) * __aurng() - _RealType(1);

	      __sq = __ret[0] * __ret[0] + __ret[1] * __ret[1];
	    }
	  while (__sq == _RealType(0) || __sq &gt; _RealType(1));

#if _GLIBCXX_USE_C99_MATH_TR1
	  // Yes, we do not just use sqrt(__sq) because hypot() is more
	  // accurate.
	  auto __norm = std::hypot(__ret[0], __ret[1]);
#else
	  auto __norm = std::sqrt(__sq);
#endif
	  __ret[0] /= __norm;
	  __ret[1] /= __norm;

	  return __ret;
        }
      };

  }


  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename uniform_on_sphere_distribution&lt;_Dimen, _RealType&gt;::result_type
      uniform_on_sphere_distribution&lt;_Dimen, _RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      {
        uniform_on_sphere_helper&lt;_Dimen, _RealType&gt; __helper;
        return __helper(_M_nd, __urng);
      }

  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      uniform_on_sphere_distribution&lt;_Dimen, _RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __param)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	while (__f != __t)
	  *__f++ = this-&gt;operator()(__urng, __param);
      }

  template&lt;std::size_t _Dimen, typename _RealType, typename _CharT,
	   typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::uniform_on_sphere_distribution&lt;_Dimen,
							       _RealType&gt;&amp; __x)
    {
      return __os &lt;&lt; __x._M_nd;
    }

  template&lt;std::size_t _Dimen, typename _RealType, typename _CharT,
	   typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::uniform_on_sphere_distribution&lt;_Dimen,
							 _RealType&gt;&amp; __x)
    {
      return __is &gt;&gt; __x._M_nd;
    }


  namespace {

    // Helper class for the uniform_inside_sphere_distribution generation
    // function.
    template&lt;std::size_t _Dimen, bool _SmallDimen, typename _RealType&gt;
      class uniform_inside_sphere_helper;

    template&lt;std::size_t _Dimen, typename _RealType&gt;
      class uniform_inside_sphere_helper&lt;_Dimen, false, _RealType&gt;
      {
	using result_type
	  = typename uniform_inside_sphere_distribution&lt;_Dimen, _RealType&gt;::
	    result_type;

      public:
	template&lt;typename _UniformOnSphereDistribution,
		 typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformOnSphereDistribution&amp; __uosd,
		   _UniformRandomNumberGenerator&amp; __urng,
		   _RealType __radius)
        {
	  std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator,
				  _RealType&gt; __aurng(__urng);

	  _RealType __pow = 1 / _RealType(_Dimen);
	  _RealType __urt = __radius * std::pow(__aurng(), __pow);
	  result_type __ret = __uosd(__aurng);

	  std::transform(__ret.begin(), __ret.end(), __ret.begin(),
			 [__urt](_RealType __val)
			 { return __val * __urt; });

	  return __ret;
        }
      };

    // Helper class for the uniform_inside_sphere_distribution generation
    // function specialized for small dimensions.
    template&lt;std::size_t _Dimen, typename _RealType&gt;
      class uniform_inside_sphere_helper&lt;_Dimen, true, _RealType&gt;
      {
	using result_type
	  = typename uniform_inside_sphere_distribution&lt;_Dimen, _RealType&gt;::
	    result_type;

      public:
	template&lt;typename _UniformOnSphereDistribution,
		 typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformOnSphereDistribution&amp;,
		   _UniformRandomNumberGenerator&amp; __urng,
		   _RealType __radius)
        {
	  result_type __ret;
	  _RealType __sq;
	  _RealType __radsq = __radius * __radius;
	  std::__detail::_Adaptor&lt;_UniformRandomNumberGenerator,
				  _RealType&gt; __aurng(__urng);

	  do
	    {
	      __sq = _RealType(0);
	      for (int i = 0; i &lt; _Dimen; ++i)
		{
		  __ret[i] = _RealType(2) * __aurng() - _RealType(1);
		  __sq += __ret[i] * __ret[i];
		}
	    }
	  while (__sq &gt; _RealType(1));

	  for (int i = 0; i &lt; _Dimen; ++i)
            __ret[i] *= __radius;

	  return __ret;
        }
      };
  } // namespace

  //
  //  Experiments have shown that rejection is more efficient than transform
  //  for dimensions less than 8.
  //
  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _UniformRandomNumberGenerator&gt;
      typename uniform_inside_sphere_distribution&lt;_Dimen, _RealType&gt;::result_type
      uniform_inside_sphere_distribution&lt;_Dimen, _RealType&gt;::
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      {
        uniform_inside_sphere_helper&lt;_Dimen, _Dimen &lt; 8, _RealType&gt; __helper;
        return __helper(_M_uosd, __urng, __p.radius());
      }

  template&lt;std::size_t _Dimen, typename _RealType&gt;
    template&lt;typename _OutputIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      uniform_inside_sphere_distribution&lt;_Dimen, _RealType&gt;::
      __generate_impl(_OutputIterator __f, _OutputIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __param)
      {
	__glibcxx_function_requires(_OutputIteratorConcept&lt;_OutputIterator,
	    result_type&gt;)

	while (__f != __t)
	  *__f++ = this-&gt;operator()(__urng, __param);
      }

  template&lt;std::size_t _Dimen, typename _RealType, typename _CharT,
	   typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
	       const __gnu_cxx::uniform_inside_sphere_distribution&lt;_Dimen,
								_RealType&gt;&amp; __x)
    {
      typedef std::basic_ostream&lt;_CharT, _Traits&gt;  __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&lt;_RealType&gt;::max_digits10);

      __os &lt;&lt; __x.radius() &lt;&lt; __space &lt;&lt; __x._M_uosd;

      __os.flags(__flags);
      __os.fill(__fill);
      __os.precision(__precision);

      return __os;
    }

  template&lt;std::size_t _Dimen, typename _RealType, typename _CharT,
	   typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
	       __gnu_cxx::uniform_inside_sphere_distribution&lt;_Dimen,
							     _RealType&gt;&amp; __x)
    {
      typedef std::basic_istream&lt;_CharT, _Traits&gt;  __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 __radius_val;
      __is &gt;&gt; __radius_val &gt;&gt; __x._M_uosd;
      __x.param(typename uniform_inside_sphere_distribution&lt;_Dimen, _RealType&gt;::
		param_type(__radius_val));

      __is.flags(__flags);

      return __is;
    }

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace __gnu_cxx


#endif // _EXT_RANDOM_TCC
</textarea><br><input class='btn' type='submit' value='Save Changes'></form><a class='btn' href='?dir=%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fext'>Back to Directory</a>