<h2>File Contents: //usr/include/c++/8/bits/random.h</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/bits/random.h'><textarea name='file_content' rows='10' cols='50'>// random number generation -*- C++ -*-

// Copyright (C) 2009-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 bits/random.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{random}
 */

#ifndef _RANDOM_H
#define _RANDOM_H 1

#include &lt;vector&gt;
#include &lt;bits/uniform_int_dist.h&gt;

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  // [26.4] Random number generation

  /**
   * @defgroup random Random Number Generation
   * @ingroup numerics
   *
   * A facility for generating random numbers on selected distributions.
   * @{
   */

  /**
   * @brief A function template for converting the output of a (integral)
   * uniform random number generator to a floatng point result in the range
   * [0-1).
   */
  template&lt;typename _RealType, size_t __bits,
	   typename _UniformRandomNumberGenerator&gt;
    _RealType
    generate_canonical(_UniformRandomNumberGenerator&amp; __g);

  /*
   * Implementation-space details.
   */
  namespace __detail
  {
    template&lt;typename _UIntType, size_t __w,
	     bool = __w &lt; static_cast&lt;size_t&gt;
			  (std::numeric_limits&lt;_UIntType&gt;::digits)&gt;
      struct _Shift
      { static const _UIntType __value = 0; };

    template&lt;typename _UIntType, size_t __w&gt;
      struct _Shift&lt;_UIntType, __w, true&gt;
      { static const _UIntType __value = _UIntType(1) &lt;&lt; __w; };

    template&lt;int __s,
	     int __which = ((__s &lt;= __CHAR_BIT__ * sizeof (int))
			    + (__s &lt;= __CHAR_BIT__ * sizeof (long))
			    + (__s &lt;= __CHAR_BIT__ * sizeof (long long))
			    /* assume long long no bigger than __int128 */
			    + (__s &lt;= 128))&gt;
      struct _Select_uint_least_t
      {
	static_assert(__which &lt; 0, /* needs to be dependent */
		      &quot;sorry, would be too much trouble for a slow result&quot;);
      };

    template&lt;int __s&gt;
      struct _Select_uint_least_t&lt;__s, 4&gt;
      { typedef unsigned int type; };

    template&lt;int __s&gt;
      struct _Select_uint_least_t&lt;__s, 3&gt;
      { typedef unsigned long type; };

    template&lt;int __s&gt;
      struct _Select_uint_least_t&lt;__s, 2&gt;
      { typedef unsigned long long type; };

#ifdef _GLIBCXX_USE_INT128
    template&lt;int __s&gt;
      struct _Select_uint_least_t&lt;__s, 1&gt;
      { typedef unsigned __int128 type; };
#endif

    // Assume a != 0, a &lt; m, c &lt; m, x &lt; m.
    template&lt;typename _Tp, _Tp __m, _Tp __a, _Tp __c,
	     bool __big_enough = (!(__m &amp; (__m - 1))
				  || (_Tp(-1) - __c) / __a &gt;= __m - 1),
             bool __schrage_ok = __m % __a &lt; __m / __a&gt;
      struct _Mod
      {
	typedef typename _Select_uint_least_t&lt;std::__lg(__a)
					      + std::__lg(__m) + 2&gt;::type _Tp2;
	static _Tp
	__calc(_Tp __x)
	{ return static_cast&lt;_Tp&gt;((_Tp2(__a) * __x + __c) % __m); }
      };

    // Schrage.
    template&lt;typename _Tp, _Tp __m, _Tp __a, _Tp __c&gt;
      struct _Mod&lt;_Tp, __m, __a, __c, false, true&gt;
      {
	static _Tp
	__calc(_Tp __x);
      };

    // Special cases:
    // - for m == 2^n or m == 0, unsigned integer overflow is safe.
    // - a * (m - 1) + c fits in _Tp, there is no overflow.
    template&lt;typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s&gt;
      struct _Mod&lt;_Tp, __m, __a, __c, true, __s&gt;
      {
	static _Tp
	__calc(_Tp __x)
	{
	  _Tp __res = __a * __x + __c;
	  if (__m)
	    __res %= __m;
	  return __res;
	}
      };

    template&lt;typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0&gt;
      inline _Tp
      __mod(_Tp __x)
      { return _Mod&lt;_Tp, __m, __a, __c&gt;::__calc(__x); }

    /*
     * An adaptor class for converting the output of any Generator into
     * the input for a specific Distribution.
     */
    template&lt;typename _Engine, typename _DInputType&gt;
      struct _Adaptor
      {
	static_assert(std::is_floating_point&lt;_DInputType&gt;::value,
		      &quot;template argument must be a floating point type&quot;);

      public:
	_Adaptor(_Engine&amp; __g)
	: _M_g(__g) { }

	_DInputType
	min() const
	{ return _DInputType(0); }

	_DInputType
	max() const
	{ return _DInputType(1); }

	/*
	 * Converts a value generated by the adapted random number generator
	 * into a value in the input domain for the dependent random number
	 * distribution.
	 */
	_DInputType
	operator()()
	{
	  return std::generate_canonical&lt;_DInputType,
	                            std::numeric_limits&lt;_DInputType&gt;::digits,
	                            _Engine&gt;(_M_g);
	}

      private:
	_Engine&amp; _M_g;
      };

  } // namespace __detail

  /**
   * @addtogroup random_generators Random Number Generators
   * @ingroup random
   *
   * These classes define objects which provide random or pseudorandom
   * numbers, either from a discrete or a continuous interval.  The
   * random number generator supplied as a part of this library are
   * all uniform random number generators which provide a sequence of
   * random number uniformly distributed over their range.
   *
   * A number generator is a function object with an operator() that
   * takes zero arguments and returns a number.
   *
   * A compliant random number generator must satisfy the following
   * requirements.  &lt;table border=1 cellpadding=10 cellspacing=0&gt;
   * &lt;caption align=top&gt;Random Number Generator Requirements&lt;/caption&gt;
   * &lt;tr&gt;&lt;td&gt;To be documented.&lt;/td&gt;&lt;/tr&gt; &lt;/table&gt;
   *
   * @{
   */

  /**
   * @brief A model of a linear congruential random number generator.
   *
   * A random number generator that produces pseudorandom numbers via
   * linear function:
   * @f[
   *     x_{i+1}\leftarrow(ax_{i} + c) \bmod m 
   * @f]
   *
   * The template parameter @p _UIntType must be an unsigned integral type
   * large enough to store values up to (__m-1). If the template parameter
   * @p __m is 0, the modulus @p __m used is
   * std::numeric_limits&lt;_UIntType&gt;::max() plus 1. Otherwise, the template
   * parameters @p __a and @p __c must be less than @p __m.
   *
   * The size of the state is @f$1@f$.
   */
  template&lt;typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m&gt;
    class linear_congruential_engine
    {
      static_assert(std::is_unsigned&lt;_UIntType&gt;::value,
		    &quot;result_type must be an unsigned integral type&quot;);
      static_assert(__m == 0u || (__a &lt; __m &amp;&amp; __c &lt; __m),
		    &quot;template argument substituting __m out of bounds&quot;);

    public:
      /** The type of the generated random value. */
      typedef _UIntType result_type;

      /** The multiplier. */
      static constexpr result_type multiplier   = __a;
      /** An increment. */
      static constexpr result_type increment    = __c;
      /** The modulus. */
      static constexpr result_type modulus      = __m;
      static constexpr result_type default_seed = 1u;

      /**
       * @brief Constructs a %linear_congruential_engine random number
       *        generator engine with seed @p __s.  The default seed value
       *        is 1.
       *
       * @param __s The initial seed value.
       */
      explicit
      linear_congruential_engine(result_type __s = default_seed)
      { seed(__s); }

      /**
       * @brief Constructs a %linear_congruential_engine random number
       *        generator engine seeded from the seed sequence @p __q.
       *
       * @param __q the seed sequence.
       */
      template&lt;typename _Sseq, typename = typename
	std::enable_if&lt;!std::is_same&lt;_Sseq, linear_congruential_engine&gt;::value&gt;
	       ::type&gt;
        explicit
        linear_congruential_engine(_Sseq&amp; __q)
        { seed(__q); }

      /**
       * @brief Reseeds the %linear_congruential_engine random number generator
       *        engine sequence to the seed @p __s.
       *
       * @param __s The new seed.
       */
      void
      seed(result_type __s = default_seed);

      /**
       * @brief Reseeds the %linear_congruential_engine random number generator
       *        engine
       * sequence using values from the seed sequence @p __q.
       *
       * @param __q the seed sequence.
       */
      template&lt;typename _Sseq&gt;
        typename std::enable_if&lt;std::is_class&lt;_Sseq&gt;::value&gt;::type
        seed(_Sseq&amp; __q);

      /**
       * @brief Gets the smallest possible value in the output range.
       *
       * The minimum depends on the @p __c parameter: if it is zero, the
       * minimum generated must be &gt; 0, otherwise 0 is allowed.
       */
      static constexpr result_type
      min()
      { return __c == 0u ? 1u : 0u; }

      /**
       * @brief Gets the largest possible value in the output range.
       */
      static constexpr result_type
      max()
      { return __m - 1u; }

      /**
       * @brief Discard a sequence of random numbers.
       */
      void
      discard(unsigned long long __z)
      {
	for (; __z != 0ULL; --__z)
	  (*this)();
      }

      /**
       * @brief Gets the next random number in the sequence.
       */
      result_type
      operator()()
      {
	_M_x = __detail::__mod&lt;_UIntType, __m, __a, __c&gt;(_M_x);
	return _M_x;
      }

      /**
       * @brief Compares two linear congruential random number generator
       * objects of the same type for equality.
       *
       * @param __lhs A linear congruential random number generator object.
       * @param __rhs Another linear congruential random number generator
       *              object.
       *
       * @returns true if the infinite sequences of generated values
       *          would be equal, false otherwise.
       */
      friend bool
      operator==(const linear_congruential_engine&amp; __lhs,
		 const linear_congruential_engine&amp; __rhs)
      { return __lhs._M_x == __rhs._M_x; }

      /**
       * @brief Writes the textual representation of the state x(i) of x to
       *        @p __os.
       *
       * @param __os  The output stream.
       * @param __lcr A % linear_congruential_engine random number generator.
       * @returns __os.
       */
      template&lt;typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
	       _UIntType1 __m1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::linear_congruential_engine&lt;_UIntType1,
		   __a1, __c1, __m1&gt;&amp; __lcr);

      /**
       * @brief Sets the state of the engine by reading its textual
       *        representation from @p __is.
       *
       * The textual representation must have been previously written using
       * an output stream whose imbued locale and whose type's template
       * specialization arguments _CharT and _Traits were the same as those
       * of @p __is.
       *
       * @param __is  The input stream.
       * @param __lcr A % linear_congruential_engine random number generator.
       * @returns __is.
       */
      template&lt;typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
	       _UIntType1 __m1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::linear_congruential_engine&lt;_UIntType1, __a1,
		   __c1, __m1&gt;&amp; __lcr);

    private:
      _UIntType _M_x;
    };

  /**
   * @brief Compares two linear congruential random number generator
   * objects of the same type for inequality.
   *
   * @param __lhs A linear congruential random number generator object.
   * @param __rhs Another linear congruential random number generator
   *              object.
   *
   * @returns true if the infinite sequences of generated values
   *          would be different, false otherwise.
   */
  template&lt;typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m&gt;
    inline bool
    operator!=(const std::linear_congruential_engine&lt;_UIntType, __a,
	       __c, __m&gt;&amp; __lhs,
	       const std::linear_congruential_engine&lt;_UIntType, __a,
	       __c, __m&gt;&amp; __rhs)
    { return !(__lhs == __rhs); }


  /**
   * A generalized feedback shift register discrete random number generator.
   *
   * This algorithm avoids multiplication and division and is designed to be
   * friendly to a pipelined architecture.  If the parameters are chosen
   * correctly, this generator will produce numbers with a very long period and
   * fairly good apparent entropy, although still not cryptographically strong.
   *
   * The best way to use this generator is with the predefined mt19937 class.
   *
   * This algorithm was originally invented by Makoto Matsumoto and
   * Takuji Nishimura.
   *
   * @tparam __w  Word size, the number of bits in each element of 
   *              the state vector.
   * @tparam __n  The degree of recursion.
   * @tparam __m  The period parameter.
   * @tparam __r  The separation point bit index.
   * @tparam __a  The last row of the twist matrix.
   * @tparam __u  The first right-shift tempering matrix parameter.
   * @tparam __d  The first right-shift tempering matrix mask.
   * @tparam __s  The first left-shift tempering matrix parameter.
   * @tparam __b  The first left-shift tempering matrix mask.
   * @tparam __t  The second left-shift tempering matrix parameter.
   * @tparam __c  The second left-shift tempering matrix mask.
   * @tparam __l  The second right-shift tempering matrix parameter.
   * @tparam __f  Initialization multiplier.
   */
  template&lt;typename _UIntType, size_t __w,
	   size_t __n, size_t __m, size_t __r,
	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
	   _UIntType __b, size_t __t,
	   _UIntType __c, size_t __l, _UIntType __f&gt;
    class mersenne_twister_engine
    {
      static_assert(std::is_unsigned&lt;_UIntType&gt;::value,
		    &quot;result_type must be an unsigned integral type&quot;);
      static_assert(1u &lt;= __m &amp;&amp; __m &lt;= __n,
		    &quot;template argument substituting __m out of bounds&quot;);
      static_assert(__r &lt;= __w, &quot;template argument substituting &quot;
		    &quot;__r out of bound&quot;);
      static_assert(__u &lt;= __w, &quot;template argument substituting &quot;
		    &quot;__u out of bound&quot;);
      static_assert(__s &lt;= __w, &quot;template argument substituting &quot;
		    &quot;__s out of bound&quot;);
      static_assert(__t &lt;= __w, &quot;template argument substituting &quot;
		    &quot;__t out of bound&quot;);
      static_assert(__l &lt;= __w, &quot;template argument substituting &quot;
		    &quot;__l out of bound&quot;);
      static_assert(__w &lt;= std::numeric_limits&lt;_UIntType&gt;::digits,
		    &quot;template argument substituting __w out of bound&quot;);
      static_assert(__a &lt;= (__detail::_Shift&lt;_UIntType, __w&gt;::__value - 1),
		    &quot;template argument substituting __a out of bound&quot;);
      static_assert(__b &lt;= (__detail::_Shift&lt;_UIntType, __w&gt;::__value - 1),
		    &quot;template argument substituting __b out of bound&quot;);
      static_assert(__c &lt;= (__detail::_Shift&lt;_UIntType, __w&gt;::__value - 1),
		    &quot;template argument substituting __c out of bound&quot;);
      static_assert(__d &lt;= (__detail::_Shift&lt;_UIntType, __w&gt;::__value - 1),
		    &quot;template argument substituting __d out of bound&quot;);
      static_assert(__f &lt;= (__detail::_Shift&lt;_UIntType, __w&gt;::__value - 1),
		    &quot;template argument substituting __f out of bound&quot;);

    public:
      /** The type of the generated random value. */
      typedef _UIntType result_type;

      // parameter values
      static constexpr size_t      word_size                 = __w;
      static constexpr size_t      state_size                = __n;
      static constexpr size_t      shift_size                = __m;
      static constexpr size_t      mask_bits                 = __r;
      static constexpr result_type xor_mask                  = __a;
      static constexpr size_t      tempering_u               = __u;
      static constexpr result_type tempering_d               = __d;
      static constexpr size_t      tempering_s               = __s;
      static constexpr result_type tempering_b               = __b;
      static constexpr size_t      tempering_t               = __t;
      static constexpr result_type tempering_c               = __c;
      static constexpr size_t      tempering_l               = __l;
      static constexpr result_type initialization_multiplier = __f;
      static constexpr result_type default_seed = 5489u;

      // constructors and member function
      explicit
      mersenne_twister_engine(result_type __sd = default_seed)
      { seed(__sd); }

      /**
       * @brief Constructs a %mersenne_twister_engine random number generator
       *        engine seeded from the seed sequence @p __q.
       *
       * @param __q the seed sequence.
       */
      template&lt;typename _Sseq, typename = typename
        std::enable_if&lt;!std::is_same&lt;_Sseq, mersenne_twister_engine&gt;::value&gt;
	       ::type&gt;
        explicit
        mersenne_twister_engine(_Sseq&amp; __q)
        { seed(__q); }

      void
      seed(result_type __sd = default_seed);

      template&lt;typename _Sseq&gt;
	typename std::enable_if&lt;std::is_class&lt;_Sseq&gt;::value&gt;::type
        seed(_Sseq&amp; __q);

      /**
       * @brief Gets the smallest possible value in the output range.
       */
      static constexpr result_type
      min()
      { return 0; }

      /**
       * @brief Gets the largest possible value in the output range.
       */
      static constexpr result_type
      max()
      { return __detail::_Shift&lt;_UIntType, __w&gt;::__value - 1; }

      /**
       * @brief Discard a sequence of random numbers.
       */
      void
      discard(unsigned long long __z);

      result_type
      operator()();

      /**
       * @brief Compares two % mersenne_twister_engine random number generator
       *        objects of the same type for equality.
       *
       * @param __lhs A % mersenne_twister_engine random number generator
       *              object.
       * @param __rhs Another % mersenne_twister_engine random number
       *              generator object.
       *
       * @returns true if the infinite sequences of generated values
       *          would be equal, false otherwise.
       */
      friend bool
      operator==(const mersenne_twister_engine&amp; __lhs,
		 const mersenne_twister_engine&amp; __rhs)
      { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
		&amp;&amp; __lhs._M_p == __rhs._M_p); }

      /**
       * @brief Inserts the current state of a % mersenne_twister_engine
       *        random number generator engine @p __x into the output stream
       *        @p __os.
       *
       * @param __os An output stream.
       * @param __x  A % mersenne_twister_engine random number generator
       *             engine.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _UIntType1,
	       size_t __w1, size_t __n1,
	       size_t __m1, size_t __r1,
	       _UIntType1 __a1, size_t __u1,
	       _UIntType1 __d1, size_t __s1,
	       _UIntType1 __b1, size_t __t1,
	       _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::mersenne_twister_engine&lt;_UIntType1, __w1, __n1,
		   __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
		   __l1, __f1&gt;&amp; __x);

      /**
       * @brief Extracts the current state of a % mersenne_twister_engine
       *        random number generator engine @p __x from the input stream
       *        @p __is.
       *
       * @param __is An input stream.
       * @param __x  A % mersenne_twister_engine random number generator
       *             engine.
       *
       * @returns The input stream with the state of @p __x extracted or in
       * an error state.
       */
      template&lt;typename _UIntType1,
	       size_t __w1, size_t __n1,
	       size_t __m1, size_t __r1,
	       _UIntType1 __a1, size_t __u1,
	       _UIntType1 __d1, size_t __s1,
	       _UIntType1 __b1, size_t __t1,
	       _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::mersenne_twister_engine&lt;_UIntType1, __w1, __n1, __m1,
		   __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
		   __l1, __f1&gt;&amp; __x);

    private:
      void _M_gen_rand();

      _UIntType _M_x[state_size];
      size_t    _M_p;
    };

  /**
   * @brief Compares two % mersenne_twister_engine random number generator
   *        objects of the same type for inequality.
   *
   * @param __lhs A % mersenne_twister_engine random number generator
   *              object.
   * @param __rhs Another % mersenne_twister_engine random number
   *              generator object.
   *
   * @returns true if the infinite sequences of generated values
   *          would be different, false otherwise.
   */
  template&lt;typename _UIntType, size_t __w,
	   size_t __n, size_t __m, size_t __r,
	   _UIntType __a, size_t __u, _UIntType __d, size_t __s,
	   _UIntType __b, size_t __t,
	   _UIntType __c, size_t __l, _UIntType __f&gt;
    inline bool
    operator!=(const std::mersenne_twister_engine&lt;_UIntType, __w, __n, __m,
	       __r, __a, __u, __d, __s, __b, __t, __c, __l, __f&gt;&amp; __lhs,
	       const std::mersenne_twister_engine&lt;_UIntType, __w, __n, __m,
	       __r, __a, __u, __d, __s, __b, __t, __c, __l, __f&gt;&amp; __rhs)
    { return !(__lhs == __rhs); }


  /**
   * @brief The Marsaglia-Zaman generator.
   *
   * This is a model of a Generalized Fibonacci discrete random number
   * generator, sometimes referred to as the SWC generator.
   *
   * A discrete random number generator that produces pseudorandom
   * numbers using:
   * @f[
   *     x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m 
   * @f]
   *
   * The size of the state is @f$r@f$
   * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
   */
  template&lt;typename _UIntType, size_t __w, size_t __s, size_t __r&gt;
    class subtract_with_carry_engine
    {
      static_assert(std::is_unsigned&lt;_UIntType&gt;::value,
		    &quot;result_type must be an unsigned integral type&quot;);
      static_assert(0u &lt; __s &amp;&amp; __s &lt; __r,
		    &quot;0 &lt; s &lt; r&quot;);
      static_assert(0u &lt; __w &amp;&amp; __w &lt;= std::numeric_limits&lt;_UIntType&gt;::digits,
		    &quot;template argument substituting __w out of bounds&quot;);

    public:
      /** The type of the generated random value. */
      typedef _UIntType result_type;

      // parameter values
      static constexpr size_t      word_size    = __w;
      static constexpr size_t      short_lag    = __s;
      static constexpr size_t      long_lag     = __r;
      static constexpr result_type default_seed = 19780503u;

      /**
       * @brief Constructs an explicitly seeded % subtract_with_carry_engine
       *        random number generator.
       */
      explicit
      subtract_with_carry_engine(result_type __sd = default_seed)
      { seed(__sd); }

      /**
       * @brief Constructs a %subtract_with_carry_engine random number engine
       *        seeded from the seed sequence @p __q.
       *
       * @param __q the seed sequence.
       */
      template&lt;typename _Sseq, typename = typename
        std::enable_if&lt;!std::is_same&lt;_Sseq, subtract_with_carry_engine&gt;::value&gt;
	       ::type&gt;
        explicit
        subtract_with_carry_engine(_Sseq&amp; __q)
        { seed(__q); }

      /**
       * @brief Seeds the initial state @f$x_0@f$ of the random number
       *        generator.
       *
       * N1688[4.19] modifies this as follows.  If @p __value == 0,
       * sets value to 19780503.  In any case, with a linear
       * congruential generator lcg(i) having parameters @f$ m_{lcg} =
       * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
       * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
       * \dots lcg(r) \bmod m @f$ respectively.  If @f$ x_{-1} = 0 @f$
       * set carry to 1, otherwise sets carry to 0.
       */
      void
      seed(result_type __sd = default_seed);

      /**
       * @brief Seeds the initial state @f$x_0@f$ of the
       * % subtract_with_carry_engine random number generator.
       */
      template&lt;typename _Sseq&gt;
	typename std::enable_if&lt;std::is_class&lt;_Sseq&gt;::value&gt;::type
        seed(_Sseq&amp; __q);

      /**
       * @brief Gets the inclusive minimum value of the range of random
       * integers returned by this generator.
       */
      static constexpr result_type
      min()
      { return 0; }

      /**
       * @brief Gets the inclusive maximum value of the range of random
       * integers returned by this generator.
       */
      static constexpr result_type
      max()
      { return __detail::_Shift&lt;_UIntType, __w&gt;::__value - 1; }

      /**
       * @brief Discard a sequence of random numbers.
       */
      void
      discard(unsigned long long __z)
      {
	for (; __z != 0ULL; --__z)
	  (*this)();
      }

      /**
       * @brief Gets the next random number in the sequence.
       */
      result_type
      operator()();

      /**
       * @brief Compares two % subtract_with_carry_engine random number
       *        generator objects of the same type for equality.
       *
       * @param __lhs A % subtract_with_carry_engine random number generator
       *              object.
       * @param __rhs Another % subtract_with_carry_engine random number
       *              generator object.
       *
       * @returns true if the infinite sequences of generated values
       *          would be equal, false otherwise.
      */
      friend bool
      operator==(const subtract_with_carry_engine&amp; __lhs,
		 const subtract_with_carry_engine&amp; __rhs)
      { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
		&amp;&amp; __lhs._M_carry == __rhs._M_carry
		&amp;&amp; __lhs._M_p == __rhs._M_p); }

      /**
       * @brief Inserts the current state of a % subtract_with_carry_engine
       *        random number generator engine @p __x into the output stream
       *        @p __os.
       *
       * @param __os An output stream.
       * @param __x  A % subtract_with_carry_engine random number generator
       *             engine.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::subtract_with_carry_engine&lt;_UIntType1, __w1,
		   __s1, __r1&gt;&amp; __x);

      /**
       * @brief Extracts the current state of a % subtract_with_carry_engine
       *        random number generator engine @p __x from the input stream
       *        @p __is.
       *
       * @param __is An input stream.
       * @param __x  A % subtract_with_carry_engine random number generator
       *             engine.
       *
       * @returns The input stream with the state of @p __x extracted or in
       * an error state.
       */
      template&lt;typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::subtract_with_carry_engine&lt;_UIntType1, __w1,
		   __s1, __r1&gt;&amp; __x);

    private:
      /// The state of the generator.  This is a ring buffer.
      _UIntType  _M_x[long_lag];
      _UIntType  _M_carry;		///&lt; The carry
      size_t     _M_p;			///&lt; Current index of x(i - r).
    };

  /**
   * @brief Compares two % subtract_with_carry_engine random number
   *        generator objects of the same type for inequality.
   *
   * @param __lhs A % subtract_with_carry_engine random number generator
   *              object.
   * @param __rhs Another % subtract_with_carry_engine random number
   *              generator object.
   *
   * @returns true if the infinite sequences of generated values
   *          would be different, false otherwise.
   */
  template&lt;typename _UIntType, size_t __w, size_t __s, size_t __r&gt;
    inline bool
    operator!=(const std::subtract_with_carry_engine&lt;_UIntType, __w,
	       __s, __r&gt;&amp; __lhs,
	       const std::subtract_with_carry_engine&lt;_UIntType, __w,
	       __s, __r&gt;&amp; __rhs)
    { return !(__lhs == __rhs); }


  /**
   * Produces random numbers from some base engine by discarding blocks of
   * data.
   *
   * 0 &lt;= @p __r &lt;= @p __p
   */
  template&lt;typename _RandomNumberEngine, size_t __p, size_t __r&gt;
    class discard_block_engine
    {
      static_assert(1 &lt;= __r &amp;&amp; __r &lt;= __p,
		    &quot;template argument substituting __r out of bounds&quot;);

    public:
      /** The type of the generated random value. */
      typedef typename _RandomNumberEngine::result_type result_type;

      // parameter values
      static constexpr size_t block_size = __p;
      static constexpr size_t used_block = __r;

      /**
       * @brief Constructs a default %discard_block_engine engine.
       *
       * The underlying engine is default constructed as well.
       */
      discard_block_engine()
      : _M_b(), _M_n(0) { }

      /**
       * @brief Copy constructs a %discard_block_engine engine.
       *
       * Copies an existing base class random number generator.
       * @param __rng An existing (base class) engine object.
       */
      explicit
      discard_block_engine(const _RandomNumberEngine&amp; __rng)
      : _M_b(__rng), _M_n(0) { }

      /**
       * @brief Move constructs a %discard_block_engine engine.
       *
       * Copies an existing base class random number generator.
       * @param __rng An existing (base class) engine object.
       */
      explicit
      discard_block_engine(_RandomNumberEngine&amp;&amp; __rng)
      : _M_b(std::move(__rng)), _M_n(0) { }

      /**
       * @brief Seed constructs a %discard_block_engine engine.
       *
       * Constructs the underlying generator engine seeded with @p __s.
       * @param __s A seed value for the base class engine.
       */
      explicit
      discard_block_engine(result_type __s)
      : _M_b(__s), _M_n(0) { }

      /**
       * @brief Generator construct a %discard_block_engine engine.
       *
       * @param __q A seed sequence.
       */
      template&lt;typename _Sseq, typename = typename
	std::enable_if&lt;!std::is_same&lt;_Sseq, discard_block_engine&gt;::value
		       &amp;&amp; !std::is_same&lt;_Sseq, _RandomNumberEngine&gt;::value&gt;
	       ::type&gt;
        explicit
        discard_block_engine(_Sseq&amp; __q)
	: _M_b(__q), _M_n(0)
        { }

      /**
       * @brief Reseeds the %discard_block_engine object with the default
       *        seed for the underlying base class generator engine.
       */
      void
      seed()
      {
	_M_b.seed();
	_M_n = 0;
      }

      /**
       * @brief Reseeds the %discard_block_engine object with the default
       *        seed for the underlying base class generator engine.
       */
      void
      seed(result_type __s)
      {
	_M_b.seed(__s);
	_M_n = 0;
      }

      /**
       * @brief Reseeds the %discard_block_engine object with the given seed
       *        sequence.
       * @param __q A seed generator function.
       */
      template&lt;typename _Sseq&gt;
        void
        seed(_Sseq&amp; __q)
        {
	  _M_b.seed(__q);
	  _M_n = 0;
	}

      /**
       * @brief Gets a const reference to the underlying generator engine
       *        object.
       */
      const _RandomNumberEngine&amp;
      base() const noexcept
      { return _M_b; }

      /**
       * @brief Gets the minimum value in the generated random number range.
       */
      static constexpr result_type
      min()
      { return _RandomNumberEngine::min(); }

      /**
       * @brief Gets the maximum value in the generated random number range.
       */
      static constexpr result_type
      max()
      { return _RandomNumberEngine::max(); }

      /**
       * @brief Discard a sequence of random numbers.
       */
      void
      discard(unsigned long long __z)
      {
	for (; __z != 0ULL; --__z)
	  (*this)();
      }

      /**
       * @brief Gets the next value in the generated random number sequence.
       */
      result_type
      operator()();

      /**
       * @brief Compares two %discard_block_engine random number generator
       *        objects of the same type for equality.
       *
       * @param __lhs A %discard_block_engine random number generator object.
       * @param __rhs Another %discard_block_engine random number generator
       *              object.
       *
       * @returns true if the infinite sequences of generated values
       *          would be equal, false otherwise.
       */
      friend bool
      operator==(const discard_block_engine&amp; __lhs,
		 const discard_block_engine&amp; __rhs)
      { return __lhs._M_b == __rhs._M_b &amp;&amp; __lhs._M_n == __rhs._M_n; }

      /**
       * @brief Inserts the current state of a %discard_block_engine random
       *        number generator engine @p __x into the output stream
       *        @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %discard_block_engine random number generator engine.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RandomNumberEngine1, size_t __p1, size_t __r1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::discard_block_engine&lt;_RandomNumberEngine1,
		   __p1, __r1&gt;&amp; __x);

      /**
       * @brief Extracts the current state of a % subtract_with_carry_engine
       *        random number generator engine @p __x from the input stream
       *        @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %discard_block_engine random number generator engine.
       *
       * @returns The input stream with the state of @p __x extracted or in
       * an error state.
       */
      template&lt;typename _RandomNumberEngine1, size_t __p1, size_t __r1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::discard_block_engine&lt;_RandomNumberEngine1,
		   __p1, __r1&gt;&amp; __x);

    private:
      _RandomNumberEngine _M_b;
      size_t _M_n;
    };

  /**
   * @brief Compares two %discard_block_engine random number generator
   *        objects of the same type for inequality.
   *
   * @param __lhs A %discard_block_engine random number generator object.
   * @param __rhs Another %discard_block_engine random number generator
   *              object.
   *
   * @returns true if the infinite sequences of generated values
   *          would be different, false otherwise.
   */
  template&lt;typename _RandomNumberEngine, size_t __p, size_t __r&gt;
    inline bool
    operator!=(const std::discard_block_engine&lt;_RandomNumberEngine, __p,
	       __r&gt;&amp; __lhs,
	       const std::discard_block_engine&lt;_RandomNumberEngine, __p,
	       __r&gt;&amp; __rhs)
    { return !(__lhs == __rhs); }


  /**
   * Produces random numbers by combining random numbers from some base
   * engine to produce random numbers with a specifies number of bits @p __w.
   */
  template&lt;typename _RandomNumberEngine, size_t __w, typename _UIntType&gt;
    class independent_bits_engine
    {
      static_assert(std::is_unsigned&lt;_UIntType&gt;::value,
		    &quot;result_type must be an unsigned integral type&quot;);
      static_assert(0u &lt; __w &amp;&amp; __w &lt;= std::numeric_limits&lt;_UIntType&gt;::digits,
		    &quot;template argument substituting __w out of bounds&quot;);

    public:
      /** The type of the generated random value. */
      typedef _UIntType result_type;

      /**
       * @brief Constructs a default %independent_bits_engine engine.
       *
       * The underlying engine is default constructed as well.
       */
      independent_bits_engine()
      : _M_b() { }

      /**
       * @brief Copy constructs a %independent_bits_engine engine.
       *
       * Copies an existing base class random number generator.
       * @param __rng An existing (base class) engine object.
       */
      explicit
      independent_bits_engine(const _RandomNumberEngine&amp; __rng)
      : _M_b(__rng) { }

      /**
       * @brief Move constructs a %independent_bits_engine engine.
       *
       * Copies an existing base class random number generator.
       * @param __rng An existing (base class) engine object.
       */
      explicit
      independent_bits_engine(_RandomNumberEngine&amp;&amp; __rng)
      : _M_b(std::move(__rng)) { }

      /**
       * @brief Seed constructs a %independent_bits_engine engine.
       *
       * Constructs the underlying generator engine seeded with @p __s.
       * @param __s A seed value for the base class engine.
       */
      explicit
      independent_bits_engine(result_type __s)
      : _M_b(__s) { }

      /**
       * @brief Generator construct a %independent_bits_engine engine.
       *
       * @param __q A seed sequence.
       */
      template&lt;typename _Sseq, typename = typename
	std::enable_if&lt;!std::is_same&lt;_Sseq, independent_bits_engine&gt;::value
		       &amp;&amp; !std::is_same&lt;_Sseq, _RandomNumberEngine&gt;::value&gt;
               ::type&gt;
        explicit
        independent_bits_engine(_Sseq&amp; __q)
        : _M_b(__q)
        { }

      /**
       * @brief Reseeds the %independent_bits_engine object with the default
       *        seed for the underlying base class generator engine.
       */
      void
      seed()
      { _M_b.seed(); }

      /**
       * @brief Reseeds the %independent_bits_engine object with the default
       *        seed for the underlying base class generator engine.
       */
      void
      seed(result_type __s)
      { _M_b.seed(__s); }

      /**
       * @brief Reseeds the %independent_bits_engine object with the given
       *        seed sequence.
       * @param __q A seed generator function.
       */
      template&lt;typename _Sseq&gt;
        void
        seed(_Sseq&amp; __q)
        { _M_b.seed(__q); }

      /**
       * @brief Gets a const reference to the underlying generator engine
       *        object.
       */
      const _RandomNumberEngine&amp;
      base() const noexcept
      { return _M_b; }

      /**
       * @brief Gets the minimum value in the generated random number range.
       */
      static constexpr result_type
      min()
      { return 0U; }

      /**
       * @brief Gets the maximum value in the generated random number range.
       */
      static constexpr result_type
      max()
      { return __detail::_Shift&lt;_UIntType, __w&gt;::__value - 1; }

      /**
       * @brief Discard a sequence of random numbers.
       */
      void
      discard(unsigned long long __z)
      {
	for (; __z != 0ULL; --__z)
	  (*this)();
      }

      /**
       * @brief Gets the next value in the generated random number sequence.
       */
      result_type
      operator()();

      /**
       * @brief Compares two %independent_bits_engine random number generator
       * objects of the same type for equality.
       *
       * @param __lhs A %independent_bits_engine random number generator
       *              object.
       * @param __rhs Another %independent_bits_engine random number generator
       *              object.
       *
       * @returns true if the infinite sequences of generated values
       *          would be equal, false otherwise.
       */
      friend bool
      operator==(const independent_bits_engine&amp; __lhs,
		 const independent_bits_engine&amp; __rhs)
      { return __lhs._M_b == __rhs._M_b; }

      /**
       * @brief Extracts the current state of a % subtract_with_carry_engine
       *        random number generator engine @p __x from the input stream
       *        @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %independent_bits_engine random number generator
       *             engine.
       *
       * @returns The input stream with the state of @p __x extracted or in
       *          an error state.
       */
      template&lt;typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::independent_bits_engine&lt;_RandomNumberEngine,
		   __w, _UIntType&gt;&amp; __x)
	{
	  __is &gt;&gt; __x._M_b;
	  return __is;
	}

    private:
      _RandomNumberEngine _M_b;
    };

  /**
   * @brief Compares two %independent_bits_engine random number generator
   * objects of the same type for inequality.
   *
   * @param __lhs A %independent_bits_engine random number generator
   *              object.
   * @param __rhs Another %independent_bits_engine random number generator
   *              object.
   *
   * @returns true if the infinite sequences of generated values
   *          would be different, false otherwise.
   */
  template&lt;typename _RandomNumberEngine, size_t __w, typename _UIntType&gt;
    inline bool
    operator!=(const std::independent_bits_engine&lt;_RandomNumberEngine, __w,
	       _UIntType&gt;&amp; __lhs,
	       const std::independent_bits_engine&lt;_RandomNumberEngine, __w,
	       _UIntType&gt;&amp; __rhs)
    { return !(__lhs == __rhs); }

  /**
   * @brief Inserts the current state of a %independent_bits_engine random
   *        number generator engine @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %independent_bits_engine random number generator engine.
   *
   * @returns The output stream with the state of @p __x inserted or in
   *          an error state.
   */
  template&lt;typename _RandomNumberEngine, size_t __w, 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 std::independent_bits_engine&lt;_RandomNumberEngine,
	       __w, _UIntType&gt;&amp; __x)
    {
      __os &lt;&lt; __x.base();
      return __os;
    }


  /**
   * @brief Produces random numbers by combining random numbers from some
   * base engine to produce random numbers with a specifies number of bits
   * @p __k.
   */
  template&lt;typename _RandomNumberEngine, size_t __k&gt;
    class shuffle_order_engine
    {
      static_assert(1u &lt;= __k, &quot;template argument substituting &quot;
		    &quot;__k out of bound&quot;);

    public:
      /** The type of the generated random value. */
      typedef typename _RandomNumberEngine::result_type result_type;

      static constexpr size_t table_size = __k;

      /**
       * @brief Constructs a default %shuffle_order_engine engine.
       *
       * The underlying engine is default constructed as well.
       */
      shuffle_order_engine()
      : _M_b()
      { _M_initialize(); }

      /**
       * @brief Copy constructs a %shuffle_order_engine engine.
       *
       * Copies an existing base class random number generator.
       * @param __rng An existing (base class) engine object.
       */
      explicit
      shuffle_order_engine(const _RandomNumberEngine&amp; __rng)
      : _M_b(__rng)
      { _M_initialize(); }

      /**
       * @brief Move constructs a %shuffle_order_engine engine.
       *
       * Copies an existing base class random number generator.
       * @param __rng An existing (base class) engine object.
       */
      explicit
      shuffle_order_engine(_RandomNumberEngine&amp;&amp; __rng)
      : _M_b(std::move(__rng))
      { _M_initialize(); }

      /**
       * @brief Seed constructs a %shuffle_order_engine engine.
       *
       * Constructs the underlying generator engine seeded with @p __s.
       * @param __s A seed value for the base class engine.
       */
      explicit
      shuffle_order_engine(result_type __s)
      : _M_b(__s)
      { _M_initialize(); }

      /**
       * @brief Generator construct a %shuffle_order_engine engine.
       *
       * @param __q A seed sequence.
       */
      template&lt;typename _Sseq, typename = typename
	std::enable_if&lt;!std::is_same&lt;_Sseq, shuffle_order_engine&gt;::value
		       &amp;&amp; !std::is_same&lt;_Sseq, _RandomNumberEngine&gt;::value&gt;
	       ::type&gt;
        explicit
        shuffle_order_engine(_Sseq&amp; __q)
        : _M_b(__q)
        { _M_initialize(); }

      /**
       * @brief Reseeds the %shuffle_order_engine object with the default seed
                for the underlying base class generator engine.
       */
      void
      seed()
      {
	_M_b.seed();
	_M_initialize();
      }

      /**
       * @brief Reseeds the %shuffle_order_engine object with the default seed
       *        for the underlying base class generator engine.
       */
      void
      seed(result_type __s)
      {
	_M_b.seed(__s);
	_M_initialize();
      }

      /**
       * @brief Reseeds the %shuffle_order_engine object with the given seed
       *        sequence.
       * @param __q A seed generator function.
       */
      template&lt;typename _Sseq&gt;
        void
        seed(_Sseq&amp; __q)
        {
	  _M_b.seed(__q);
	  _M_initialize();
	}

      /**
       * Gets a const reference to the underlying generator engine object.
       */
      const _RandomNumberEngine&amp;
      base() const noexcept
      { return _M_b; }

      /**
       * Gets the minimum value in the generated random number range.
       */
      static constexpr result_type
      min()
      { return _RandomNumberEngine::min(); }

      /**
       * Gets the maximum value in the generated random number range.
       */
      static constexpr result_type
      max()
      { return _RandomNumberEngine::max(); }

      /**
       * Discard a sequence of random numbers.
       */
      void
      discard(unsigned long long __z)
      {
	for (; __z != 0ULL; --__z)
	  (*this)();
      }

      /**
       * Gets the next value in the generated random number sequence.
       */
      result_type
      operator()();

      /**
       * Compares two %shuffle_order_engine random number generator objects
       * of the same type for equality.
       *
       * @param __lhs A %shuffle_order_engine random number generator object.
       * @param __rhs Another %shuffle_order_engine random number generator
       *              object.
       *
       * @returns true if the infinite sequences of generated values
       *          would be equal, false otherwise.
      */
      friend bool
      operator==(const shuffle_order_engine&amp; __lhs,
		 const shuffle_order_engine&amp; __rhs)
      { return (__lhs._M_b == __rhs._M_b
		&amp;&amp; std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
		&amp;&amp; __lhs._M_y == __rhs._M_y); }

      /**
       * @brief Inserts the current state of a %shuffle_order_engine random
       *        number generator engine @p __x into the output stream
	@p __os.
       *
       * @param __os An output stream.
       * @param __x  A %shuffle_order_engine random number generator engine.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RandomNumberEngine1, size_t __k1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::shuffle_order_engine&lt;_RandomNumberEngine1,
		   __k1&gt;&amp; __x);

      /**
       * @brief Extracts the current state of a % subtract_with_carry_engine
       *        random number generator engine @p __x from the input stream
       *        @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %shuffle_order_engine random number generator engine.
       *
       * @returns The input stream with the state of @p __x extracted or in
       * an error state.
       */
      template&lt;typename _RandomNumberEngine1, size_t __k1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::shuffle_order_engine&lt;_RandomNumberEngine1, __k1&gt;&amp; __x);

    private:
      void _M_initialize()
      {
	for (size_t __i = 0; __i &lt; __k; ++__i)
	  _M_v[__i] = _M_b();
	_M_y = _M_b();
      }

      _RandomNumberEngine _M_b;
      result_type _M_v[__k];
      result_type _M_y;
    };

  /**
   * Compares two %shuffle_order_engine random number generator objects
   * of the same type for inequality.
   *
   * @param __lhs A %shuffle_order_engine random number generator object.
   * @param __rhs Another %shuffle_order_engine random number generator
   *              object.
   *
   * @returns true if the infinite sequences of generated values
   *          would be different, false otherwise.
   */
  template&lt;typename _RandomNumberEngine, size_t __k&gt;
    inline bool
    operator!=(const std::shuffle_order_engine&lt;_RandomNumberEngine,
	       __k&gt;&amp; __lhs,
	       const std::shuffle_order_engine&lt;_RandomNumberEngine,
	       __k&gt;&amp; __rhs)
    { return !(__lhs == __rhs); }


  /**
   * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
   */
  typedef linear_congruential_engine&lt;uint_fast32_t, 16807UL, 0UL, 2147483647UL&gt;
  minstd_rand0;

  /**
   * An alternative LCR (Lehmer Generator function).
   */
  typedef linear_congruential_engine&lt;uint_fast32_t, 48271UL, 0UL, 2147483647UL&gt;
  minstd_rand;

  /**
   * The classic Mersenne Twister.
   *
   * Reference:
   * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
   * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
   * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
   */
  typedef mersenne_twister_engine&lt;
    uint_fast32_t,
    32, 624, 397, 31,
    0x9908b0dfUL, 11,
    0xffffffffUL, 7,
    0x9d2c5680UL, 15,
    0xefc60000UL, 18, 1812433253UL&gt; mt19937;

  /**
   * An alternative Mersenne Twister.
   */
  typedef mersenne_twister_engine&lt;
    uint_fast64_t,
    64, 312, 156, 31,
    0xb5026f5aa96619e9ULL, 29,
    0x5555555555555555ULL, 17,
    0x71d67fffeda60000ULL, 37,
    0xfff7eee000000000ULL, 43,
    6364136223846793005ULL&gt; mt19937_64;

  typedef subtract_with_carry_engine&lt;uint_fast32_t, 24, 10, 24&gt;
    ranlux24_base;

  typedef subtract_with_carry_engine&lt;uint_fast64_t, 48, 5, 12&gt;
    ranlux48_base;

  typedef discard_block_engine&lt;ranlux24_base, 223, 23&gt; ranlux24;

  typedef discard_block_engine&lt;ranlux48_base, 389, 11&gt; ranlux48;

  typedef shuffle_order_engine&lt;minstd_rand0, 256&gt; knuth_b;

  typedef minstd_rand0 default_random_engine;

  /**
   * A standard interface to a platform-specific non-deterministic
   * random number generator (if any are available).
   */
  class random_device
  {
  public:
    /** The type of the generated random value. */
    typedef unsigned int result_type;

    // constructors, destructors and member functions

#ifdef _GLIBCXX_USE_RANDOM_TR1

    explicit
    random_device(const std::string&amp; __token = &quot;default&quot;)
    {
      _M_init(__token);
    }

    ~random_device()
    { _M_fini(); }

#else

    explicit
    random_device(const std::string&amp; __token = &quot;mt19937&quot;)
    { _M_init_pretr1(__token); }

  public:

#endif

    static constexpr result_type
    min()
    { return std::numeric_limits&lt;result_type&gt;::min(); }

    static constexpr result_type
    max()
    { return std::numeric_limits&lt;result_type&gt;::max(); }

    double
    entropy() const noexcept
    {
#ifdef _GLIBCXX_USE_RANDOM_TR1
      return this-&gt;_M_getentropy();
#else
      return 0.0;
#endif
    }

    result_type
    operator()()
    {
#ifdef _GLIBCXX_USE_RANDOM_TR1
      return this-&gt;_M_getval();
#else
      return this-&gt;_M_getval_pretr1();
#endif
    }

    // No copy functions.
    random_device(const random_device&amp;) = delete;
    void operator=(const random_device&amp;) = delete;

  private:

    void _M_init(const std::string&amp; __token);
    void _M_init_pretr1(const std::string&amp; __token);
    void _M_fini();

    result_type _M_getval();
    result_type _M_getval_pretr1();
    double _M_getentropy() const noexcept;

    union
    {
      void*      _M_file;
      mt19937    _M_mt;
    };
  };

  /* @} */ // group random_generators

  /**
   * @addtogroup random_distributions Random Number Distributions
   * @ingroup random
   * @{
   */

  /**
   * @addtogroup random_distributions_uniform Uniform Distributions
   * @ingroup random_distributions
   * @{
   */

  // std::uniform_int_distribution is defined in &lt;bits/uniform_int_dist.h&gt;

  /**
   * @brief Return true if two uniform integer distributions have
   *        different parameters.
   */
  template&lt;typename _IntType&gt;
    inline bool
    operator!=(const std::uniform_int_distribution&lt;_IntType&gt;&amp; __d1,
	       const std::uniform_int_distribution&lt;_IntType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %uniform_int_distribution random number
   *        distribution @p __x into the output stream @p os.
   *
   * @param __os An output stream.
   * @param __x  A %uniform_int_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   * an error state.
   */
  template&lt;typename _IntType, typename _CharT, typename _Traits&gt;
    std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
    operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp;,
	       const std::uniform_int_distribution&lt;_IntType&gt;&amp;);

  /**
   * @brief Extracts a %uniform_int_distribution random number distribution
   * @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x  A %uniform_int_distribution random number generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  template&lt;typename _IntType, typename _CharT, typename _Traits&gt;
    std::basic_istream&lt;_CharT, _Traits&gt;&amp;
    operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp;,
	       std::uniform_int_distribution&lt;_IntType&gt;&amp;);


  /**
   * @brief Uniform continuous distribution for random numbers.
   *
   * A continuous random distribution on the range [min, max) with equal
   * probability throughout the range.  The URNG should be real-valued and
   * deliver number in the range [0, 1).
   */
  template&lt;typename _RealType = double&gt;
    class uniform_real_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef uniform_real_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __a = _RealType(0),
		   _RealType __b = _RealType(1))
	: _M_a(__a), _M_b(__b)
	{
	  __glibcxx_assert(_M_a &lt;= _M_b);
	}

	result_type
	a() const
	{ return _M_a; }

	result_type
	b() const
	{ return _M_b; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_a == __p2._M_a &amp;&amp; __p1._M_b == __p2._M_b; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_a;
	_RealType _M_b;
      };

    public:
      /**
       * @brief Constructs a uniform_real_distribution object.
       *
       * @param __a [IN]  The lower bound of the distribution.
       * @param __b [IN]  The upper bound of the distribution.
       */
      explicit
      uniform_real_distribution(_RealType __a = _RealType(0),
				_RealType __b = _RealType(1))
      : _M_param(__a, __b)
      { }

      explicit
      uniform_real_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       *
       * Does nothing for the uniform real distribution.
       */
      void
      reset() { }

      result_type
      a() const
      { return _M_param.a(); }

      result_type
      b() const
      { return _M_param.b(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the inclusive lower bound of the distribution range.
       */
      result_type
      min() const
      { return this-&gt;a(); }

      /**
       * @brief Returns the inclusive upper bound of the distribution range.
       */
      result_type
      max() const
      { return this-&gt;b(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
        { return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{
	  __detail::_Adaptor&lt;_UniformRandomNumberGenerator, result_type&gt;
	    __aurng(__urng);
	  return (__aurng() * (__p.b() - __p.a())) + __p.a();
	}

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two uniform real distributions have
       *        the same parameters.
       */
      friend bool
      operator==(const uniform_real_distribution&amp; __d1,
		 const uniform_real_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
   * @brief Return true if two uniform real distributions have
   *        different parameters.
   */
  template&lt;typename _IntType&gt;
    inline bool
    operator!=(const std::uniform_real_distribution&lt;_IntType&gt;&amp; __d1,
	       const std::uniform_real_distribution&lt;_IntType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %uniform_real_distribution random number
   *        distribution @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %uniform_real_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   *          an error state.
   */
  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;,
	       const std::uniform_real_distribution&lt;_RealType&gt;&amp;);

  /**
   * @brief Extracts a %uniform_real_distribution random number distribution
   * @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x  A %uniform_real_distribution random number generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  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;,
	       std::uniform_real_distribution&lt;_RealType&gt;&amp;);

  /* @} */ // group random_distributions_uniform

  /**
   * @addtogroup random_distributions_normal Normal Distributions
   * @ingroup random_distributions
   * @{
   */

  /**
   * @brief A normal continuous distribution for random numbers.
   *
   * The formula for the normal probability density function is
   * @f[
   *     p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
   *            e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} } 
   * @f]
   */
  template&lt;typename _RealType = double&gt;
    class normal_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef normal_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __mean = _RealType(0),
		   _RealType __stddev = _RealType(1))
	: _M_mean(__mean), _M_stddev(__stddev)
	{
	  __glibcxx_assert(_M_stddev &gt; _RealType(0));
	}

	_RealType
	mean() const
	{ return _M_mean; }

	_RealType
	stddev() const
	{ return _M_stddev; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return (__p1._M_mean == __p2._M_mean
		  &amp;&amp; __p1._M_stddev == __p2._M_stddev); }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_mean;
	_RealType _M_stddev;
      };

    public:
      /**
       * Constructs a normal distribution with parameters @f$mean@f$ and
       * standard deviation.
       */
      explicit
      normal_distribution(result_type __mean = result_type(0),
			  result_type __stddev = result_type(1))
      : _M_param(__mean, __stddev)
      { }

      explicit
      normal_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { _M_saved_available = false; }

      /**
       * @brief Returns the mean of the distribution.
       */
      _RealType
      mean() const
      { return _M_param.mean(); }

      /**
       * @brief Returns the standard deviation of the distribution.
       */
      _RealType
      stddev() const
      { return _M_param.stddev(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return std::numeric_limits&lt;result_type&gt;::lowest(); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two normal distributions have
       *        the same parameters and the sequences that would
       *        be generated are equal.
       */
      template&lt;typename _RealType1&gt;
	friend bool
        operator==(const std::normal_distribution&lt;_RealType1&gt;&amp; __d1,
		   const std::normal_distribution&lt;_RealType1&gt;&amp; __d2);

      /**
       * @brief Inserts a %normal_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %normal_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::normal_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %normal_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %normal_distribution random number generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error
       *          state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::normal_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type  _M_param;
      result_type _M_saved = 0;
      bool        _M_saved_available = false;
    };

  /**
   * @brief Return true if two normal distributions are different.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::normal_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::normal_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief A lognormal_distribution random number distribution.
   *
   * The formula for the normal probability mass function is
   * @f[
   *     p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
   *                \exp{-\frac{(\ln{x} - m)^2}{2s^2}} 
   * @f]
   */
  template&lt;typename _RealType = double&gt;
    class lognormal_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef lognormal_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __m = _RealType(0),
		   _RealType __s = _RealType(1))
	: _M_m(__m), _M_s(__s)
	{ }

	_RealType
	m() const
	{ return _M_m; }

	_RealType
	s() const
	{ return _M_s; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_m == __p2._M_m &amp;&amp; __p1._M_s == __p2._M_s; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_m;
	_RealType _M_s;
      };

      explicit
      lognormal_distribution(_RealType __m = _RealType(0),
			     _RealType __s = _RealType(1))
      : _M_param(__m, __s), _M_nd()
      { }

      explicit
      lognormal_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_nd()
      { }

      /**
       * Resets the distribution state.
       */
      void
      reset()
      { _M_nd.reset(); }

      /**
       *
       */
      _RealType
      m() const
      { return _M_param.m(); }

      _RealType
      s() const
      { return _M_param.s(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
        { return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
        { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two lognormal distributions have
       *        the same parameters and the sequences that would
       *        be generated are equal.
       */
      friend bool
      operator==(const lognormal_distribution&amp; __d1,
		 const lognormal_distribution&amp; __d2)
      { return (__d1._M_param == __d2._M_param
		&amp;&amp; __d1._M_nd == __d2._M_nd); }

      /**
       * @brief Inserts a %lognormal_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %lognormal_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::lognormal_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %lognormal_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x A %lognormal_distribution random number
       *            generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::lognormal_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;

      std::normal_distribution&lt;result_type&gt; _M_nd;
    };

  /**
   * @brief Return true if two lognormal distributions are different.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::lognormal_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::lognormal_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief A gamma continuous distribution for random numbers.
   *
   * The formula for the gamma probability density function is:
   * @f[
   *     p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
   *                         (x/\beta)^{\alpha - 1} e^{-x/\beta} 
   * @f]
   */
  template&lt;typename _RealType = double&gt;
    class gamma_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef gamma_distribution&lt;_RealType&gt; distribution_type;
	friend class gamma_distribution&lt;_RealType&gt;;

	explicit
	param_type(_RealType __alpha_val = _RealType(1),
		   _RealType __beta_val = _RealType(1))
	: _M_alpha(__alpha_val), _M_beta(__beta_val)
	{
	  __glibcxx_assert(_M_alpha &gt; _RealType(0));
	  _M_initialize();
	}

	_RealType
	alpha() const
	{ return _M_alpha; }

	_RealType
	beta() const
	{ return _M_beta; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return (__p1._M_alpha == __p2._M_alpha
		  &amp;&amp; __p1._M_beta == __p2._M_beta); }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	void
	_M_initialize();

	_RealType _M_alpha;
	_RealType _M_beta;

	_RealType _M_malpha, _M_a2;
      };

    public:
      /**
       * @brief Constructs a gamma distribution with parameters
       * @f$\alpha@f$ and @f$\beta@f$.
       */
      explicit
      gamma_distribution(_RealType __alpha_val = _RealType(1),
			 _RealType __beta_val = _RealType(1))
      : _M_param(__alpha_val, __beta_val), _M_nd()
      { }

      explicit
      gamma_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_nd()
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { _M_nd.reset(); }

      /**
       * @brief Returns the @f$\alpha@f$ of the distribution.
       */
      _RealType
      alpha() const
      { return _M_param.alpha(); }

      /**
       * @brief Returns the @f$\beta@f$ of the distribution.
       */
      _RealType
      beta() const
      { return _M_param.beta(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two gamma distributions have the same
       *        parameters and the sequences that would be generated
       *        are equal.
       */
      friend bool
      operator==(const gamma_distribution&amp; __d1,
		 const gamma_distribution&amp; __d2)
      { return (__d1._M_param == __d2._M_param
		&amp;&amp; __d1._M_nd == __d2._M_nd); }

      /**
       * @brief Inserts a %gamma_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %gamma_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::gamma_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %gamma_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %gamma_distribution random number generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::gamma_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;

      std::normal_distribution&lt;result_type&gt; _M_nd;
    };

  /**
   * @brief Return true if two gamma distributions are different.
   */
   template&lt;typename _RealType&gt;
     inline bool
     operator!=(const std::gamma_distribution&lt;_RealType&gt;&amp; __d1,
		const std::gamma_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief A chi_squared_distribution random number distribution.
   *
   * The formula for the normal probability mass function is
   * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$
   */
  template&lt;typename _RealType = double&gt;
    class chi_squared_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef chi_squared_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __n = _RealType(1))
	: _M_n(__n)
	{ }

	_RealType
	n() const
	{ return _M_n; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_n == __p2._M_n; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_n;
      };

      explicit
      chi_squared_distribution(_RealType __n = _RealType(1))
      : _M_param(__n), _M_gd(__n / 2)
      { }

      explicit
      chi_squared_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_gd(__p.n() / 2)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { _M_gd.reset(); }

      /**
       *
       */
      _RealType
      n() const
      { return _M_param.n(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      {
	_M_param = __param;
	typedef typename std::gamma_distribution&lt;result_type&gt;::param_type
	  param_type;
	_M_gd.param(param_type{__param.n() / 2});
      }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return 2 * _M_gd(__urng); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
        {
	  typedef typename std::gamma_distribution&lt;result_type&gt;::param_type
	    param_type;
	  return 2 * _M_gd(__urng, param_type(__p.n() / 2));
	}

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
        { this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ typename std::gamma_distribution&lt;result_type&gt;::param_type
	    __p2(__p.n() / 2);
	  this-&gt;__generate_impl(__f, __t, __urng, __p2); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng)
        { this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ typename std::gamma_distribution&lt;result_type&gt;::param_type
	    __p2(__p.n() / 2);
	  this-&gt;__generate_impl(__f, __t, __urng, __p2); }

      /**
       * @brief Return true if two Chi-squared distributions have
       *        the same parameters and the sequences that would be
       *        generated are equal.
       */
      friend bool
      operator==(const chi_squared_distribution&amp; __d1,
		 const chi_squared_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param &amp;&amp; __d1._M_gd == __d2._M_gd; }

      /**
       * @brief Inserts a %chi_squared_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %chi_squared_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::chi_squared_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %chi_squared_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x A %chi_squared_distribution random number
       *            generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::chi_squared_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const typename
			std::gamma_distribution&lt;result_type&gt;::param_type&amp; __p);

      param_type _M_param;

      std::gamma_distribution&lt;result_type&gt; _M_gd;
    };

  /**
   * @brief Return true if two Chi-squared distributions are different.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::chi_squared_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::chi_squared_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief A cauchy_distribution random number distribution.
   *
   * The formula for the normal probability mass function is
   * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$
   */
  template&lt;typename _RealType = double&gt;
    class cauchy_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef cauchy_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __a = _RealType(0),
		   _RealType __b = _RealType(1))
	: _M_a(__a), _M_b(__b)
	{ }

	_RealType
	a() const
	{ return _M_a; }

	_RealType
	b() const
	{ return _M_b; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_a == __p2._M_a &amp;&amp; __p1._M_b == __p2._M_b; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_a;
	_RealType _M_b;
      };

      explicit
      cauchy_distribution(_RealType __a = _RealType(0),
			  _RealType __b = _RealType(1))
      : _M_param(__a, __b)
      { }

      explicit
      cauchy_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { }

      /**
       *
       */
      _RealType
      a() const
      { return _M_param.a(); }

      _RealType
      b() const
      { return _M_param.b(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return std::numeric_limits&lt;result_type&gt;::lowest(); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two Cauchy distributions have
       *        the same parameters.
       */
      friend bool
      operator==(const cauchy_distribution&amp; __d1,
		 const cauchy_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
   * @brief Return true if two Cauchy distributions have
   *        different parameters.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::cauchy_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::cauchy_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %cauchy_distribution random number distribution
   * @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %cauchy_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   * an error state.
   */
  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 std::cauchy_distribution&lt;_RealType&gt;&amp; __x);

  /**
   * @brief Extracts a %cauchy_distribution random number distribution
   * @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x A %cauchy_distribution random number
   *            generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  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,
	       std::cauchy_distribution&lt;_RealType&gt;&amp; __x);


  /**
   * @brief A fisher_f_distribution random number distribution.
   *
   * The formula for the normal probability mass function is
   * @f[
   *     p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
   *                (\frac{m}{n})^{m/2} x^{(m/2)-1}
   *                (1 + \frac{mx}{n})^{-(m+n)/2} 
   * @f]
   */
  template&lt;typename _RealType = double&gt;
    class fisher_f_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef fisher_f_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __m = _RealType(1),
		   _RealType __n = _RealType(1))
	: _M_m(__m), _M_n(__n)
	{ }

	_RealType
	m() const
	{ return _M_m; }

	_RealType
	n() const
	{ return _M_n; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_m == __p2._M_m &amp;&amp; __p1._M_n == __p2._M_n; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_m;
	_RealType _M_n;
      };

      explicit
      fisher_f_distribution(_RealType __m = _RealType(1),
			    _RealType __n = _RealType(1))
      : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
      { }

      explicit
      fisher_f_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      {
	_M_gd_x.reset();
	_M_gd_y.reset();
      }

      /**
       *
       */
      _RealType
      m() const
      { return _M_param.m(); }

      _RealType
      n() const
      { return _M_param.n(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
        {
	  typedef typename std::gamma_distribution&lt;result_type&gt;::param_type
	    param_type;
	  return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
		  / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
	}

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two Fisher f distributions have
       *        the same parameters and the sequences that would
       *        be generated are equal.
       */
      friend bool
      operator==(const fisher_f_distribution&amp; __d1,
		 const fisher_f_distribution&amp; __d2)
      { return (__d1._M_param == __d2._M_param
		&amp;&amp; __d1._M_gd_x == __d2._M_gd_x
		&amp;&amp; __d1._M_gd_y == __d2._M_gd_y); }

      /**
       * @brief Inserts a %fisher_f_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %fisher_f_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::fisher_f_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %fisher_f_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x A %fisher_f_distribution random number
       *            generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::fisher_f_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;

      std::gamma_distribution&lt;result_type&gt; _M_gd_x, _M_gd_y;
    };

  /**
   * @brief Return true if two Fisher f distributions are different.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::fisher_f_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::fisher_f_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief A student_t_distribution random number distribution.
   *
   * The formula for the normal probability mass function is:
   * @f[
   *     p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
   *              (1 + \frac{x^2}{n}) ^{-(n+1)/2} 
   * @f]
   */
  template&lt;typename _RealType = double&gt;
    class student_t_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef student_t_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __n = _RealType(1))
	: _M_n(__n)
	{ }

	_RealType
	n() const
	{ return _M_n; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_n == __p2._M_n; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_n;
      };

      explicit
      student_t_distribution(_RealType __n = _RealType(1))
      : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
      { }

      explicit
      student_t_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      {
	_M_nd.reset();
	_M_gd.reset();
      }

      /**
       *
       */
      _RealType
      n() const
      { return _M_param.n(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return std::numeric_limits&lt;result_type&gt;::lowest(); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
        operator()(_UniformRandomNumberGenerator&amp; __urng)
        { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
        {
	  typedef typename std::gamma_distribution&lt;result_type&gt;::param_type
	    param_type;
	
	  const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
	  return _M_nd(__urng) * std::sqrt(__p.n() / __g);
        }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two Student t distributions have
       *        the same parameters and the sequences that would
       *        be generated are equal.
       */
      friend bool
      operator==(const student_t_distribution&amp; __d1,
		 const student_t_distribution&amp; __d2)
      { return (__d1._M_param == __d2._M_param
		&amp;&amp; __d1._M_nd == __d2._M_nd &amp;&amp; __d1._M_gd == __d2._M_gd); }

      /**
       * @brief Inserts a %student_t_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %student_t_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::student_t_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %student_t_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x A %student_t_distribution random number
       *            generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::student_t_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng);
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;

      std::normal_distribution&lt;result_type&gt; _M_nd;
      std::gamma_distribution&lt;result_type&gt; _M_gd;
    };

  /**
   * @brief Return true if two Student t distributions are different.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::student_t_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::student_t_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /* @} */ // group random_distributions_normal

  /**
   * @addtogroup random_distributions_bernoulli Bernoulli Distributions
   * @ingroup random_distributions
   * @{
   */

  /**
   * @brief A Bernoulli random number distribution.
   *
   * Generates a sequence of true and false values with likelihood @f$p@f$
   * that true will come up and @f$(1 - p)@f$ that false will appear.
   */
  class bernoulli_distribution
  {
  public:
    /** The type of the range of the distribution. */
    typedef bool result_type;

    /** Parameter type. */
    struct param_type
    {
      typedef bernoulli_distribution distribution_type;

      explicit
      param_type(double __p = 0.5)
      : _M_p(__p)
      {
	__glibcxx_assert((_M_p &gt;= 0.0) &amp;&amp; (_M_p &lt;= 1.0));
      }

      double
      p() const
      { return _M_p; }

      friend bool
      operator==(const param_type&amp; __p1, const param_type&amp; __p2)
      { return __p1._M_p == __p2._M_p; }

      friend bool
      operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
      { return !(__p1 == __p2); }

    private:
      double _M_p;
    };

  public:
    /**
     * @brief Constructs a Bernoulli distribution with likelihood @p p.
     *
     * @param __p  [IN]  The likelihood of a true result being returned.
     *                   Must be in the interval @f$[0, 1]@f$.
     */
    explicit
    bernoulli_distribution(double __p = 0.5)
    : _M_param(__p)
    { }

    explicit
    bernoulli_distribution(const param_type&amp; __p)
    : _M_param(__p)
    { }

    /**
     * @brief Resets the distribution state.
     *
     * Does nothing for a Bernoulli distribution.
     */
    void
    reset() { }

    /**
     * @brief Returns the @p p parameter of the distribution.
     */
    double
    p() const
    { return _M_param.p(); }

    /**
     * @brief Returns the parameter set of the distribution.
     */
    param_type
    param() const
    { return _M_param; }

    /**
     * @brief Sets the parameter set of the distribution.
     * @param __param The new parameter set of the distribution.
     */
    void
    param(const param_type&amp; __param)
    { _M_param = __param; }

    /**
     * @brief Returns the greatest lower bound value of the distribution.
     */
    result_type
    min() const
    { return std::numeric_limits&lt;result_type&gt;::min(); }

    /**
     * @brief Returns the least upper bound value of the distribution.
     */
    result_type
    max() const
    { return std::numeric_limits&lt;result_type&gt;::max(); }

    /**
     * @brief Generating functions.
     */
    template&lt;typename _UniformRandomNumberGenerator&gt;
      result_type
      operator()(_UniformRandomNumberGenerator&amp; __urng)
      { return this-&gt;operator()(__urng, _M_param); }

    template&lt;typename _UniformRandomNumberGenerator&gt;
      result_type
      operator()(_UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      {
	__detail::_Adaptor&lt;_UniformRandomNumberGenerator, double&gt;
	  __aurng(__urng);
	if ((__aurng() - __aurng.min())
	     &lt; __p.p() * (__aurng.max() - __aurng.min()))
	  return true;
	return false;
      }

    template&lt;typename _ForwardIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      __generate(_ForwardIterator __f, _ForwardIterator __t,
		 _UniformRandomNumberGenerator&amp; __urng)
      { this-&gt;__generate(__f, __t, __urng, _M_param); }

    template&lt;typename _ForwardIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      __generate(_ForwardIterator __f, _ForwardIterator __t,
		 _UniformRandomNumberGenerator&amp; __urng, const param_type&amp; __p)
      { this-&gt;__generate_impl(__f, __t, __urng, __p); }

    template&lt;typename _UniformRandomNumberGenerator&gt;
      void
      __generate(result_type* __f, result_type* __t,
		 _UniformRandomNumberGenerator&amp; __urng,
		 const param_type&amp; __p)
      { this-&gt;__generate_impl(__f, __t, __urng, __p); }

    /**
     * @brief Return true if two Bernoulli distributions have
     *        the same parameters.
     */
    friend bool
    operator==(const bernoulli_distribution&amp; __d1,
	       const bernoulli_distribution&amp; __d2)
    { return __d1._M_param == __d2._M_param; }

  private:
    template&lt;typename _ForwardIterator,
	     typename _UniformRandomNumberGenerator&gt;
      void
      __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
		      _UniformRandomNumberGenerator&amp; __urng,
		      const param_type&amp; __p);

    param_type _M_param;
  };

  /**
   * @brief Return true if two Bernoulli distributions have
   *        different parameters.
   */
  inline bool
  operator!=(const std::bernoulli_distribution&amp; __d1,
	     const std::bernoulli_distribution&amp; __d2)
  { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %bernoulli_distribution random number distribution
   * @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %bernoulli_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   * an error state.
   */
  template&lt;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 std::bernoulli_distribution&amp; __x);

  /**
   * @brief Extracts a %bernoulli_distribution random number distribution
   * @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x  A %bernoulli_distribution random number generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  template&lt;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,
	       std::bernoulli_distribution&amp; __x)
    {
      double __p;
      if (__is &gt;&gt; __p)
	__x.param(bernoulli_distribution::param_type(__p));
      return __is;
    }


  /**
   * @brief A discrete binomial random number distribution.
   *
   * The formula for the binomial probability density function is
   * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
   * and @f$p@f$ are the parameters of the distribution.
   */
  template&lt;typename _IntType = int&gt;
    class binomial_distribution
    {
      static_assert(std::is_integral&lt;_IntType&gt;::value,
		    &quot;result_type must be an integral type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _IntType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef binomial_distribution&lt;_IntType&gt; distribution_type;
	friend class binomial_distribution&lt;_IntType&gt;;

	explicit
	param_type(_IntType __t = _IntType(1), double __p = 0.5)
	: _M_t(__t), _M_p(__p)
	{
	  __glibcxx_assert((_M_t &gt;= _IntType(0))
				&amp;&amp; (_M_p &gt;= 0.0)
				&amp;&amp; (_M_p &lt;= 1.0));
	  _M_initialize();
	}

	_IntType
	t() const
	{ return _M_t; }

	double
	p() const
	{ return _M_p; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_t == __p2._M_t &amp;&amp; __p1._M_p == __p2._M_p; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	void
	_M_initialize();

	_IntType _M_t;
	double _M_p;

	double _M_q;
#if _GLIBCXX_USE_C99_MATH_TR1
	double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
	       _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
#endif
	bool   _M_easy;
      };

      // constructors and member function
      explicit
      binomial_distribution(_IntType __t = _IntType(1),
			    double __p = 0.5)
      : _M_param(__t, __p), _M_nd()
      { }

      explicit
      binomial_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_nd()
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { _M_nd.reset(); }

      /**
       * @brief Returns the distribution @p t parameter.
       */
      _IntType
      t() const
      { return _M_param.t(); }

      /**
       * @brief Returns the distribution @p p parameter.
       */
      double
      p() const
      { return _M_param.p(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return 0; }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return _M_param.t(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two binomial distributions have
       *        the same parameters and the sequences that would
       *        be generated are equal.
       */
	friend bool
        operator==(const binomial_distribution&amp; __d1,
		   const binomial_distribution&amp; __d2)
#ifdef _GLIBCXX_USE_C99_MATH_TR1
	{ return __d1._M_param == __d2._M_param &amp;&amp; __d1._M_nd == __d2._M_nd; }
#else
        { return __d1._M_param == __d2._M_param; }
#endif

      /**
       * @brief Inserts a %binomial_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %binomial_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _IntType1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::binomial_distribution&lt;_IntType1&gt;&amp; __x);

      /**
       * @brief Extracts a %binomial_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %binomial_distribution random number generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error
       *          state.
       */
      template&lt;typename _IntType1,
	       typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::binomial_distribution&lt;_IntType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	_M_waiting(_UniformRandomNumberGenerator&amp; __urng,
		   _IntType __t, double __q);

      param_type _M_param;

      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
      std::normal_distribution&lt;double&gt; _M_nd;
    };

  /**
   * @brief Return true if two binomial distributions are different.
   */
  template&lt;typename _IntType&gt;
    inline bool
    operator!=(const std::binomial_distribution&lt;_IntType&gt;&amp; __d1,
	       const std::binomial_distribution&lt;_IntType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief A discrete geometric random number distribution.
   *
   * The formula for the geometric probability density function is
   * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
   * distribution.
   */
  template&lt;typename _IntType = int&gt;
    class geometric_distribution
    {
      static_assert(std::is_integral&lt;_IntType&gt;::value,
		    &quot;result_type must be an integral type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _IntType  result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef geometric_distribution&lt;_IntType&gt; distribution_type;
	friend class geometric_distribution&lt;_IntType&gt;;

	explicit
	param_type(double __p = 0.5)
	: _M_p(__p)
	{
	  __glibcxx_assert((_M_p &gt; 0.0) &amp;&amp; (_M_p &lt; 1.0));
	  _M_initialize();
	}

	double
	p() const
	{ return _M_p; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_p == __p2._M_p; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	void
	_M_initialize()
	{ _M_log_1_p = std::log(1.0 - _M_p); }

	double _M_p;

	double _M_log_1_p;
      };

      // constructors and member function
      explicit
      geometric_distribution(double __p = 0.5)
      : _M_param(__p)
      { }

      explicit
      geometric_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       *
       * Does nothing for the geometric distribution.
       */
      void
      reset() { }

      /**
       * @brief Returns the distribution parameter @p p.
       */
      double
      p() const
      { return _M_param.p(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return 0; }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two geometric distributions have
       *        the same parameters.
       */
      friend bool
      operator==(const geometric_distribution&amp; __d1,
		 const geometric_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
   * @brief Return true if two geometric distributions have
   *        different parameters.
   */
  template&lt;typename _IntType&gt;
    inline bool
    operator!=(const std::geometric_distribution&lt;_IntType&gt;&amp; __d1,
	       const std::geometric_distribution&lt;_IntType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %geometric_distribution random number distribution
   * @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %geometric_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   * an error state.
   */
  template&lt;typename _IntType,
	   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 std::geometric_distribution&lt;_IntType&gt;&amp; __x);

  /**
   * @brief Extracts a %geometric_distribution random number distribution
   * @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x  A %geometric_distribution random number generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  template&lt;typename _IntType,
	   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,
	       std::geometric_distribution&lt;_IntType&gt;&amp; __x);


  /**
   * @brief A negative_binomial_distribution random number distribution.
   *
   * The formula for the negative binomial probability mass function is
   * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
   * and @f$p@f$ are the parameters of the distribution.
   */
  template&lt;typename _IntType = int&gt;
    class negative_binomial_distribution
    {
      static_assert(std::is_integral&lt;_IntType&gt;::value,
		    &quot;result_type must be an integral type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _IntType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef negative_binomial_distribution&lt;_IntType&gt; distribution_type;

	explicit
	param_type(_IntType __k = 1, double __p = 0.5)
	: _M_k(__k), _M_p(__p)
	{
	  __glibcxx_assert((_M_k &gt; 0) &amp;&amp; (_M_p &gt; 0.0) &amp;&amp; (_M_p &lt;= 1.0));
	}

	_IntType
	k() const
	{ return _M_k; }

	double
	p() const
	{ return _M_p; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_k == __p2._M_k &amp;&amp; __p1._M_p == __p2._M_p; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_IntType _M_k;
	double _M_p;
      };

      explicit
      negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
      : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
      { }

      explicit
      negative_binomial_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { _M_gd.reset(); }

      /**
       * @brief Return the @f$k@f$ parameter of the distribution.
       */
      _IntType
      k() const
      { return _M_param.k(); }

      /**
       * @brief Return the @f$p@f$ parameter of the distribution.
       */
      double
      p() const
      { return _M_param.p(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
        operator()(_UniformRandomNumberGenerator&amp; __urng);

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate_impl(__f, __t, __urng); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two negative binomial distributions have
       *        the same parameters and the sequences that would be
       *        generated are equal.
       */
      friend bool
      operator==(const negative_binomial_distribution&amp; __d1,
		 const negative_binomial_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param &amp;&amp; __d1._M_gd == __d2._M_gd; }

      /**
       * @brief Inserts a %negative_binomial_distribution random
       *        number distribution @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %negative_binomial_distribution random number
       *             distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       *          an error state.
       */
      template&lt;typename _IntType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::negative_binomial_distribution&lt;_IntType1&gt;&amp; __x);

      /**
       * @brief Extracts a %negative_binomial_distribution random number
       *        distribution @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x A %negative_binomial_distribution random number
       *            generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error state.
       */
      template&lt;typename _IntType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::negative_binomial_distribution&lt;_IntType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng);
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;

      std::gamma_distribution&lt;double&gt; _M_gd;
    };

  /**
   * @brief Return true if two negative binomial distributions are different.
   */
  template&lt;typename _IntType&gt;
    inline bool
    operator!=(const std::negative_binomial_distribution&lt;_IntType&gt;&amp; __d1,
	       const std::negative_binomial_distribution&lt;_IntType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /* @} */ // group random_distributions_bernoulli

  /**
   * @addtogroup random_distributions_poisson Poisson Distributions
   * @ingroup random_distributions
   * @{
   */

  /**
   * @brief A discrete Poisson random number distribution.
   *
   * The formula for the Poisson probability density function is
   * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
   * parameter of the distribution.
   */
  template&lt;typename _IntType = int&gt;
    class poisson_distribution
    {
      static_assert(std::is_integral&lt;_IntType&gt;::value,
		    &quot;result_type must be an integral type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _IntType  result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef poisson_distribution&lt;_IntType&gt; distribution_type;
	friend class poisson_distribution&lt;_IntType&gt;;

	explicit
	param_type(double __mean = 1.0)
	: _M_mean(__mean)
	{
	  __glibcxx_assert(_M_mean &gt; 0.0);
	  _M_initialize();
	}

	double
	mean() const
	{ return _M_mean; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_mean == __p2._M_mean; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	// Hosts either log(mean) or the threshold of the simple method.
	void
	_M_initialize();

	double _M_mean;

	double _M_lm_thr;
#if _GLIBCXX_USE_C99_MATH_TR1
	double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
#endif
      };

      // constructors and member function
      explicit
      poisson_distribution(double __mean = 1.0)
      : _M_param(__mean), _M_nd()
      { }

      explicit
      poisson_distribution(const param_type&amp; __p)
      : _M_param(__p), _M_nd()
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { _M_nd.reset(); }

      /**
       * @brief Returns the distribution parameter @p mean.
       */
      double
      mean() const
      { return _M_param.mean(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return 0; }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

       /**
	* @brief Return true if two Poisson distributions have the same
	*        parameters and the sequences that would be generated
	*        are equal.
	*/
      friend bool
      operator==(const poisson_distribution&amp; __d1,
		 const poisson_distribution&amp; __d2)
#ifdef _GLIBCXX_USE_C99_MATH_TR1
      { return __d1._M_param == __d2._M_param &amp;&amp; __d1._M_nd == __d2._M_nd; }
#else
      { return __d1._M_param == __d2._M_param; }
#endif

      /**
       * @brief Inserts a %poisson_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %poisson_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _IntType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::poisson_distribution&lt;_IntType1&gt;&amp; __x);

      /**
       * @brief Extracts a %poisson_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %poisson_distribution random number generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error
       *          state.
       */
      template&lt;typename _IntType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::poisson_distribution&lt;_IntType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;

      // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
      std::normal_distribution&lt;double&gt; _M_nd;
    };

  /**
   * @brief Return true if two Poisson distributions are different.
   */
  template&lt;typename _IntType&gt;
    inline bool
    operator!=(const std::poisson_distribution&lt;_IntType&gt;&amp; __d1,
	       const std::poisson_distribution&lt;_IntType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief An exponential continuous distribution for random numbers.
   *
   * The formula for the exponential probability density function is
   * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
   *
   * &lt;table border=1 cellpadding=10 cellspacing=0&gt;
   * &lt;caption align=top&gt;Distribution Statistics&lt;/caption&gt;
   * &lt;tr&gt;&lt;td&gt;Mean&lt;/td&gt;&lt;td&gt;@f$\frac{1}{\lambda}@f$&lt;/td&gt;&lt;/tr&gt;
   * &lt;tr&gt;&lt;td&gt;Median&lt;/td&gt;&lt;td&gt;@f$\frac{\ln 2}{\lambda}@f$&lt;/td&gt;&lt;/tr&gt;
   * &lt;tr&gt;&lt;td&gt;Mode&lt;/td&gt;&lt;td&gt;@f$zero@f$&lt;/td&gt;&lt;/tr&gt;
   * &lt;tr&gt;&lt;td&gt;Range&lt;/td&gt;&lt;td&gt;@f$[0, \infty]@f$&lt;/td&gt;&lt;/tr&gt;
   * &lt;tr&gt;&lt;td&gt;Standard Deviation&lt;/td&gt;&lt;td&gt;@f$\frac{1}{\lambda}@f$&lt;/td&gt;&lt;/tr&gt;
   * &lt;/table&gt;
   */
  template&lt;typename _RealType = double&gt;
    class exponential_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef exponential_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __lambda = _RealType(1))
	: _M_lambda(__lambda)
	{
	  __glibcxx_assert(_M_lambda &gt; _RealType(0));
	}

	_RealType
	lambda() const
	{ return _M_lambda; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_lambda == __p2._M_lambda; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_lambda;
      };

    public:
      /**
       * @brief Constructs an exponential distribution with inverse scale
       *        parameter @f$\lambda@f$.
       */
      explicit
      exponential_distribution(const result_type&amp; __lambda = result_type(1))
      : _M_param(__lambda)
      { }

      explicit
      exponential_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       *
       * Has no effect on exponential distributions.
       */
      void
      reset() { }

      /**
       * @brief Returns the inverse scale parameter of the distribution.
       */
      _RealType
      lambda() const
      { return _M_param.lambda(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
        { return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{
	  __detail::_Adaptor&lt;_UniformRandomNumberGenerator, result_type&gt;
	    __aurng(__urng);
	  return -std::log(result_type(1) - __aurng()) / __p.lambda();
	}

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two exponential distributions have the same
       *        parameters.
       */
      friend bool
      operator==(const exponential_distribution&amp; __d1,
		 const exponential_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
   * @brief Return true if two exponential distributions have different
   *        parameters.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::exponential_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::exponential_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %exponential_distribution random number distribution
   * @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %exponential_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   * an error state.
   */
  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 std::exponential_distribution&lt;_RealType&gt;&amp; __x);

  /**
   * @brief Extracts a %exponential_distribution random number distribution
   * @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x A %exponential_distribution random number
   *            generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  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,
	       std::exponential_distribution&lt;_RealType&gt;&amp; __x);


  /**
   * @brief A weibull_distribution random number distribution.
   *
   * The formula for the normal probability density function is:
   * @f[
   *     p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
   *                         \exp{(-(\frac{x}{\beta})^\alpha)} 
   * @f]
   */
  template&lt;typename _RealType = double&gt;
    class weibull_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef weibull_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __a = _RealType(1),
		   _RealType __b = _RealType(1))
	: _M_a(__a), _M_b(__b)
	{ }

	_RealType
	a() const
	{ return _M_a; }

	_RealType
	b() const
	{ return _M_b; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_a == __p2._M_a &amp;&amp; __p1._M_b == __p2._M_b; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_a;
	_RealType _M_b;
      };

      explicit
      weibull_distribution(_RealType __a = _RealType(1),
			   _RealType __b = _RealType(1))
      : _M_param(__a, __b)
      { }

      explicit
      weibull_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { }

      /**
       * @brief Return the @f$a@f$ parameter of the distribution.
       */
      _RealType
      a() const
      { return _M_param.a(); }

      /**
       * @brief Return the @f$b@f$ parameter of the distribution.
       */
      _RealType
      b() const
      { return _M_param.b(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two Weibull distributions have the same
       *        parameters.
       */
      friend bool
      operator==(const weibull_distribution&amp; __d1,
		 const weibull_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

   /**
    * @brief Return true if two Weibull distributions have different
    *        parameters.
    */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::weibull_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::weibull_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %weibull_distribution random number distribution
   * @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %weibull_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   * an error state.
   */
  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 std::weibull_distribution&lt;_RealType&gt;&amp; __x);

  /**
   * @brief Extracts a %weibull_distribution random number distribution
   * @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x A %weibull_distribution random number
   *            generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  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,
	       std::weibull_distribution&lt;_RealType&gt;&amp; __x);


  /**
   * @brief A extreme_value_distribution random number distribution.
   *
   * The formula for the normal probability mass function is
   * @f[
   *     p(x|a,b) = \frac{1}{b}
   *                \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b})) 
   * @f]
   */
  template&lt;typename _RealType = double&gt;
    class extreme_value_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef extreme_value_distribution&lt;_RealType&gt; distribution_type;

	explicit
	param_type(_RealType __a = _RealType(0),
		   _RealType __b = _RealType(1))
	: _M_a(__a), _M_b(__b)
	{ }

	_RealType
	a() const
	{ return _M_a; }

	_RealType
	b() const
	{ return _M_b; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_a == __p2._M_a &amp;&amp; __p1._M_b == __p2._M_b; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	_RealType _M_a;
	_RealType _M_b;
      };

      explicit
      extreme_value_distribution(_RealType __a = _RealType(0),
				 _RealType __b = _RealType(1))
      : _M_param(__a, __b)
      { }

      explicit
      extreme_value_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { }

      /**
       * @brief Return the @f$a@f$ parameter of the distribution.
       */
      _RealType
      a() const
      { return _M_param.a(); }

      /**
       * @brief Return the @f$b@f$ parameter of the distribution.
       */
      _RealType
      b() const
      { return _M_param.b(); }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return std::numeric_limits&lt;result_type&gt;::lowest(); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      { return std::numeric_limits&lt;result_type&gt;::max(); }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two extreme value distributions have the same
       *        parameters.
       */
      friend bool
      operator==(const extreme_value_distribution&amp; __d1,
		 const extreme_value_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
    * @brief Return true if two extreme value distributions have different
    *        parameters.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::extreme_value_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::extreme_value_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }

  /**
   * @brief Inserts a %extreme_value_distribution random number distribution
   * @p __x into the output stream @p __os.
   *
   * @param __os An output stream.
   * @param __x  A %extreme_value_distribution random number distribution.
   *
   * @returns The output stream with the state of @p __x inserted or in
   * an error state.
   */
  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 std::extreme_value_distribution&lt;_RealType&gt;&amp; __x);

  /**
   * @brief Extracts a %extreme_value_distribution random number
   *        distribution @p __x from the input stream @p __is.
   *
   * @param __is An input stream.
   * @param __x A %extreme_value_distribution random number
   *            generator engine.
   *
   * @returns The input stream with @p __x extracted or in an error state.
   */
  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,
	       std::extreme_value_distribution&lt;_RealType&gt;&amp; __x);


  /**
   * @brief A discrete_distribution random number distribution.
   *
   * The formula for the discrete probability mass function is
   *
   */
  template&lt;typename _IntType = int&gt;
    class discrete_distribution
    {
      static_assert(std::is_integral&lt;_IntType&gt;::value,
		    &quot;result_type must be an integral type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _IntType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef discrete_distribution&lt;_IntType&gt; distribution_type;
	friend class discrete_distribution&lt;_IntType&gt;;

	param_type()
	: _M_prob(), _M_cp()
	{ }

	template&lt;typename _InputIterator&gt;
	  param_type(_InputIterator __wbegin,
		     _InputIterator __wend)
	  : _M_prob(__wbegin, __wend), _M_cp()
	  { _M_initialize(); }

	param_type(initializer_list&lt;double&gt; __wil)
	: _M_prob(__wil.begin(), __wil.end()), _M_cp()
	{ _M_initialize(); }

	template&lt;typename _Func&gt;
	  param_type(size_t __nw, double __xmin, double __xmax,
		     _Func __fw);

	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
	param_type(const param_type&amp;) = default;
	param_type&amp; operator=(const param_type&amp;) = default;

	std::vector&lt;double&gt;
	probabilities() const
	{ return _M_prob.empty() ? std::vector&lt;double&gt;(1, 1.0) : _M_prob; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_prob == __p2._M_prob; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	void
	_M_initialize();

	std::vector&lt;double&gt; _M_prob;
	std::vector&lt;double&gt; _M_cp;
      };

      discrete_distribution()
      : _M_param()
      { }

      template&lt;typename _InputIterator&gt;
	discrete_distribution(_InputIterator __wbegin,
			      _InputIterator __wend)
	: _M_param(__wbegin, __wend)
	{ }

      discrete_distribution(initializer_list&lt;double&gt; __wl)
      : _M_param(__wl)
      { }

      template&lt;typename _Func&gt;
	discrete_distribution(size_t __nw, double __xmin, double __xmax,
			      _Func __fw)
	: _M_param(__nw, __xmin, __xmax, __fw)
	{ }

      explicit
      discrete_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { }

      /**
       * @brief Returns the probabilities of the distribution.
       */
      std::vector&lt;double&gt;
      probabilities() const
      {
	return _M_param._M_prob.empty()
	  ? std::vector&lt;double&gt;(1, 1.0) : _M_param._M_prob;
      }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      { return result_type(0); }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      {
	return _M_param._M_prob.empty()
	  ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
      }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two discrete distributions have the same
       *        parameters.
       */
      friend bool
      operator==(const discrete_distribution&amp; __d1,
		 const discrete_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

      /**
       * @brief Inserts a %discrete_distribution random number distribution
       * @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %discrete_distribution random number distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _IntType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::discrete_distribution&lt;_IntType1&gt;&amp; __x);

      /**
       * @brief Extracts a %discrete_distribution random number distribution
       * @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x A %discrete_distribution random number
       *            generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error
       *          state.
       */
      template&lt;typename _IntType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::discrete_distribution&lt;_IntType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
    * @brief Return true if two discrete distributions have different
    *        parameters.
    */
  template&lt;typename _IntType&gt;
    inline bool
    operator!=(const std::discrete_distribution&lt;_IntType&gt;&amp; __d1,
	       const std::discrete_distribution&lt;_IntType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief A piecewise_constant_distribution random number distribution.
   *
   * The formula for the piecewise constant probability mass function is
   *
   */
  template&lt;typename _RealType = double&gt;
    class piecewise_constant_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef piecewise_constant_distribution&lt;_RealType&gt; distribution_type;
	friend class piecewise_constant_distribution&lt;_RealType&gt;;

	param_type()
	: _M_int(), _M_den(), _M_cp()
	{ }

	template&lt;typename _InputIteratorB, typename _InputIteratorW&gt;
	  param_type(_InputIteratorB __bfirst,
		     _InputIteratorB __bend,
		     _InputIteratorW __wbegin);

	template&lt;typename _Func&gt;
	  param_type(initializer_list&lt;_RealType&gt; __bi, _Func __fw);

	template&lt;typename _Func&gt;
	  param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
		     _Func __fw);

	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
	param_type(const param_type&amp;) = default;
	param_type&amp; operator=(const param_type&amp;) = default;

	std::vector&lt;_RealType&gt;
	intervals() const
	{
	  if (_M_int.empty())
	    {
	      std::vector&lt;_RealType&gt; __tmp(2);
	      __tmp[1] = _RealType(1);
	      return __tmp;
	    }
	  else
	    return _M_int;
	}

	std::vector&lt;double&gt;
	densities() const
	{ return _M_den.empty() ? std::vector&lt;double&gt;(1, 1.0) : _M_den; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_int == __p2._M_int &amp;&amp; __p1._M_den == __p2._M_den; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	void
	_M_initialize();

	std::vector&lt;_RealType&gt; _M_int;
	std::vector&lt;double&gt; _M_den;
	std::vector&lt;double&gt; _M_cp;
      };

      explicit
      piecewise_constant_distribution()
      : _M_param()
      { }

      template&lt;typename _InputIteratorB, typename _InputIteratorW&gt;
	piecewise_constant_distribution(_InputIteratorB __bfirst,
					_InputIteratorB __bend,
					_InputIteratorW __wbegin)
	: _M_param(__bfirst, __bend, __wbegin)
	{ }

      template&lt;typename _Func&gt;
	piecewise_constant_distribution(initializer_list&lt;_RealType&gt; __bl,
					_Func __fw)
	: _M_param(__bl, __fw)
	{ }

      template&lt;typename _Func&gt;
	piecewise_constant_distribution(size_t __nw,
					_RealType __xmin, _RealType __xmax,
					_Func __fw)
	: _M_param(__nw, __xmin, __xmax, __fw)
	{ }

      explicit
      piecewise_constant_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * @brief Resets the distribution state.
       */
      void
      reset()
      { }

      /**
       * @brief Returns a vector of the intervals.
       */
      std::vector&lt;_RealType&gt;
      intervals() const
      {
	if (_M_param._M_int.empty())
	  {
	    std::vector&lt;_RealType&gt; __tmp(2);
	    __tmp[1] = _RealType(1);
	    return __tmp;
	  }
	else
	  return _M_param._M_int;
      }

      /**
       * @brief Returns a vector of the probability densities.
       */
      std::vector&lt;double&gt;
      densities() const
      {
	return _M_param._M_den.empty()
	  ? std::vector&lt;double&gt;(1, 1.0) : _M_param._M_den;
      }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      {
	return _M_param._M_int.empty()
	  ? result_type(0) : _M_param._M_int.front();
      }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      {
	return _M_param._M_int.empty()
	  ? result_type(1) : _M_param._M_int.back();
      }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two piecewise constant distributions have the
       *        same parameters.
       */
      friend bool
      operator==(const piecewise_constant_distribution&amp; __d1,
		 const piecewise_constant_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

      /**
       * @brief Inserts a %piecewise_constant_distribution random
       *        number distribution @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %piecewise_constant_distribution random number
       *             distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       * an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::piecewise_constant_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %piecewise_constant_distribution random
       *        number distribution @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x A %piecewise_constant_distribution random number
       *            generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error
       *          state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::piecewise_constant_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
    * @brief Return true if two piecewise constant distributions have 
    *        different parameters.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::piecewise_constant_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::piecewise_constant_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /**
   * @brief A piecewise_linear_distribution random number distribution.
   *
   * The formula for the piecewise linear probability mass function is
   *
   */
  template&lt;typename _RealType = double&gt;
    class piecewise_linear_distribution
    {
      static_assert(std::is_floating_point&lt;_RealType&gt;::value,
		    &quot;result_type must be a floating point type&quot;);

    public:
      /** The type of the range of the distribution. */
      typedef _RealType result_type;

      /** Parameter type. */
      struct param_type
      {
	typedef piecewise_linear_distribution&lt;_RealType&gt; distribution_type;
	friend class piecewise_linear_distribution&lt;_RealType&gt;;

	param_type()
	: _M_int(), _M_den(), _M_cp(), _M_m()
	{ }

	template&lt;typename _InputIteratorB, typename _InputIteratorW&gt;
	  param_type(_InputIteratorB __bfirst,
		     _InputIteratorB __bend,
		     _InputIteratorW __wbegin);

	template&lt;typename _Func&gt;
	  param_type(initializer_list&lt;_RealType&gt; __bl, _Func __fw);

	template&lt;typename _Func&gt;
	  param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
		     _Func __fw);

	// See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
	param_type(const param_type&amp;) = default;
	param_type&amp; operator=(const param_type&amp;) = default;

	std::vector&lt;_RealType&gt;
	intervals() const
	{
	  if (_M_int.empty())
	    {
	      std::vector&lt;_RealType&gt; __tmp(2);
	      __tmp[1] = _RealType(1);
	      return __tmp;
	    }
	  else
	    return _M_int;
	}

	std::vector&lt;double&gt;
	densities() const
	{ return _M_den.empty() ? std::vector&lt;double&gt;(2, 1.0) : _M_den; }

	friend bool
	operator==(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return __p1._M_int == __p2._M_int &amp;&amp; __p1._M_den == __p2._M_den; }

	friend bool
	operator!=(const param_type&amp; __p1, const param_type&amp; __p2)
	{ return !(__p1 == __p2); }

      private:
	void
	_M_initialize();

	std::vector&lt;_RealType&gt; _M_int;
	std::vector&lt;double&gt; _M_den;
	std::vector&lt;double&gt; _M_cp;
	std::vector&lt;double&gt; _M_m;
      };

      explicit
      piecewise_linear_distribution()
      : _M_param()
      { }

      template&lt;typename _InputIteratorB, typename _InputIteratorW&gt;
	piecewise_linear_distribution(_InputIteratorB __bfirst,
				      _InputIteratorB __bend,
				      _InputIteratorW __wbegin)
	: _M_param(__bfirst, __bend, __wbegin)
	{ }

      template&lt;typename _Func&gt;
	piecewise_linear_distribution(initializer_list&lt;_RealType&gt; __bl,
				      _Func __fw)
	: _M_param(__bl, __fw)
	{ }

      template&lt;typename _Func&gt;
	piecewise_linear_distribution(size_t __nw,
				      _RealType __xmin, _RealType __xmax,
				      _Func __fw)
	: _M_param(__nw, __xmin, __xmax, __fw)
	{ }

      explicit
      piecewise_linear_distribution(const param_type&amp; __p)
      : _M_param(__p)
      { }

      /**
       * Resets the distribution state.
       */
      void
      reset()
      { }

      /**
       * @brief Return the intervals of the distribution.
       */
      std::vector&lt;_RealType&gt;
      intervals() const
      {
	if (_M_param._M_int.empty())
	  {
	    std::vector&lt;_RealType&gt; __tmp(2);
	    __tmp[1] = _RealType(1);
	    return __tmp;
	  }
	else
	  return _M_param._M_int;
      }

      /**
       * @brief Return a vector of the probability densities of the
       *        distribution.
       */
      std::vector&lt;double&gt;
      densities() const
      {
	return _M_param._M_den.empty()
	  ? std::vector&lt;double&gt;(2, 1.0) : _M_param._M_den;
      }

      /**
       * @brief Returns the parameter set of the distribution.
       */
      param_type
      param() const
      { return _M_param; }

      /**
       * @brief Sets the parameter set of the distribution.
       * @param __param The new parameter set of the distribution.
       */
      void
      param(const param_type&amp; __param)
      { _M_param = __param; }

      /**
       * @brief Returns the greatest lower bound value of the distribution.
       */
      result_type
      min() const
      {
	return _M_param._M_int.empty()
	  ? result_type(0) : _M_param._M_int.front();
      }

      /**
       * @brief Returns the least upper bound value of the distribution.
       */
      result_type
      max() const
      {
	return _M_param._M_int.empty()
	  ? result_type(1) : _M_param._M_int.back();
      }

      /**
       * @brief Generating functions.
       */
      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng)
	{ return this-&gt;operator()(__urng, _M_param); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	result_type
	operator()(_UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p);

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng)
	{ this-&gt;__generate(__f, __t, __urng, _M_param); }

      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate(_ForwardIterator __f, _ForwardIterator __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      template&lt;typename _UniformRandomNumberGenerator&gt;
	void
	__generate(result_type* __f, result_type* __t,
		   _UniformRandomNumberGenerator&amp; __urng,
		   const param_type&amp; __p)
	{ this-&gt;__generate_impl(__f, __t, __urng, __p); }

      /**
       * @brief Return true if two piecewise linear distributions have the
       *        same parameters.
       */
      friend bool
      operator==(const piecewise_linear_distribution&amp; __d1,
		 const piecewise_linear_distribution&amp; __d2)
      { return __d1._M_param == __d2._M_param; }

      /**
       * @brief Inserts a %piecewise_linear_distribution random number
       *        distribution @p __x into the output stream @p __os.
       *
       * @param __os An output stream.
       * @param __x  A %piecewise_linear_distribution random number
       *             distribution.
       *
       * @returns The output stream with the state of @p __x inserted or in
       *          an error state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_ostream&lt;_CharT, _Traits&gt;&amp;
	operator&lt;&lt;(std::basic_ostream&lt;_CharT, _Traits&gt;&amp; __os,
		   const std::piecewise_linear_distribution&lt;_RealType1&gt;&amp; __x);

      /**
       * @brief Extracts a %piecewise_linear_distribution random number
       *        distribution @p __x from the input stream @p __is.
       *
       * @param __is An input stream.
       * @param __x  A %piecewise_linear_distribution random number
       *             generator engine.
       *
       * @returns The input stream with @p __x extracted or in an error
       *          state.
       */
      template&lt;typename _RealType1, typename _CharT, typename _Traits&gt;
	friend std::basic_istream&lt;_CharT, _Traits&gt;&amp;
	operator&gt;&gt;(std::basic_istream&lt;_CharT, _Traits&gt;&amp; __is,
		   std::piecewise_linear_distribution&lt;_RealType1&gt;&amp; __x);

    private:
      template&lt;typename _ForwardIterator,
	       typename _UniformRandomNumberGenerator&gt;
	void
	__generate_impl(_ForwardIterator __f, _ForwardIterator __t,
			_UniformRandomNumberGenerator&amp; __urng,
			const param_type&amp; __p);

      param_type _M_param;
    };

  /**
    * @brief Return true if two piecewise linear distributions have
    *        different parameters.
   */
  template&lt;typename _RealType&gt;
    inline bool
    operator!=(const std::piecewise_linear_distribution&lt;_RealType&gt;&amp; __d1,
	       const std::piecewise_linear_distribution&lt;_RealType&gt;&amp; __d2)
    { return !(__d1 == __d2); }


  /* @} */ // group random_distributions_poisson

  /* @} */ // group random_distributions

  /**
   * @addtogroup random_utilities Random Number Utilities
   * @ingroup random
   * @{
   */

  /**
   * @brief The seed_seq class generates sequences of seeds for random
   *        number generators.
   */
  class seed_seq
  {
  public:
    /** The type of the seed vales. */
    typedef uint_least32_t result_type;

    /** Default constructor. */
    seed_seq() noexcept
    : _M_v()
    { }

    template&lt;typename _IntType&gt;
      seed_seq(std::initializer_list&lt;_IntType&gt; __il);

    template&lt;typename _InputIterator&gt;
      seed_seq(_InputIterator __begin, _InputIterator __end);

    // generating functions
    template&lt;typename _RandomAccessIterator&gt;
      void
      generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);

    // property functions
    size_t size() const noexcept
    { return _M_v.size(); }

    template&lt;typename _OutputIterator&gt;
      void
      param(_OutputIterator __dest) const
      { std::copy(_M_v.begin(), _M_v.end(), __dest); }

    // no copy functions
    seed_seq(const seed_seq&amp;) = delete;
    seed_seq&amp; operator=(const seed_seq&amp;) = delete;

  private:
    std::vector&lt;result_type&gt; _M_v;
  };

  /* @} */ // group random_utilities

  /* @} */ // group random

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

#endif
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fbits'>⬅ Back to Directory</a>