Subversion Repositories Kolibri OS

Rev

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

  1. // random number generation -*- C++ -*-
  2.  
  3. // Copyright (C) 2009-2013 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library.  This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 3, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU General Public License for more details.
  15.  
  16. // Under Section 7 of GPL version 3, you are granted additional
  17. // permissions described in the GCC Runtime Library Exception, version
  18. // 3.1, as published by the Free Software Foundation.
  19.  
  20. // You should have received a copy of the GNU General Public License and
  21. // a copy of the GCC Runtime Library Exception along with this program;
  22. // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  23. // <http://www.gnu.org/licenses/>.
  24.  
  25. /**
  26.  * @file bits/random.h
  27.  *  This is an internal header file, included by other library headers.
  28.  *  Do not attempt to use it directly. @headername{random}
  29.  */
  30.  
  31. #ifndef _RANDOM_H
  32. #define _RANDOM_H 1
  33.  
  34. #include <vector>
  35.  
  36. namespace std _GLIBCXX_VISIBILITY(default)
  37. {
  38. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  39.  
  40.   // [26.4] Random number generation
  41.  
  42.   /**
  43.    * @defgroup random Random Number Generation
  44.    * @ingroup numerics
  45.    *
  46.    * A facility for generating random numbers on selected distributions.
  47.    * @{
  48.    */
  49.  
  50.   /**
  51.    * @brief A function template for converting the output of a (integral)
  52.    * uniform random number generator to a floatng point result in the range
  53.    * [0-1).
  54.    */
  55.   template<typename _RealType, size_t __bits,
  56.            typename _UniformRandomNumberGenerator>
  57.     _RealType
  58.     generate_canonical(_UniformRandomNumberGenerator& __g);
  59.  
  60. _GLIBCXX_END_NAMESPACE_VERSION
  61.  
  62.   /*
  63.    * Implementation-space details.
  64.    */
  65.   namespace __detail
  66.   {
  67.   _GLIBCXX_BEGIN_NAMESPACE_VERSION
  68.  
  69.     template<typename _UIntType, size_t __w,
  70.              bool = __w < static_cast<size_t>
  71.                           (std::numeric_limits<_UIntType>::digits)>
  72.       struct _Shift
  73.       { static const _UIntType __value = 0; };
  74.  
  75.     template<typename _UIntType, size_t __w>
  76.       struct _Shift<_UIntType, __w, true>
  77.       { static const _UIntType __value = _UIntType(1) << __w; };
  78.  
  79.     template<int __s,
  80.              int __which = ((__s <= __CHAR_BIT__ * sizeof (int))
  81.                             + (__s <= __CHAR_BIT__ * sizeof (long))
  82.                             + (__s <= __CHAR_BIT__ * sizeof (long long))
  83.                             /* assume long long no bigger than __int128 */
  84.                             + (__s <= 128))>
  85.       struct _Select_uint_least_t
  86.       {
  87.         static_assert(__which < 0, /* needs to be dependent */
  88.                       "sorry, would be too much trouble for a slow result");
  89.       };
  90.  
  91.     template<int __s>
  92.       struct _Select_uint_least_t<__s, 4>
  93.       { typedef unsigned int type; };
  94.  
  95.     template<int __s>
  96.       struct _Select_uint_least_t<__s, 3>
  97.       { typedef unsigned long type; };
  98.  
  99.     template<int __s>
  100.       struct _Select_uint_least_t<__s, 2>
  101.       { typedef unsigned long long type; };
  102.  
  103. #ifdef _GLIBCXX_USE_INT128
  104.     template<int __s>
  105.       struct _Select_uint_least_t<__s, 1>
  106.       { typedef unsigned __int128 type; };
  107. #endif
  108.  
  109.     // Assume a != 0, a < m, c < m, x < m.
  110.     template<typename _Tp, _Tp __m, _Tp __a, _Tp __c,
  111.              bool __big_enough = (!(__m & (__m - 1))
  112.                                   || (_Tp(-1) - __c) / __a >= __m - 1),
  113.              bool __schrage_ok = __m % __a < __m / __a>
  114.       struct _Mod
  115.       {
  116.         typedef typename _Select_uint_least_t<std::__lg(__a)
  117.                                               + std::__lg(__m) + 2>::type _Tp2;
  118.         static _Tp
  119.         __calc(_Tp __x)
  120.         { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); }
  121.       };
  122.  
  123.     // Schrage.
  124.     template<typename _Tp, _Tp __m, _Tp __a, _Tp __c>
  125.       struct _Mod<_Tp, __m, __a, __c, false, true>
  126.       {
  127.         static _Tp
  128.         __calc(_Tp __x);
  129.       };
  130.  
  131.     // Special cases:
  132.     // - for m == 2^n or m == 0, unsigned integer overflow is safe.
  133.     // - a * (m - 1) + c fits in _Tp, there is no overflow.
  134.     template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s>
  135.       struct _Mod<_Tp, __m, __a, __c, true, __s>
  136.       {
  137.         static _Tp
  138.         __calc(_Tp __x)
  139.         {
  140.           _Tp __res = __a * __x + __c;
  141.           if (__m)
  142.             __res %= __m;
  143.           return __res;
  144.         }
  145.       };
  146.  
  147.     template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0>
  148.       inline _Tp
  149.       __mod(_Tp __x)
  150.       { return _Mod<_Tp, __m, __a, __c>::__calc(__x); }
  151.  
  152.     /* Determine whether number is a power of 2.  */
  153.     template<typename _Tp>
  154.       inline bool
  155.       _Power_of_2(_Tp __x)
  156.       {
  157.         return ((__x - 1) & __x) == 0;
  158.       };
  159.  
  160.     /*
  161.      * An adaptor class for converting the output of any Generator into
  162.      * the input for a specific Distribution.
  163.      */
  164.     template<typename _Engine, typename _DInputType>
  165.       struct _Adaptor
  166.       {
  167.  
  168.       public:
  169.         _Adaptor(_Engine& __g)
  170.         : _M_g(__g) { }
  171.  
  172.         _DInputType
  173.         min() const
  174.         { return _DInputType(0); }
  175.  
  176.         _DInputType
  177.         max() const
  178.         { return _DInputType(1); }
  179.  
  180.         /*
  181.          * Converts a value generated by the adapted random number generator
  182.          * into a value in the input domain for the dependent random number
  183.          * distribution.
  184.          */
  185.         _DInputType
  186.         operator()()
  187.         {
  188.           return std::generate_canonical<_DInputType,
  189.                                     std::numeric_limits<_DInputType>::digits,
  190.                                     _Engine>(_M_g);
  191.         }
  192.  
  193.       private:
  194.         _Engine& _M_g;
  195.       };
  196.  
  197.   _GLIBCXX_END_NAMESPACE_VERSION
  198.   } // namespace __detail
  199.  
  200. _GLIBCXX_BEGIN_NAMESPACE_VERSION
  201.  
  202.   /**
  203.    * @addtogroup random_generators Random Number Generators
  204.    * @ingroup random
  205.    *
  206.    * These classes define objects which provide random or pseudorandom
  207.    * numbers, either from a discrete or a continuous interval.  The
  208.    * random number generator supplied as a part of this library are
  209.    * all uniform random number generators which provide a sequence of
  210.    * random number uniformly distributed over their range.
  211.    *
  212.    * A number generator is a function object with an operator() that
  213.    * takes zero arguments and returns a number.
  214.    *
  215.    * A compliant random number generator must satisfy the following
  216.    * requirements.  <table border=1 cellpadding=10 cellspacing=0>
  217.    * <caption align=top>Random Number Generator Requirements</caption>
  218.    * <tr><td>To be documented.</td></tr> </table>
  219.    *
  220.    * @{
  221.    */
  222.  
  223.   /**
  224.    * @brief A model of a linear congruential random number generator.
  225.    *
  226.    * A random number generator that produces pseudorandom numbers via
  227.    * linear function:
  228.    * @f[
  229.    *     x_{i+1}\leftarrow(ax_{i} + c) \bmod m
  230.    * @f]
  231.    *
  232.    * The template parameter @p _UIntType must be an unsigned integral type
  233.    * large enough to store values up to (__m-1). If the template parameter
  234.    * @p __m is 0, the modulus @p __m used is
  235.    * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template
  236.    * parameters @p __a and @p __c must be less than @p __m.
  237.    *
  238.    * The size of the state is @f$1@f$.
  239.    */
  240.   template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
  241.     class linear_congruential_engine
  242.     {
  243.       static_assert(std::is_unsigned<_UIntType>::value, "template argument "
  244.                     "substituting _UIntType not an unsigned integral type");
  245.       static_assert(__m == 0u || (__a < __m && __c < __m),
  246.                     "template argument substituting __m out of bounds");
  247.  
  248.     public:
  249.       /** The type of the generated random value. */
  250.       typedef _UIntType result_type;
  251.  
  252.       /** The multiplier. */
  253.       static constexpr result_type multiplier   = __a;
  254.       /** An increment. */
  255.       static constexpr result_type increment    = __c;
  256.       /** The modulus. */
  257.       static constexpr result_type modulus      = __m;
  258.       static constexpr result_type default_seed = 1u;
  259.  
  260.       /**
  261.        * @brief Constructs a %linear_congruential_engine random number
  262.        *        generator engine with seed @p __s.  The default seed value
  263.        *        is 1.
  264.        *
  265.        * @param __s The initial seed value.
  266.        */
  267.       explicit
  268.       linear_congruential_engine(result_type __s = default_seed)
  269.       { seed(__s); }
  270.  
  271.       /**
  272.        * @brief Constructs a %linear_congruential_engine random number
  273.        *        generator engine seeded from the seed sequence @p __q.
  274.        *
  275.        * @param __q the seed sequence.
  276.        */
  277.       template<typename _Sseq, typename = typename
  278.         std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value>
  279.                ::type>
  280.         explicit
  281.         linear_congruential_engine(_Sseq& __q)
  282.         { seed(__q); }
  283.  
  284.       /**
  285.        * @brief Reseeds the %linear_congruential_engine random number generator
  286.        *        engine sequence to the seed @p __s.
  287.        *
  288.        * @param __s The new seed.
  289.        */
  290.       void
  291.       seed(result_type __s = default_seed);
  292.  
  293.       /**
  294.        * @brief Reseeds the %linear_congruential_engine random number generator
  295.        *        engine
  296.        * sequence using values from the seed sequence @p __q.
  297.        *
  298.        * @param __q the seed sequence.
  299.        */
  300.       template<typename _Sseq>
  301.         typename std::enable_if<std::is_class<_Sseq>::value>::type
  302.         seed(_Sseq& __q);
  303.  
  304.       /**
  305.        * @brief Gets the smallest possible value in the output range.
  306.        *
  307.        * The minimum depends on the @p __c parameter: if it is zero, the
  308.        * minimum generated must be > 0, otherwise 0 is allowed.
  309.        */
  310.       static constexpr result_type
  311.       min()
  312.       { return __c == 0u ? 1u : 0u; }
  313.  
  314.       /**
  315.        * @brief Gets the largest possible value in the output range.
  316.        */
  317.       static constexpr result_type
  318.       max()
  319.       { return __m - 1u; }
  320.  
  321.       /**
  322.        * @brief Discard a sequence of random numbers.
  323.        */
  324.       void
  325.       discard(unsigned long long __z)
  326.       {
  327.         for (; __z != 0ULL; --__z)
  328.           (*this)();
  329.       }
  330.  
  331.       /**
  332.        * @brief Gets the next random number in the sequence.
  333.        */
  334.       result_type
  335.       operator()()
  336.       {
  337.         _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x);
  338.         return _M_x;
  339.       }
  340.  
  341.       /**
  342.        * @brief Compares two linear congruential random number generator
  343.        * objects of the same type for equality.
  344.        *
  345.        * @param __lhs A linear congruential random number generator object.
  346.        * @param __rhs Another linear congruential random number generator
  347.        *              object.
  348.        *
  349.        * @returns true if the infinite sequences of generated values
  350.        *          would be equal, false otherwise.
  351.        */
  352.       friend bool
  353.       operator==(const linear_congruential_engine& __lhs,
  354.                  const linear_congruential_engine& __rhs)
  355.       { return __lhs._M_x == __rhs._M_x; }
  356.  
  357.       /**
  358.        * @brief Writes the textual representation of the state x(i) of x to
  359.        *        @p __os.
  360.        *
  361.        * @param __os  The output stream.
  362.        * @param __lcr A % linear_congruential_engine random number generator.
  363.        * @returns __os.
  364.        */
  365.       template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
  366.                _UIntType1 __m1, typename _CharT, typename _Traits>
  367.         friend std::basic_ostream<_CharT, _Traits>&
  368.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  369.                    const std::linear_congruential_engine<_UIntType1,
  370.                    __a1, __c1, __m1>& __lcr);
  371.  
  372.       /**
  373.        * @brief Sets the state of the engine by reading its textual
  374.        *        representation from @p __is.
  375.        *
  376.        * The textual representation must have been previously written using
  377.        * an output stream whose imbued locale and whose type's template
  378.        * specialization arguments _CharT and _Traits were the same as those
  379.        * of @p __is.
  380.        *
  381.        * @param __is  The input stream.
  382.        * @param __lcr A % linear_congruential_engine random number generator.
  383.        * @returns __is.
  384.        */
  385.       template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1,
  386.                _UIntType1 __m1, typename _CharT, typename _Traits>
  387.         friend std::basic_istream<_CharT, _Traits>&
  388.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  389.                    std::linear_congruential_engine<_UIntType1, __a1,
  390.                    __c1, __m1>& __lcr);
  391.  
  392.     private:
  393.       _UIntType _M_x;
  394.     };
  395.  
  396.   /**
  397.    * @brief Compares two linear congruential random number generator
  398.    * objects of the same type for inequality.
  399.    *
  400.    * @param __lhs A linear congruential random number generator object.
  401.    * @param __rhs Another linear congruential random number generator
  402.    *              object.
  403.    *
  404.    * @returns true if the infinite sequences of generated values
  405.    *          would be different, false otherwise.
  406.    */
  407.   template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
  408.     inline bool
  409.     operator!=(const std::linear_congruential_engine<_UIntType, __a,
  410.                __c, __m>& __lhs,
  411.                const std::linear_congruential_engine<_UIntType, __a,
  412.                __c, __m>& __rhs)
  413.     { return !(__lhs == __rhs); }
  414.  
  415.  
  416.   /**
  417.    * A generalized feedback shift register discrete random number generator.
  418.    *
  419.    * This algorithm avoids multiplication and division and is designed to be
  420.    * friendly to a pipelined architecture.  If the parameters are chosen
  421.    * correctly, this generator will produce numbers with a very long period and
  422.    * fairly good apparent entropy, although still not cryptographically strong.
  423.    *
  424.    * The best way to use this generator is with the predefined mt19937 class.
  425.    *
  426.    * This algorithm was originally invented by Makoto Matsumoto and
  427.    * Takuji Nishimura.
  428.    *
  429.    * @tparam __w  Word size, the number of bits in each element of
  430.    *              the state vector.
  431.    * @tparam __n  The degree of recursion.
  432.    * @tparam __m  The period parameter.
  433.    * @tparam __r  The separation point bit index.
  434.    * @tparam __a  The last row of the twist matrix.
  435.    * @tparam __u  The first right-shift tempering matrix parameter.
  436.    * @tparam __d  The first right-shift tempering matrix mask.
  437.    * @tparam __s  The first left-shift tempering matrix parameter.
  438.    * @tparam __b  The first left-shift tempering matrix mask.
  439.    * @tparam __t  The second left-shift tempering matrix parameter.
  440.    * @tparam __c  The second left-shift tempering matrix mask.
  441.    * @tparam __l  The second right-shift tempering matrix parameter.
  442.    * @tparam __f  Initialization multiplier.
  443.    */
  444.   template<typename _UIntType, size_t __w,
  445.            size_t __n, size_t __m, size_t __r,
  446.            _UIntType __a, size_t __u, _UIntType __d, size_t __s,
  447.            _UIntType __b, size_t __t,
  448.            _UIntType __c, size_t __l, _UIntType __f>
  449.     class mersenne_twister_engine
  450.     {
  451.       static_assert(std::is_unsigned<_UIntType>::value, "template argument "
  452.                     "substituting _UIntType not an unsigned integral type");
  453.       static_assert(1u <= __m && __m <= __n,
  454.                     "template argument substituting __m out of bounds");
  455.       static_assert(__r <= __w, "template argument substituting "
  456.                     "__r out of bound");
  457.       static_assert(__u <= __w, "template argument substituting "
  458.                     "__u out of bound");
  459.       static_assert(__s <= __w, "template argument substituting "
  460.                     "__s out of bound");
  461.       static_assert(__t <= __w, "template argument substituting "
  462.                     "__t out of bound");
  463.       static_assert(__l <= __w, "template argument substituting "
  464.                     "__l out of bound");
  465.       static_assert(__w <= std::numeric_limits<_UIntType>::digits,
  466.                     "template argument substituting __w out of bound");
  467.       static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1),
  468.                     "template argument substituting __a out of bound");
  469.       static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1),
  470.                     "template argument substituting __b out of bound");
  471.       static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1),
  472.                     "template argument substituting __c out of bound");
  473.       static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1),
  474.                     "template argument substituting __d out of bound");
  475.       static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1),
  476.                     "template argument substituting __f out of bound");
  477.  
  478.     public:
  479.       /** The type of the generated random value. */
  480.       typedef _UIntType result_type;
  481.  
  482.       // parameter values
  483.       static constexpr size_t      word_size                 = __w;
  484.       static constexpr size_t      state_size                = __n;
  485.       static constexpr size_t      shift_size                = __m;
  486.       static constexpr size_t      mask_bits                 = __r;
  487.       static constexpr result_type xor_mask                  = __a;
  488.       static constexpr size_t      tempering_u               = __u;
  489.       static constexpr result_type tempering_d               = __d;
  490.       static constexpr size_t      tempering_s               = __s;
  491.       static constexpr result_type tempering_b               = __b;
  492.       static constexpr size_t      tempering_t               = __t;
  493.       static constexpr result_type tempering_c               = __c;
  494.       static constexpr size_t      tempering_l               = __l;
  495.       static constexpr result_type initialization_multiplier = __f;
  496.       static constexpr result_type default_seed = 5489u;
  497.  
  498.       // constructors and member function
  499.       explicit
  500.       mersenne_twister_engine(result_type __sd = default_seed)
  501.       { seed(__sd); }
  502.  
  503.       /**
  504.        * @brief Constructs a %mersenne_twister_engine random number generator
  505.        *        engine seeded from the seed sequence @p __q.
  506.        *
  507.        * @param __q the seed sequence.
  508.        */
  509.       template<typename _Sseq, typename = typename
  510.         std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value>
  511.                ::type>
  512.         explicit
  513.         mersenne_twister_engine(_Sseq& __q)
  514.         { seed(__q); }
  515.  
  516.       void
  517.       seed(result_type __sd = default_seed);
  518.  
  519.       template<typename _Sseq>
  520.         typename std::enable_if<std::is_class<_Sseq>::value>::type
  521.         seed(_Sseq& __q);
  522.  
  523.       /**
  524.        * @brief Gets the smallest possible value in the output range.
  525.        */
  526.       static constexpr result_type
  527.       min()
  528.       { return 0; };
  529.  
  530.       /**
  531.        * @brief Gets the largest possible value in the output range.
  532.        */
  533.       static constexpr result_type
  534.       max()
  535.       { return __detail::_Shift<_UIntType, __w>::__value - 1; }
  536.  
  537.       /**
  538.        * @brief Discard a sequence of random numbers.
  539.        */
  540.       void
  541.       discard(unsigned long long __z);
  542.  
  543.       result_type
  544.       operator()();
  545.  
  546.       /**
  547.        * @brief Compares two % mersenne_twister_engine random number generator
  548.        *        objects of the same type for equality.
  549.        *
  550.        * @param __lhs A % mersenne_twister_engine random number generator
  551.        *              object.
  552.        * @param __rhs Another % mersenne_twister_engine random number
  553.        *              generator object.
  554.        *
  555.        * @returns true if the infinite sequences of generated values
  556.        *          would be equal, false otherwise.
  557.        */
  558.       friend bool
  559.       operator==(const mersenne_twister_engine& __lhs,
  560.                  const mersenne_twister_engine& __rhs)
  561.       { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x)
  562.                 && __lhs._M_p == __rhs._M_p); }
  563.  
  564.       /**
  565.        * @brief Inserts the current state of a % mersenne_twister_engine
  566.        *        random number generator engine @p __x into the output stream
  567.        *        @p __os.
  568.        *
  569.        * @param __os An output stream.
  570.        * @param __x  A % mersenne_twister_engine random number generator
  571.        *             engine.
  572.        *
  573.        * @returns The output stream with the state of @p __x inserted or in
  574.        * an error state.
  575.        */
  576.       template<typename _UIntType1,
  577.                size_t __w1, size_t __n1,
  578.                size_t __m1, size_t __r1,
  579.                _UIntType1 __a1, size_t __u1,
  580.                _UIntType1 __d1, size_t __s1,
  581.                _UIntType1 __b1, size_t __t1,
  582.                _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
  583.                typename _CharT, typename _Traits>
  584.         friend std::basic_ostream<_CharT, _Traits>&
  585.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  586.                    const std::mersenne_twister_engine<_UIntType1, __w1, __n1,
  587.                    __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
  588.                    __l1, __f1>& __x);
  589.  
  590.       /**
  591.        * @brief Extracts the current state of a % mersenne_twister_engine
  592.        *        random number generator engine @p __x from the input stream
  593.        *        @p __is.
  594.        *
  595.        * @param __is An input stream.
  596.        * @param __x  A % mersenne_twister_engine random number generator
  597.        *             engine.
  598.        *
  599.        * @returns The input stream with the state of @p __x extracted or in
  600.        * an error state.
  601.        */
  602.       template<typename _UIntType1,
  603.                size_t __w1, size_t __n1,
  604.                size_t __m1, size_t __r1,
  605.                _UIntType1 __a1, size_t __u1,
  606.                _UIntType1 __d1, size_t __s1,
  607.                _UIntType1 __b1, size_t __t1,
  608.                _UIntType1 __c1, size_t __l1, _UIntType1 __f1,
  609.                typename _CharT, typename _Traits>
  610.         friend std::basic_istream<_CharT, _Traits>&
  611.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  612.                    std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1,
  613.                    __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1,
  614.                    __l1, __f1>& __x);
  615.  
  616.     private:
  617.       void _M_gen_rand();
  618.  
  619.       _UIntType _M_x[state_size];
  620.       size_t    _M_p;
  621.     };
  622.  
  623.   /**
  624.    * @brief Compares two % mersenne_twister_engine random number generator
  625.    *        objects of the same type for inequality.
  626.    *
  627.    * @param __lhs A % mersenne_twister_engine random number generator
  628.    *              object.
  629.    * @param __rhs Another % mersenne_twister_engine random number
  630.    *              generator object.
  631.    *
  632.    * @returns true if the infinite sequences of generated values
  633.    *          would be different, false otherwise.
  634.    */
  635.   template<typename _UIntType, size_t __w,
  636.            size_t __n, size_t __m, size_t __r,
  637.            _UIntType __a, size_t __u, _UIntType __d, size_t __s,
  638.            _UIntType __b, size_t __t,
  639.            _UIntType __c, size_t __l, _UIntType __f>
  640.     inline bool
  641.     operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
  642.                __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs,
  643.                const std::mersenne_twister_engine<_UIntType, __w, __n, __m,
  644.                __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs)
  645.     { return !(__lhs == __rhs); }
  646.  
  647.  
  648.   /**
  649.    * @brief The Marsaglia-Zaman generator.
  650.    *
  651.    * This is a model of a Generalized Fibonacci discrete random number
  652.    * generator, sometimes referred to as the SWC generator.
  653.    *
  654.    * A discrete random number generator that produces pseudorandom
  655.    * numbers using:
  656.    * @f[
  657.    *     x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m
  658.    * @f]
  659.    *
  660.    * The size of the state is @f$r@f$
  661.    * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$.
  662.    *
  663.    * @var _M_x     The state of the generator.  This is a ring buffer.
  664.    * @var _M_carry The carry.
  665.    * @var _M_p     Current index of x(i - r).
  666.    */
  667.   template<typename _UIntType, size_t __w, size_t __s, size_t __r>
  668.     class subtract_with_carry_engine
  669.     {
  670.       static_assert(std::is_unsigned<_UIntType>::value, "template argument "
  671.                     "substituting _UIntType not an unsigned integral type");
  672.       static_assert(0u < __s && __s < __r,
  673.                     "template argument substituting __s out of bounds");
  674.       static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
  675.                     "template argument substituting __w out of bounds");
  676.  
  677.     public:
  678.       /** The type of the generated random value. */
  679.       typedef _UIntType result_type;
  680.  
  681.       // parameter values
  682.       static constexpr size_t      word_size    = __w;
  683.       static constexpr size_t      short_lag    = __s;
  684.       static constexpr size_t      long_lag     = __r;
  685.       static constexpr result_type default_seed = 19780503u;
  686.  
  687.       /**
  688.        * @brief Constructs an explicitly seeded % subtract_with_carry_engine
  689.        *        random number generator.
  690.        */
  691.       explicit
  692.       subtract_with_carry_engine(result_type __sd = default_seed)
  693.       { seed(__sd); }
  694.  
  695.       /**
  696.        * @brief Constructs a %subtract_with_carry_engine random number engine
  697.        *        seeded from the seed sequence @p __q.
  698.        *
  699.        * @param __q the seed sequence.
  700.        */
  701.       template<typename _Sseq, typename = typename
  702.         std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value>
  703.                ::type>
  704.         explicit
  705.         subtract_with_carry_engine(_Sseq& __q)
  706.         { seed(__q); }
  707.  
  708.       /**
  709.        * @brief Seeds the initial state @f$x_0@f$ of the random number
  710.        *        generator.
  711.        *
  712.        * N1688[4.19] modifies this as follows.  If @p __value == 0,
  713.        * sets value to 19780503.  In any case, with a linear
  714.        * congruential generator lcg(i) having parameters @f$ m_{lcg} =
  715.        * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value
  716.        * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m
  717.        * \dots lcg(r) \bmod m @f$ respectively.  If @f$ x_{-1} = 0 @f$
  718.        * set carry to 1, otherwise sets carry to 0.
  719.        */
  720.       void
  721.       seed(result_type __sd = default_seed);
  722.  
  723.       /**
  724.        * @brief Seeds the initial state @f$x_0@f$ of the
  725.        * % subtract_with_carry_engine random number generator.
  726.        */
  727.       template<typename _Sseq>
  728.         typename std::enable_if<std::is_class<_Sseq>::value>::type
  729.         seed(_Sseq& __q);
  730.  
  731.       /**
  732.        * @brief Gets the inclusive minimum value of the range of random
  733.        * integers returned by this generator.
  734.        */
  735.       static constexpr result_type
  736.       min()
  737.       { return 0; }
  738.  
  739.       /**
  740.        * @brief Gets the inclusive maximum value of the range of random
  741.        * integers returned by this generator.
  742.        */
  743.       static constexpr result_type
  744.       max()
  745.       { return __detail::_Shift<_UIntType, __w>::__value - 1; }
  746.  
  747.       /**
  748.        * @brief Discard a sequence of random numbers.
  749.        */
  750.       void
  751.       discard(unsigned long long __z)
  752.       {
  753.         for (; __z != 0ULL; --__z)
  754.           (*this)();
  755.       }
  756.  
  757.       /**
  758.        * @brief Gets the next random number in the sequence.
  759.        */
  760.       result_type
  761.       operator()();
  762.  
  763.       /**
  764.        * @brief Compares two % subtract_with_carry_engine random number
  765.        *        generator objects of the same type for equality.
  766.        *
  767.        * @param __lhs A % subtract_with_carry_engine random number generator
  768.        *              object.
  769.        * @param __rhs Another % subtract_with_carry_engine random number
  770.        *              generator object.
  771.        *
  772.        * @returns true if the infinite sequences of generated values
  773.        *          would be equal, false otherwise.
  774.       */
  775.       friend bool
  776.       operator==(const subtract_with_carry_engine& __lhs,
  777.                  const subtract_with_carry_engine& __rhs)
  778.       { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x)
  779.                 && __lhs._M_carry == __rhs._M_carry
  780.                 && __lhs._M_p == __rhs._M_p); }
  781.  
  782.       /**
  783.        * @brief Inserts the current state of a % subtract_with_carry_engine
  784.        *        random number generator engine @p __x into the output stream
  785.        *        @p __os.
  786.        *
  787.        * @param __os An output stream.
  788.        * @param __x  A % subtract_with_carry_engine random number generator
  789.        *             engine.
  790.        *
  791.        * @returns The output stream with the state of @p __x inserted or in
  792.        * an error state.
  793.        */
  794.       template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
  795.                typename _CharT, typename _Traits>
  796.         friend std::basic_ostream<_CharT, _Traits>&
  797.         operator<<(std::basic_ostream<_CharT, _Traits>&,
  798.                    const std::subtract_with_carry_engine<_UIntType1, __w1,
  799.                    __s1, __r1>&);
  800.  
  801.       /**
  802.        * @brief Extracts the current state of a % subtract_with_carry_engine
  803.        *        random number generator engine @p __x from the input stream
  804.        *        @p __is.
  805.        *
  806.        * @param __is An input stream.
  807.        * @param __x  A % subtract_with_carry_engine random number generator
  808.        *             engine.
  809.        *
  810.        * @returns The input stream with the state of @p __x extracted or in
  811.        * an error state.
  812.        */
  813.       template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1,
  814.                typename _CharT, typename _Traits>
  815.         friend std::basic_istream<_CharT, _Traits>&
  816.         operator>>(std::basic_istream<_CharT, _Traits>&,
  817.                    std::subtract_with_carry_engine<_UIntType1, __w1,
  818.                    __s1, __r1>&);
  819.  
  820.     private:
  821.       _UIntType  _M_x[long_lag];
  822.       _UIntType  _M_carry;
  823.       size_t     _M_p;
  824.     };
  825.  
  826.   /**
  827.    * @brief Compares two % subtract_with_carry_engine random number
  828.    *        generator objects of the same type for inequality.
  829.    *
  830.    * @param __lhs A % subtract_with_carry_engine random number generator
  831.    *              object.
  832.    * @param __rhs Another % subtract_with_carry_engine random number
  833.    *              generator object.
  834.    *
  835.    * @returns true if the infinite sequences of generated values
  836.    *          would be different, false otherwise.
  837.    */
  838.   template<typename _UIntType, size_t __w, size_t __s, size_t __r>
  839.     inline bool
  840.     operator!=(const std::subtract_with_carry_engine<_UIntType, __w,
  841.                __s, __r>& __lhs,
  842.                const std::subtract_with_carry_engine<_UIntType, __w,
  843.                __s, __r>& __rhs)
  844.     { return !(__lhs == __rhs); }
  845.  
  846.  
  847.   /**
  848.    * Produces random numbers from some base engine by discarding blocks of
  849.    * data.
  850.    *
  851.    * 0 <= @p __r <= @p __p
  852.    */
  853.   template<typename _RandomNumberEngine, size_t __p, size_t __r>
  854.     class discard_block_engine
  855.     {
  856.       static_assert(1 <= __r && __r <= __p,
  857.                     "template argument substituting __r out of bounds");
  858.  
  859.     public:
  860.       /** The type of the generated random value. */
  861.       typedef typename _RandomNumberEngine::result_type result_type;
  862.  
  863.       // parameter values
  864.       static constexpr size_t block_size = __p;
  865.       static constexpr size_t used_block = __r;
  866.  
  867.       /**
  868.        * @brief Constructs a default %discard_block_engine engine.
  869.        *
  870.        * The underlying engine is default constructed as well.
  871.        */
  872.       discard_block_engine()
  873.       : _M_b(), _M_n(0) { }
  874.  
  875.       /**
  876.        * @brief Copy constructs a %discard_block_engine engine.
  877.        *
  878.        * Copies an existing base class random number generator.
  879.        * @param __rng An existing (base class) engine object.
  880.        */
  881.       explicit
  882.       discard_block_engine(const _RandomNumberEngine& __rng)
  883.       : _M_b(__rng), _M_n(0) { }
  884.  
  885.       /**
  886.        * @brief Move constructs a %discard_block_engine engine.
  887.        *
  888.        * Copies an existing base class random number generator.
  889.        * @param __rng An existing (base class) engine object.
  890.        */
  891.       explicit
  892.       discard_block_engine(_RandomNumberEngine&& __rng)
  893.       : _M_b(std::move(__rng)), _M_n(0) { }
  894.  
  895.       /**
  896.        * @brief Seed constructs a %discard_block_engine engine.
  897.        *
  898.        * Constructs the underlying generator engine seeded with @p __s.
  899.        * @param __s A seed value for the base class engine.
  900.        */
  901.       explicit
  902.       discard_block_engine(result_type __s)
  903.       : _M_b(__s), _M_n(0) { }
  904.  
  905.       /**
  906.        * @brief Generator construct a %discard_block_engine engine.
  907.        *
  908.        * @param __q A seed sequence.
  909.        */
  910.       template<typename _Sseq, typename = typename
  911.         std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value
  912.                        && !std::is_same<_Sseq, _RandomNumberEngine>::value>
  913.                ::type>
  914.         explicit
  915.         discard_block_engine(_Sseq& __q)
  916.         : _M_b(__q), _M_n(0)
  917.         { }
  918.  
  919.       /**
  920.        * @brief Reseeds the %discard_block_engine object with the default
  921.        *        seed for the underlying base class generator engine.
  922.        */
  923.       void
  924.       seed()
  925.       {
  926.         _M_b.seed();
  927.         _M_n = 0;
  928.       }
  929.  
  930.       /**
  931.        * @brief Reseeds the %discard_block_engine object with the default
  932.        *        seed for the underlying base class generator engine.
  933.        */
  934.       void
  935.       seed(result_type __s)
  936.       {
  937.         _M_b.seed(__s);
  938.         _M_n = 0;
  939.       }
  940.  
  941.       /**
  942.        * @brief Reseeds the %discard_block_engine object with the given seed
  943.        *        sequence.
  944.        * @param __q A seed generator function.
  945.        */
  946.       template<typename _Sseq>
  947.         void
  948.         seed(_Sseq& __q)
  949.         {
  950.           _M_b.seed(__q);
  951.           _M_n = 0;
  952.         }
  953.  
  954.       /**
  955.        * @brief Gets a const reference to the underlying generator engine
  956.        *        object.
  957.        */
  958.       const _RandomNumberEngine&
  959.       base() const noexcept
  960.       { return _M_b; }
  961.  
  962.       /**
  963.        * @brief Gets the minimum value in the generated random number range.
  964.        */
  965.       static constexpr result_type
  966.       min()
  967.       { return _RandomNumberEngine::min(); }
  968.  
  969.       /**
  970.        * @brief Gets the maximum value in the generated random number range.
  971.        */
  972.       static constexpr result_type
  973.       max()
  974.       { return _RandomNumberEngine::max(); }
  975.  
  976.       /**
  977.        * @brief Discard a sequence of random numbers.
  978.        */
  979.       void
  980.       discard(unsigned long long __z)
  981.       {
  982.         for (; __z != 0ULL; --__z)
  983.           (*this)();
  984.       }
  985.  
  986.       /**
  987.        * @brief Gets the next value in the generated random number sequence.
  988.        */
  989.       result_type
  990.       operator()();
  991.  
  992.       /**
  993.        * @brief Compares two %discard_block_engine random number generator
  994.        *        objects of the same type for equality.
  995.        *
  996.        * @param __lhs A %discard_block_engine random number generator object.
  997.        * @param __rhs Another %discard_block_engine random number generator
  998.        *              object.
  999.        *
  1000.        * @returns true if the infinite sequences of generated values
  1001.        *          would be equal, false otherwise.
  1002.        */
  1003.       friend bool
  1004.       operator==(const discard_block_engine& __lhs,
  1005.                  const discard_block_engine& __rhs)
  1006.       { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; }
  1007.  
  1008.       /**
  1009.        * @brief Inserts the current state of a %discard_block_engine random
  1010.        *        number generator engine @p __x into the output stream
  1011.        *        @p __os.
  1012.        *
  1013.        * @param __os An output stream.
  1014.        * @param __x  A %discard_block_engine random number generator engine.
  1015.        *
  1016.        * @returns The output stream with the state of @p __x inserted or in
  1017.        * an error state.
  1018.        */
  1019.       template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
  1020.                typename _CharT, typename _Traits>
  1021.         friend std::basic_ostream<_CharT, _Traits>&
  1022.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  1023.                    const std::discard_block_engine<_RandomNumberEngine1,
  1024.                    __p1, __r1>& __x);
  1025.  
  1026.       /**
  1027.        * @brief Extracts the current state of a % subtract_with_carry_engine
  1028.        *        random number generator engine @p __x from the input stream
  1029.        *        @p __is.
  1030.        *
  1031.        * @param __is An input stream.
  1032.        * @param __x  A %discard_block_engine random number generator engine.
  1033.        *
  1034.        * @returns The input stream with the state of @p __x extracted or in
  1035.        * an error state.
  1036.        */
  1037.       template<typename _RandomNumberEngine1, size_t __p1, size_t __r1,
  1038.                typename _CharT, typename _Traits>
  1039.         friend std::basic_istream<_CharT, _Traits>&
  1040.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  1041.                    std::discard_block_engine<_RandomNumberEngine1,
  1042.                    __p1, __r1>& __x);
  1043.  
  1044.     private:
  1045.       _RandomNumberEngine _M_b;
  1046.       size_t _M_n;
  1047.     };
  1048.  
  1049.   /**
  1050.    * @brief Compares two %discard_block_engine random number generator
  1051.    *        objects of the same type for inequality.
  1052.    *
  1053.    * @param __lhs A %discard_block_engine random number generator object.
  1054.    * @param __rhs Another %discard_block_engine random number generator
  1055.    *              object.
  1056.    *
  1057.    * @returns true if the infinite sequences of generated values
  1058.    *          would be different, false otherwise.
  1059.    */
  1060.   template<typename _RandomNumberEngine, size_t __p, size_t __r>
  1061.     inline bool
  1062.     operator!=(const std::discard_block_engine<_RandomNumberEngine, __p,
  1063.                __r>& __lhs,
  1064.                const std::discard_block_engine<_RandomNumberEngine, __p,
  1065.                __r>& __rhs)
  1066.     { return !(__lhs == __rhs); }
  1067.  
  1068.  
  1069.   /**
  1070.    * Produces random numbers by combining random numbers from some base
  1071.    * engine to produce random numbers with a specifies number of bits @p __w.
  1072.    */
  1073.   template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
  1074.     class independent_bits_engine
  1075.     {
  1076.       static_assert(std::is_unsigned<_UIntType>::value, "template argument "
  1077.                     "substituting _UIntType not an unsigned integral type");
  1078.       static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits,
  1079.                     "template argument substituting __w out of bounds");
  1080.  
  1081.     public:
  1082.       /** The type of the generated random value. */
  1083.       typedef _UIntType result_type;
  1084.  
  1085.       /**
  1086.        * @brief Constructs a default %independent_bits_engine engine.
  1087.        *
  1088.        * The underlying engine is default constructed as well.
  1089.        */
  1090.       independent_bits_engine()
  1091.       : _M_b() { }
  1092.  
  1093.       /**
  1094.        * @brief Copy constructs a %independent_bits_engine engine.
  1095.        *
  1096.        * Copies an existing base class random number generator.
  1097.        * @param __rng An existing (base class) engine object.
  1098.        */
  1099.       explicit
  1100.       independent_bits_engine(const _RandomNumberEngine& __rng)
  1101.       : _M_b(__rng) { }
  1102.  
  1103.       /**
  1104.        * @brief Move constructs a %independent_bits_engine engine.
  1105.        *
  1106.        * Copies an existing base class random number generator.
  1107.        * @param __rng An existing (base class) engine object.
  1108.        */
  1109.       explicit
  1110.       independent_bits_engine(_RandomNumberEngine&& __rng)
  1111.       : _M_b(std::move(__rng)) { }
  1112.  
  1113.       /**
  1114.        * @brief Seed constructs a %independent_bits_engine engine.
  1115.        *
  1116.        * Constructs the underlying generator engine seeded with @p __s.
  1117.        * @param __s A seed value for the base class engine.
  1118.        */
  1119.       explicit
  1120.       independent_bits_engine(result_type __s)
  1121.       : _M_b(__s) { }
  1122.  
  1123.       /**
  1124.        * @brief Generator construct a %independent_bits_engine engine.
  1125.        *
  1126.        * @param __q A seed sequence.
  1127.        */
  1128.       template<typename _Sseq, typename = typename
  1129.         std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value
  1130.                        && !std::is_same<_Sseq, _RandomNumberEngine>::value>
  1131.                ::type>
  1132.         explicit
  1133.         independent_bits_engine(_Sseq& __q)
  1134.         : _M_b(__q)
  1135.         { }
  1136.  
  1137.       /**
  1138.        * @brief Reseeds the %independent_bits_engine object with the default
  1139.        *        seed for the underlying base class generator engine.
  1140.        */
  1141.       void
  1142.       seed()
  1143.       { _M_b.seed(); }
  1144.  
  1145.       /**
  1146.        * @brief Reseeds the %independent_bits_engine object with the default
  1147.        *        seed for the underlying base class generator engine.
  1148.        */
  1149.       void
  1150.       seed(result_type __s)
  1151.       { _M_b.seed(__s); }
  1152.  
  1153.       /**
  1154.        * @brief Reseeds the %independent_bits_engine object with the given
  1155.        *        seed sequence.
  1156.        * @param __q A seed generator function.
  1157.        */
  1158.       template<typename _Sseq>
  1159.         void
  1160.         seed(_Sseq& __q)
  1161.         { _M_b.seed(__q); }
  1162.  
  1163.       /**
  1164.        * @brief Gets a const reference to the underlying generator engine
  1165.        *        object.
  1166.        */
  1167.       const _RandomNumberEngine&
  1168.       base() const noexcept
  1169.       { return _M_b; }
  1170.  
  1171.       /**
  1172.        * @brief Gets the minimum value in the generated random number range.
  1173.        */
  1174.       static constexpr result_type
  1175.       min()
  1176.       { return 0U; }
  1177.  
  1178.       /**
  1179.        * @brief Gets the maximum value in the generated random number range.
  1180.        */
  1181.       static constexpr result_type
  1182.       max()
  1183.       { return __detail::_Shift<_UIntType, __w>::__value - 1; }
  1184.  
  1185.       /**
  1186.        * @brief Discard a sequence of random numbers.
  1187.        */
  1188.       void
  1189.       discard(unsigned long long __z)
  1190.       {
  1191.         for (; __z != 0ULL; --__z)
  1192.           (*this)();
  1193.       }
  1194.  
  1195.       /**
  1196.        * @brief Gets the next value in the generated random number sequence.
  1197.        */
  1198.       result_type
  1199.       operator()();
  1200.  
  1201.       /**
  1202.        * @brief Compares two %independent_bits_engine random number generator
  1203.        * objects of the same type for equality.
  1204.        *
  1205.        * @param __lhs A %independent_bits_engine random number generator
  1206.        *              object.
  1207.        * @param __rhs Another %independent_bits_engine random number generator
  1208.        *              object.
  1209.        *
  1210.        * @returns true if the infinite sequences of generated values
  1211.        *          would be equal, false otherwise.
  1212.        */
  1213.       friend bool
  1214.       operator==(const independent_bits_engine& __lhs,
  1215.                  const independent_bits_engine& __rhs)
  1216.       { return __lhs._M_b == __rhs._M_b; }
  1217.  
  1218.       /**
  1219.        * @brief Extracts the current state of a % subtract_with_carry_engine
  1220.        *        random number generator engine @p __x from the input stream
  1221.        *        @p __is.
  1222.        *
  1223.        * @param __is An input stream.
  1224.        * @param __x  A %independent_bits_engine random number generator
  1225.        *             engine.
  1226.        *
  1227.        * @returns The input stream with the state of @p __x extracted or in
  1228.        *          an error state.
  1229.        */
  1230.       template<typename _CharT, typename _Traits>
  1231.         friend std::basic_istream<_CharT, _Traits>&
  1232.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  1233.                    std::independent_bits_engine<_RandomNumberEngine,
  1234.                    __w, _UIntType>& __x)
  1235.         {
  1236.           __is >> __x._M_b;
  1237.           return __is;
  1238.         }
  1239.  
  1240.     private:
  1241.       _RandomNumberEngine _M_b;
  1242.     };
  1243.  
  1244.   /**
  1245.    * @brief Compares two %independent_bits_engine random number generator
  1246.    * objects of the same type for inequality.
  1247.    *
  1248.    * @param __lhs A %independent_bits_engine random number generator
  1249.    *              object.
  1250.    * @param __rhs Another %independent_bits_engine random number generator
  1251.    *              object.
  1252.    *
  1253.    * @returns true if the infinite sequences of generated values
  1254.    *          would be different, false otherwise.
  1255.    */
  1256.   template<typename _RandomNumberEngine, size_t __w, typename _UIntType>
  1257.     inline bool
  1258.     operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w,
  1259.                _UIntType>& __lhs,
  1260.                const std::independent_bits_engine<_RandomNumberEngine, __w,
  1261.                _UIntType>& __rhs)
  1262.     { return !(__lhs == __rhs); }
  1263.  
  1264.   /**
  1265.    * @brief Inserts the current state of a %independent_bits_engine random
  1266.    *        number generator engine @p __x into the output stream @p __os.
  1267.    *
  1268.    * @param __os An output stream.
  1269.    * @param __x  A %independent_bits_engine random number generator engine.
  1270.    *
  1271.    * @returns The output stream with the state of @p __x inserted or in
  1272.    *          an error state.
  1273.    */
  1274.   template<typename _RandomNumberEngine, size_t __w, typename _UIntType,
  1275.            typename _CharT, typename _Traits>
  1276.     std::basic_ostream<_CharT, _Traits>&
  1277.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  1278.                const std::independent_bits_engine<_RandomNumberEngine,
  1279.                __w, _UIntType>& __x)
  1280.     {
  1281.       __os << __x.base();
  1282.       return __os;
  1283.     }
  1284.  
  1285.  
  1286.   /**
  1287.    * @brief Produces random numbers by combining random numbers from some
  1288.    * base engine to produce random numbers with a specifies number of bits
  1289.    * @p __w.
  1290.    */
  1291.   template<typename _RandomNumberEngine, size_t __k>
  1292.     class shuffle_order_engine
  1293.     {
  1294.       static_assert(1u <= __k, "template argument substituting "
  1295.                     "__k out of bound");
  1296.  
  1297.     public:
  1298.       /** The type of the generated random value. */
  1299.       typedef typename _RandomNumberEngine::result_type result_type;
  1300.  
  1301.       static constexpr size_t table_size = __k;
  1302.  
  1303.       /**
  1304.        * @brief Constructs a default %shuffle_order_engine engine.
  1305.        *
  1306.        * The underlying engine is default constructed as well.
  1307.        */
  1308.       shuffle_order_engine()
  1309.       : _M_b()
  1310.       { _M_initialize(); }
  1311.  
  1312.       /**
  1313.        * @brief Copy constructs a %shuffle_order_engine engine.
  1314.        *
  1315.        * Copies an existing base class random number generator.
  1316.        * @param __rng An existing (base class) engine object.
  1317.        */
  1318.       explicit
  1319.       shuffle_order_engine(const _RandomNumberEngine& __rng)
  1320.       : _M_b(__rng)
  1321.       { _M_initialize(); }
  1322.  
  1323.       /**
  1324.        * @brief Move constructs a %shuffle_order_engine engine.
  1325.        *
  1326.        * Copies an existing base class random number generator.
  1327.        * @param __rng An existing (base class) engine object.
  1328.        */
  1329.       explicit
  1330.       shuffle_order_engine(_RandomNumberEngine&& __rng)
  1331.       : _M_b(std::move(__rng))
  1332.       { _M_initialize(); }
  1333.  
  1334.       /**
  1335.        * @brief Seed constructs a %shuffle_order_engine engine.
  1336.        *
  1337.        * Constructs the underlying generator engine seeded with @p __s.
  1338.        * @param __s A seed value for the base class engine.
  1339.        */
  1340.       explicit
  1341.       shuffle_order_engine(result_type __s)
  1342.       : _M_b(__s)
  1343.       { _M_initialize(); }
  1344.  
  1345.       /**
  1346.        * @brief Generator construct a %shuffle_order_engine engine.
  1347.        *
  1348.        * @param __q A seed sequence.
  1349.        */
  1350.       template<typename _Sseq, typename = typename
  1351.         std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value
  1352.                        && !std::is_same<_Sseq, _RandomNumberEngine>::value>
  1353.                ::type>
  1354.         explicit
  1355.         shuffle_order_engine(_Sseq& __q)
  1356.         : _M_b(__q)
  1357.         { _M_initialize(); }
  1358.  
  1359.       /**
  1360.        * @brief Reseeds the %shuffle_order_engine object with the default seed
  1361.                 for the underlying base class generator engine.
  1362.        */
  1363.       void
  1364.       seed()
  1365.       {
  1366.         _M_b.seed();
  1367.         _M_initialize();
  1368.       }
  1369.  
  1370.       /**
  1371.        * @brief Reseeds the %shuffle_order_engine object with the default seed
  1372.        *        for the underlying base class generator engine.
  1373.        */
  1374.       void
  1375.       seed(result_type __s)
  1376.       {
  1377.         _M_b.seed(__s);
  1378.         _M_initialize();
  1379.       }
  1380.  
  1381.       /**
  1382.        * @brief Reseeds the %shuffle_order_engine object with the given seed
  1383.        *        sequence.
  1384.        * @param __q A seed generator function.
  1385.        */
  1386.       template<typename _Sseq>
  1387.         void
  1388.         seed(_Sseq& __q)
  1389.         {
  1390.           _M_b.seed(__q);
  1391.           _M_initialize();
  1392.         }
  1393.  
  1394.       /**
  1395.        * Gets a const reference to the underlying generator engine object.
  1396.        */
  1397.       const _RandomNumberEngine&
  1398.       base() const noexcept
  1399.       { return _M_b; }
  1400.  
  1401.       /**
  1402.        * Gets the minimum value in the generated random number range.
  1403.        */
  1404.       static constexpr result_type
  1405.       min()
  1406.       { return _RandomNumberEngine::min(); }
  1407.  
  1408.       /**
  1409.        * Gets the maximum value in the generated random number range.
  1410.        */
  1411.       static constexpr result_type
  1412.       max()
  1413.       { return _RandomNumberEngine::max(); }
  1414.  
  1415.       /**
  1416.        * Discard a sequence of random numbers.
  1417.        */
  1418.       void
  1419.       discard(unsigned long long __z)
  1420.       {
  1421.         for (; __z != 0ULL; --__z)
  1422.           (*this)();
  1423.       }
  1424.  
  1425.       /**
  1426.        * Gets the next value in the generated random number sequence.
  1427.        */
  1428.       result_type
  1429.       operator()();
  1430.  
  1431.       /**
  1432.        * Compares two %shuffle_order_engine random number generator objects
  1433.        * of the same type for equality.
  1434.        *
  1435.        * @param __lhs A %shuffle_order_engine random number generator object.
  1436.        * @param __rhs Another %shuffle_order_engine random number generator
  1437.        *              object.
  1438.        *
  1439.        * @returns true if the infinite sequences of generated values
  1440.        *          would be equal, false otherwise.
  1441.       */
  1442.       friend bool
  1443.       operator==(const shuffle_order_engine& __lhs,
  1444.                  const shuffle_order_engine& __rhs)
  1445.       { return (__lhs._M_b == __rhs._M_b
  1446.                 && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v)
  1447.                 && __lhs._M_y == __rhs._M_y); }
  1448.  
  1449.       /**
  1450.        * @brief Inserts the current state of a %shuffle_order_engine random
  1451.        *        number generator engine @p __x into the output stream
  1452.         @p __os.
  1453.        *
  1454.        * @param __os An output stream.
  1455.        * @param __x  A %shuffle_order_engine random number generator engine.
  1456.        *
  1457.        * @returns The output stream with the state of @p __x inserted or in
  1458.        * an error state.
  1459.        */
  1460.       template<typename _RandomNumberEngine1, size_t __k1,
  1461.                typename _CharT, typename _Traits>
  1462.         friend std::basic_ostream<_CharT, _Traits>&
  1463.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  1464.                    const std::shuffle_order_engine<_RandomNumberEngine1,
  1465.                    __k1>& __x);
  1466.  
  1467.       /**
  1468.        * @brief Extracts the current state of a % subtract_with_carry_engine
  1469.        *        random number generator engine @p __x from the input stream
  1470.        *        @p __is.
  1471.        *
  1472.        * @param __is An input stream.
  1473.        * @param __x  A %shuffle_order_engine random number generator engine.
  1474.        *
  1475.        * @returns The input stream with the state of @p __x extracted or in
  1476.        * an error state.
  1477.        */
  1478.       template<typename _RandomNumberEngine1, size_t __k1,
  1479.                typename _CharT, typename _Traits>
  1480.         friend std::basic_istream<_CharT, _Traits>&
  1481.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  1482.                    std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x);
  1483.  
  1484.     private:
  1485.       void _M_initialize()
  1486.       {
  1487.         for (size_t __i = 0; __i < __k; ++__i)
  1488.           _M_v[__i] = _M_b();
  1489.         _M_y = _M_b();
  1490.       }
  1491.  
  1492.       _RandomNumberEngine _M_b;
  1493.       result_type _M_v[__k];
  1494.       result_type _M_y;
  1495.     };
  1496.  
  1497.   /**
  1498.    * Compares two %shuffle_order_engine random number generator objects
  1499.    * of the same type for inequality.
  1500.    *
  1501.    * @param __lhs A %shuffle_order_engine random number generator object.
  1502.    * @param __rhs Another %shuffle_order_engine random number generator
  1503.    *              object.
  1504.    *
  1505.    * @returns true if the infinite sequences of generated values
  1506.    *          would be different, false otherwise.
  1507.    */
  1508.   template<typename _RandomNumberEngine, size_t __k>
  1509.     inline bool
  1510.     operator!=(const std::shuffle_order_engine<_RandomNumberEngine,
  1511.                __k>& __lhs,
  1512.                const std::shuffle_order_engine<_RandomNumberEngine,
  1513.                __k>& __rhs)
  1514.     { return !(__lhs == __rhs); }
  1515.  
  1516.  
  1517.   /**
  1518.    * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller.
  1519.    */
  1520.   typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL>
  1521.   minstd_rand0;
  1522.  
  1523.   /**
  1524.    * An alternative LCR (Lehmer Generator function).
  1525.    */
  1526.   typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL>
  1527.   minstd_rand;
  1528.  
  1529.   /**
  1530.    * The classic Mersenne Twister.
  1531.    *
  1532.    * Reference:
  1533.    * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally
  1534.    * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions
  1535.    * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30.
  1536.    */
  1537.   typedef mersenne_twister_engine<
  1538.     uint_fast32_t,
  1539.     32, 624, 397, 31,
  1540.     0x9908b0dfUL, 11,
  1541.     0xffffffffUL, 7,
  1542.     0x9d2c5680UL, 15,
  1543.     0xefc60000UL, 18, 1812433253UL> mt19937;
  1544.  
  1545.   /**
  1546.    * An alternative Mersenne Twister.
  1547.    */
  1548.   typedef mersenne_twister_engine<
  1549.     uint_fast64_t,
  1550.     64, 312, 156, 31,
  1551.     0xb5026f5aa96619e9ULL, 29,
  1552.     0x5555555555555555ULL, 17,
  1553.     0x71d67fffeda60000ULL, 37,
  1554.     0xfff7eee000000000ULL, 43,
  1555.     6364136223846793005ULL> mt19937_64;
  1556.  
  1557.   typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>
  1558.     ranlux24_base;
  1559.  
  1560.   typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12>
  1561.     ranlux48_base;
  1562.  
  1563.   typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
  1564.  
  1565.   typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
  1566.  
  1567.   typedef shuffle_order_engine<minstd_rand0, 256> knuth_b;
  1568.  
  1569.   typedef minstd_rand0 default_random_engine;
  1570.  
  1571.   /**
  1572.    * A standard interface to a platform-specific non-deterministic
  1573.    * random number generator (if any are available).
  1574.    */
  1575.   class random_device
  1576.   {
  1577.   public:
  1578.     /** The type of the generated random value. */
  1579.     typedef unsigned int result_type;
  1580.  
  1581.     // constructors, destructors and member functions
  1582.  
  1583. #ifdef _GLIBCXX_USE_RANDOM_TR1
  1584.  
  1585.     explicit
  1586.     random_device(const std::string& __token = "default")
  1587.     {
  1588.       _M_init(__token);
  1589.     }
  1590.  
  1591.     ~random_device()
  1592.     { _M_fini(); }
  1593.  
  1594. #else
  1595.  
  1596.     explicit
  1597.     random_device(const std::string& __token = "mt19937")
  1598.     { _M_init_pretr1(__token); }
  1599.  
  1600.   public:
  1601.  
  1602. #endif
  1603.  
  1604.     static constexpr result_type
  1605.     min()
  1606.     { return std::numeric_limits<result_type>::min(); }
  1607.  
  1608.     static constexpr result_type
  1609.     max()
  1610.     { return std::numeric_limits<result_type>::max(); }
  1611.  
  1612.     double
  1613.     entropy() const noexcept
  1614.     { return 0.0; }
  1615.  
  1616.     result_type
  1617.     operator()()
  1618.     {
  1619. #ifdef _GLIBCXX_USE_RANDOM_TR1
  1620.       return this->_M_getval();
  1621. #else
  1622.       return this->_M_getval_pretr1();
  1623. #endif
  1624.     }
  1625.  
  1626.     // No copy functions.
  1627.     random_device(const random_device&) = delete;
  1628.     void operator=(const random_device&) = delete;
  1629.  
  1630.   private:
  1631.  
  1632.     void _M_init(const std::string& __token);
  1633.     void _M_init_pretr1(const std::string& __token);
  1634.     void _M_fini();
  1635.  
  1636.     result_type _M_getval();
  1637.     result_type _M_getval_pretr1();
  1638.  
  1639.     union
  1640.     {
  1641.     FILE*        _M_file;
  1642.     mt19937      _M_mt;
  1643.   };
  1644.   };
  1645.  
  1646.   /* @} */ // group random_generators
  1647.  
  1648.   /**
  1649.    * @addtogroup random_distributions Random Number Distributions
  1650.    * @ingroup random
  1651.    * @{
  1652.    */
  1653.  
  1654.   /**
  1655.    * @addtogroup random_distributions_uniform Uniform Distributions
  1656.    * @ingroup random_distributions
  1657.    * @{
  1658.    */
  1659.  
  1660.   /**
  1661.    * @brief Uniform discrete distribution for random numbers.
  1662.    * A discrete random distribution on the range @f$[min, max]@f$ with equal
  1663.    * probability throughout the range.
  1664.    */
  1665.   template<typename _IntType = int>
  1666.     class uniform_int_distribution
  1667.     {
  1668.       static_assert(std::is_integral<_IntType>::value,
  1669.                     "template argument not an integral type");
  1670.  
  1671.     public:
  1672.       /** The type of the range of the distribution. */
  1673.       typedef _IntType result_type;
  1674.       /** Parameter type. */
  1675.       struct param_type
  1676.       {
  1677.         typedef uniform_int_distribution<_IntType> distribution_type;
  1678.  
  1679.         explicit
  1680.         param_type(_IntType __a = 0,
  1681.                    _IntType __b = std::numeric_limits<_IntType>::max())
  1682.         : _M_a(__a), _M_b(__b)
  1683.         {
  1684.           _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
  1685.         }
  1686.  
  1687.         result_type
  1688.         a() const
  1689.         { return _M_a; }
  1690.  
  1691.         result_type
  1692.         b() const
  1693.         { return _M_b; }
  1694.  
  1695.         friend bool
  1696.         operator==(const param_type& __p1, const param_type& __p2)
  1697.         { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
  1698.  
  1699.       private:
  1700.         _IntType _M_a;
  1701.         _IntType _M_b;
  1702.       };
  1703.  
  1704.     public:
  1705.       /**
  1706.        * @brief Constructs a uniform distribution object.
  1707.        */
  1708.       explicit
  1709.       uniform_int_distribution(_IntType __a = 0,
  1710.                            _IntType __b = std::numeric_limits<_IntType>::max())
  1711.       : _M_param(__a, __b)
  1712.       { }
  1713.  
  1714.       explicit
  1715.       uniform_int_distribution(const param_type& __p)
  1716.       : _M_param(__p)
  1717.       { }
  1718.  
  1719.       /**
  1720.        * @brief Resets the distribution state.
  1721.        *
  1722.        * Does nothing for the uniform integer distribution.
  1723.        */
  1724.       void
  1725.       reset() { }
  1726.  
  1727.       result_type
  1728.       a() const
  1729.       { return _M_param.a(); }
  1730.  
  1731.       result_type
  1732.       b() const
  1733.       { return _M_param.b(); }
  1734.  
  1735.       /**
  1736.        * @brief Returns the parameter set of the distribution.
  1737.        */
  1738.       param_type
  1739.       param() const
  1740.       { return _M_param; }
  1741.  
  1742.       /**
  1743.        * @brief Sets the parameter set of the distribution.
  1744.        * @param __param The new parameter set of the distribution.
  1745.        */
  1746.       void
  1747.       param(const param_type& __param)
  1748.       { _M_param = __param; }
  1749.  
  1750.       /**
  1751.        * @brief Returns the inclusive lower bound of the distribution range.
  1752.        */
  1753.       result_type
  1754.       min() const
  1755.       { return this->a(); }
  1756.  
  1757.       /**
  1758.        * @brief Returns the inclusive upper bound of the distribution range.
  1759.        */
  1760.       result_type
  1761.       max() const
  1762.       { return this->b(); }
  1763.  
  1764.       /**
  1765.        * @brief Generating functions.
  1766.        */
  1767.       template<typename _UniformRandomNumberGenerator>
  1768.         result_type
  1769.         operator()(_UniformRandomNumberGenerator& __urng)
  1770.         { return this->operator()(__urng, _M_param); }
  1771.  
  1772.       template<typename _UniformRandomNumberGenerator>
  1773.         result_type
  1774.         operator()(_UniformRandomNumberGenerator& __urng,
  1775.                    const param_type& __p);
  1776.  
  1777.       template<typename _ForwardIterator,
  1778.                typename _UniformRandomNumberGenerator>
  1779.         void
  1780.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  1781.                    _UniformRandomNumberGenerator& __urng)
  1782.         { this->__generate(__f, __t, __urng, _M_param); }
  1783.  
  1784.       template<typename _ForwardIterator,
  1785.                typename _UniformRandomNumberGenerator>
  1786.         void
  1787.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  1788.                    _UniformRandomNumberGenerator& __urng,
  1789.                    const param_type& __p)
  1790.         { this->__generate_impl(__f, __t, __urng, __p); }
  1791.  
  1792.       template<typename _UniformRandomNumberGenerator>
  1793.         void
  1794.         __generate(result_type* __f, result_type* __t,
  1795.                    _UniformRandomNumberGenerator& __urng,
  1796.                    const param_type& __p)
  1797.         { this->__generate_impl(__f, __t, __urng, __p); }
  1798.  
  1799.       /**
  1800.        * @brief Return true if two uniform integer distributions have
  1801.        *        the same parameters.
  1802.        */
  1803.       friend bool
  1804.       operator==(const uniform_int_distribution& __d1,
  1805.                  const uniform_int_distribution& __d2)
  1806.       { return __d1._M_param == __d2._M_param; }
  1807.  
  1808.     private:
  1809.       template<typename _ForwardIterator,
  1810.                typename _UniformRandomNumberGenerator>
  1811.         void
  1812.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  1813.                         _UniformRandomNumberGenerator& __urng,
  1814.                         const param_type& __p);
  1815.  
  1816.       param_type _M_param;
  1817.     };
  1818.  
  1819.   /**
  1820.    * @brief Return true if two uniform integer distributions have
  1821.    *        different parameters.
  1822.    */
  1823.   template<typename _IntType>
  1824.     inline bool
  1825.     operator!=(const std::uniform_int_distribution<_IntType>& __d1,
  1826.                const std::uniform_int_distribution<_IntType>& __d2)
  1827.     { return !(__d1 == __d2); }
  1828.  
  1829.   /**
  1830.    * @brief Inserts a %uniform_int_distribution random number
  1831.    *        distribution @p __x into the output stream @p os.
  1832.    *
  1833.    * @param __os An output stream.
  1834.    * @param __x  A %uniform_int_distribution random number distribution.
  1835.    *
  1836.    * @returns The output stream with the state of @p __x inserted or in
  1837.    * an error state.
  1838.    */
  1839.   template<typename _IntType, typename _CharT, typename _Traits>
  1840.     std::basic_ostream<_CharT, _Traits>&
  1841.     operator<<(std::basic_ostream<_CharT, _Traits>&,
  1842.                const std::uniform_int_distribution<_IntType>&);
  1843.  
  1844.   /**
  1845.    * @brief Extracts a %uniform_int_distribution random number distribution
  1846.    * @p __x from the input stream @p __is.
  1847.    *
  1848.    * @param __is An input stream.
  1849.    * @param __x  A %uniform_int_distribution random number generator engine.
  1850.    *
  1851.    * @returns The input stream with @p __x extracted or in an error state.
  1852.    */
  1853.   template<typename _IntType, typename _CharT, typename _Traits>
  1854.     std::basic_istream<_CharT, _Traits>&
  1855.     operator>>(std::basic_istream<_CharT, _Traits>&,
  1856.                std::uniform_int_distribution<_IntType>&);
  1857.  
  1858.  
  1859.   /**
  1860.    * @brief Uniform continuous distribution for random numbers.
  1861.    *
  1862.    * A continuous random distribution on the range [min, max) with equal
  1863.    * probability throughout the range.  The URNG should be real-valued and
  1864.    * deliver number in the range [0, 1).
  1865.    */
  1866.   template<typename _RealType = double>
  1867.     class uniform_real_distribution
  1868.     {
  1869.       static_assert(std::is_floating_point<_RealType>::value,
  1870.                     "template argument not a floating point type");
  1871.  
  1872.     public:
  1873.       /** The type of the range of the distribution. */
  1874.       typedef _RealType result_type;
  1875.       /** Parameter type. */
  1876.       struct param_type
  1877.       {
  1878.         typedef uniform_real_distribution<_RealType> distribution_type;
  1879.  
  1880.         explicit
  1881.         param_type(_RealType __a = _RealType(0),
  1882.                    _RealType __b = _RealType(1))
  1883.         : _M_a(__a), _M_b(__b)
  1884.         {
  1885.           _GLIBCXX_DEBUG_ASSERT(_M_a <= _M_b);
  1886.         }
  1887.  
  1888.         result_type
  1889.         a() const
  1890.         { return _M_a; }
  1891.  
  1892.         result_type
  1893.         b() const
  1894.         { return _M_b; }
  1895.  
  1896.         friend bool
  1897.         operator==(const param_type& __p1, const param_type& __p2)
  1898.         { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
  1899.  
  1900.       private:
  1901.         _RealType _M_a;
  1902.         _RealType _M_b;
  1903.       };
  1904.  
  1905.     public:
  1906.       /**
  1907.        * @brief Constructs a uniform_real_distribution object.
  1908.        *
  1909.        * @param __a [IN]  The lower bound of the distribution.
  1910.        * @param __b [IN]  The upper bound of the distribution.
  1911.        */
  1912.       explicit
  1913.       uniform_real_distribution(_RealType __a = _RealType(0),
  1914.                                 _RealType __b = _RealType(1))
  1915.       : _M_param(__a, __b)
  1916.       { }
  1917.  
  1918.       explicit
  1919.       uniform_real_distribution(const param_type& __p)
  1920.       : _M_param(__p)
  1921.       { }
  1922.  
  1923.       /**
  1924.        * @brief Resets the distribution state.
  1925.        *
  1926.        * Does nothing for the uniform real distribution.
  1927.        */
  1928.       void
  1929.       reset() { }
  1930.  
  1931.       result_type
  1932.       a() const
  1933.       { return _M_param.a(); }
  1934.  
  1935.       result_type
  1936.       b() const
  1937.       { return _M_param.b(); }
  1938.  
  1939.       /**
  1940.        * @brief Returns the parameter set of the distribution.
  1941.        */
  1942.       param_type
  1943.       param() const
  1944.       { return _M_param; }
  1945.  
  1946.       /**
  1947.        * @brief Sets the parameter set of the distribution.
  1948.        * @param __param The new parameter set of the distribution.
  1949.        */
  1950.       void
  1951.       param(const param_type& __param)
  1952.       { _M_param = __param; }
  1953.  
  1954.       /**
  1955.        * @brief Returns the inclusive lower bound of the distribution range.
  1956.        */
  1957.       result_type
  1958.       min() const
  1959.       { return this->a(); }
  1960.  
  1961.       /**
  1962.        * @brief Returns the inclusive upper bound of the distribution range.
  1963.        */
  1964.       result_type
  1965.       max() const
  1966.       { return this->b(); }
  1967.  
  1968.       /**
  1969.        * @brief Generating functions.
  1970.        */
  1971.       template<typename _UniformRandomNumberGenerator>
  1972.         result_type
  1973.         operator()(_UniformRandomNumberGenerator& __urng)
  1974.         { return this->operator()(__urng, _M_param); }
  1975.  
  1976.       template<typename _UniformRandomNumberGenerator>
  1977.         result_type
  1978.         operator()(_UniformRandomNumberGenerator& __urng,
  1979.                    const param_type& __p)
  1980.         {
  1981.           __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
  1982.             __aurng(__urng);
  1983.           return (__aurng() * (__p.b() - __p.a())) + __p.a();
  1984.         }
  1985.  
  1986.       template<typename _ForwardIterator,
  1987.                typename _UniformRandomNumberGenerator>
  1988.         void
  1989.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  1990.                    _UniformRandomNumberGenerator& __urng)
  1991.         { this->__generate(__f, __t, __urng, _M_param); }
  1992.  
  1993.       template<typename _ForwardIterator,
  1994.                typename _UniformRandomNumberGenerator>
  1995.         void
  1996.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  1997.                    _UniformRandomNumberGenerator& __urng,
  1998.                    const param_type& __p)
  1999.         { this->__generate_impl(__f, __t, __urng, __p); }
  2000.  
  2001.       template<typename _UniformRandomNumberGenerator>
  2002.         void
  2003.         __generate(result_type* __f, result_type* __t,
  2004.                    _UniformRandomNumberGenerator& __urng,
  2005.                    const param_type& __p)
  2006.         { this->__generate_impl(__f, __t, __urng, __p); }
  2007.  
  2008.       /**
  2009.        * @brief Return true if two uniform real distributions have
  2010.        *        the same parameters.
  2011.        */
  2012.       friend bool
  2013.       operator==(const uniform_real_distribution& __d1,
  2014.                  const uniform_real_distribution& __d2)
  2015.       { return __d1._M_param == __d2._M_param; }
  2016.  
  2017.     private:
  2018.       template<typename _ForwardIterator,
  2019.                typename _UniformRandomNumberGenerator>
  2020.         void
  2021.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  2022.                         _UniformRandomNumberGenerator& __urng,
  2023.                         const param_type& __p);
  2024.  
  2025.       param_type _M_param;
  2026.     };
  2027.  
  2028.   /**
  2029.    * @brief Return true if two uniform real distributions have
  2030.    *        different parameters.
  2031.    */
  2032.   template<typename _IntType>
  2033.     inline bool
  2034.     operator!=(const std::uniform_real_distribution<_IntType>& __d1,
  2035.                const std::uniform_real_distribution<_IntType>& __d2)
  2036.     { return !(__d1 == __d2); }
  2037.  
  2038.   /**
  2039.    * @brief Inserts a %uniform_real_distribution random number
  2040.    *        distribution @p __x into the output stream @p __os.
  2041.    *
  2042.    * @param __os An output stream.
  2043.    * @param __x  A %uniform_real_distribution random number distribution.
  2044.    *
  2045.    * @returns The output stream with the state of @p __x inserted or in
  2046.    *          an error state.
  2047.    */
  2048.   template<typename _RealType, typename _CharT, typename _Traits>
  2049.     std::basic_ostream<_CharT, _Traits>&
  2050.     operator<<(std::basic_ostream<_CharT, _Traits>&,
  2051.                const std::uniform_real_distribution<_RealType>&);
  2052.  
  2053.   /**
  2054.    * @brief Extracts a %uniform_real_distribution random number distribution
  2055.    * @p __x from the input stream @p __is.
  2056.    *
  2057.    * @param __is An input stream.
  2058.    * @param __x  A %uniform_real_distribution random number generator engine.
  2059.    *
  2060.    * @returns The input stream with @p __x extracted or in an error state.
  2061.    */
  2062.   template<typename _RealType, typename _CharT, typename _Traits>
  2063.     std::basic_istream<_CharT, _Traits>&
  2064.     operator>>(std::basic_istream<_CharT, _Traits>&,
  2065.                std::uniform_real_distribution<_RealType>&);
  2066.  
  2067.   /* @} */ // group random_distributions_uniform
  2068.  
  2069.   /**
  2070.    * @addtogroup random_distributions_normal Normal Distributions
  2071.    * @ingroup random_distributions
  2072.    * @{
  2073.    */
  2074.  
  2075.   /**
  2076.    * @brief A normal continuous distribution for random numbers.
  2077.    *
  2078.    * The formula for the normal probability density function is
  2079.    * @f[
  2080.    *     p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}}
  2081.    *            e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} }
  2082.    * @f]
  2083.    */
  2084.   template<typename _RealType = double>
  2085.     class normal_distribution
  2086.     {
  2087.       static_assert(std::is_floating_point<_RealType>::value,
  2088.                     "template argument not a floating point type");
  2089.  
  2090.     public:
  2091.       /** The type of the range of the distribution. */
  2092.       typedef _RealType result_type;
  2093.       /** Parameter type. */
  2094.       struct param_type
  2095.       {
  2096.         typedef normal_distribution<_RealType> distribution_type;
  2097.  
  2098.         explicit
  2099.         param_type(_RealType __mean = _RealType(0),
  2100.                    _RealType __stddev = _RealType(1))
  2101.         : _M_mean(__mean), _M_stddev(__stddev)
  2102.         {
  2103.           _GLIBCXX_DEBUG_ASSERT(_M_stddev > _RealType(0));
  2104.         }
  2105.  
  2106.         _RealType
  2107.         mean() const
  2108.         { return _M_mean; }
  2109.  
  2110.         _RealType
  2111.         stddev() const
  2112.         { return _M_stddev; }
  2113.  
  2114.         friend bool
  2115.         operator==(const param_type& __p1, const param_type& __p2)
  2116.         { return (__p1._M_mean == __p2._M_mean
  2117.                   && __p1._M_stddev == __p2._M_stddev); }
  2118.  
  2119.       private:
  2120.         _RealType _M_mean;
  2121.         _RealType _M_stddev;
  2122.       };
  2123.  
  2124.     public:
  2125.       /**
  2126.        * Constructs a normal distribution with parameters @f$mean@f$ and
  2127.        * standard deviation.
  2128.        */
  2129.       explicit
  2130.       normal_distribution(result_type __mean = result_type(0),
  2131.                           result_type __stddev = result_type(1))
  2132.       : _M_param(__mean, __stddev), _M_saved_available(false)
  2133.       { }
  2134.  
  2135.       explicit
  2136.       normal_distribution(const param_type& __p)
  2137.       : _M_param(__p), _M_saved_available(false)
  2138.       { }
  2139.  
  2140.       /**
  2141.        * @brief Resets the distribution state.
  2142.        */
  2143.       void
  2144.       reset()
  2145.       { _M_saved_available = false; }
  2146.  
  2147.       /**
  2148.        * @brief Returns the mean of the distribution.
  2149.        */
  2150.       _RealType
  2151.       mean() const
  2152.       { return _M_param.mean(); }
  2153.  
  2154.       /**
  2155.        * @brief Returns the standard deviation of the distribution.
  2156.        */
  2157.       _RealType
  2158.       stddev() const
  2159.       { return _M_param.stddev(); }
  2160.  
  2161.       /**
  2162.        * @brief Returns the parameter set of the distribution.
  2163.        */
  2164.       param_type
  2165.       param() const
  2166.       { return _M_param; }
  2167.  
  2168.       /**
  2169.        * @brief Sets the parameter set of the distribution.
  2170.        * @param __param The new parameter set of the distribution.
  2171.        */
  2172.       void
  2173.       param(const param_type& __param)
  2174.       { _M_param = __param; }
  2175.  
  2176.       /**
  2177.        * @brief Returns the greatest lower bound value of the distribution.
  2178.        */
  2179.       result_type
  2180.       min() const
  2181.       { return std::numeric_limits<result_type>::lowest(); }
  2182.  
  2183.       /**
  2184.        * @brief Returns the least upper bound value of the distribution.
  2185.        */
  2186.       result_type
  2187.       max() const
  2188.       { return std::numeric_limits<result_type>::max(); }
  2189.  
  2190.       /**
  2191.        * @brief Generating functions.
  2192.        */
  2193.       template<typename _UniformRandomNumberGenerator>
  2194.         result_type
  2195.         operator()(_UniformRandomNumberGenerator& __urng)
  2196.         { return this->operator()(__urng, _M_param); }
  2197.  
  2198.       template<typename _UniformRandomNumberGenerator>
  2199.         result_type
  2200.         operator()(_UniformRandomNumberGenerator& __urng,
  2201.                    const param_type& __p);
  2202.  
  2203.       template<typename _ForwardIterator,
  2204.                typename _UniformRandomNumberGenerator>
  2205.         void
  2206.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2207.                    _UniformRandomNumberGenerator& __urng)
  2208.         { this->__generate(__f, __t, __urng, _M_param); }
  2209.  
  2210.       template<typename _ForwardIterator,
  2211.                typename _UniformRandomNumberGenerator>
  2212.         void
  2213.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2214.                    _UniformRandomNumberGenerator& __urng,
  2215.                    const param_type& __p)
  2216.         { this->__generate_impl(__f, __t, __urng, __p); }
  2217.  
  2218.       template<typename _UniformRandomNumberGenerator>
  2219.         void
  2220.         __generate(result_type* __f, result_type* __t,
  2221.                    _UniformRandomNumberGenerator& __urng,
  2222.                    const param_type& __p)
  2223.         { this->__generate_impl(__f, __t, __urng, __p); }
  2224.  
  2225.       /**
  2226.        * @brief Return true if two normal distributions have
  2227.        *        the same parameters and the sequences that would
  2228.        *        be generated are equal.
  2229.        */
  2230.       template<typename _RealType1>
  2231.         friend bool
  2232.         operator==(const std::normal_distribution<_RealType1>& __d1,
  2233.                    const std::normal_distribution<_RealType1>& __d2);
  2234.  
  2235.       /**
  2236.        * @brief Inserts a %normal_distribution random number distribution
  2237.        * @p __x into the output stream @p __os.
  2238.        *
  2239.        * @param __os An output stream.
  2240.        * @param __x  A %normal_distribution random number distribution.
  2241.        *
  2242.        * @returns The output stream with the state of @p __x inserted or in
  2243.        * an error state.
  2244.        */
  2245.       template<typename _RealType1, typename _CharT, typename _Traits>
  2246.         friend std::basic_ostream<_CharT, _Traits>&
  2247.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  2248.                    const std::normal_distribution<_RealType1>& __x);
  2249.  
  2250.       /**
  2251.        * @brief Extracts a %normal_distribution random number distribution
  2252.        * @p __x from the input stream @p __is.
  2253.        *
  2254.        * @param __is An input stream.
  2255.        * @param __x  A %normal_distribution random number generator engine.
  2256.        *
  2257.        * @returns The input stream with @p __x extracted or in an error
  2258.        *          state.
  2259.        */
  2260.       template<typename _RealType1, typename _CharT, typename _Traits>
  2261.         friend std::basic_istream<_CharT, _Traits>&
  2262.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  2263.                    std::normal_distribution<_RealType1>& __x);
  2264.  
  2265.     private:
  2266.       template<typename _ForwardIterator,
  2267.                typename _UniformRandomNumberGenerator>
  2268.         void
  2269.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  2270.                         _UniformRandomNumberGenerator& __urng,
  2271.                         const param_type& __p);
  2272.  
  2273.       param_type  _M_param;
  2274.       result_type _M_saved;
  2275.       bool        _M_saved_available;
  2276.     };
  2277.  
  2278.   /**
  2279.    * @brief Return true if two normal distributions are different.
  2280.    */
  2281.   template<typename _RealType>
  2282.     inline bool
  2283.     operator!=(const std::normal_distribution<_RealType>& __d1,
  2284.                const std::normal_distribution<_RealType>& __d2)
  2285.     { return !(__d1 == __d2); }
  2286.  
  2287.  
  2288.   /**
  2289.    * @brief A lognormal_distribution random number distribution.
  2290.    *
  2291.    * The formula for the normal probability mass function is
  2292.    * @f[
  2293.    *     p(x|m,s) = \frac{1}{sx\sqrt{2\pi}}
  2294.    *                \exp{-\frac{(\ln{x} - m)^2}{2s^2}}
  2295.    * @f]
  2296.    */
  2297.   template<typename _RealType = double>
  2298.     class lognormal_distribution
  2299.     {
  2300.       static_assert(std::is_floating_point<_RealType>::value,
  2301.                     "template argument not a floating point type");
  2302.  
  2303.     public:
  2304.       /** The type of the range of the distribution. */
  2305.       typedef _RealType result_type;
  2306.       /** Parameter type. */
  2307.       struct param_type
  2308.       {
  2309.         typedef lognormal_distribution<_RealType> distribution_type;
  2310.  
  2311.         explicit
  2312.         param_type(_RealType __m = _RealType(0),
  2313.                    _RealType __s = _RealType(1))
  2314.         : _M_m(__m), _M_s(__s)
  2315.         { }
  2316.  
  2317.         _RealType
  2318.         m() const
  2319.         { return _M_m; }
  2320.  
  2321.         _RealType
  2322.         s() const
  2323.         { return _M_s; }
  2324.  
  2325.         friend bool
  2326.         operator==(const param_type& __p1, const param_type& __p2)
  2327.         { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; }
  2328.  
  2329.       private:
  2330.         _RealType _M_m;
  2331.         _RealType _M_s;
  2332.       };
  2333.  
  2334.       explicit
  2335.       lognormal_distribution(_RealType __m = _RealType(0),
  2336.                              _RealType __s = _RealType(1))
  2337.       : _M_param(__m, __s), _M_nd()
  2338.       { }
  2339.  
  2340.       explicit
  2341.       lognormal_distribution(const param_type& __p)
  2342.       : _M_param(__p), _M_nd()
  2343.       { }
  2344.  
  2345.       /**
  2346.        * Resets the distribution state.
  2347.        */
  2348.       void
  2349.       reset()
  2350.       { _M_nd.reset(); }
  2351.  
  2352.       /**
  2353.        *
  2354.        */
  2355.       _RealType
  2356.       m() const
  2357.       { return _M_param.m(); }
  2358.  
  2359.       _RealType
  2360.       s() const
  2361.       { return _M_param.s(); }
  2362.  
  2363.       /**
  2364.        * @brief Returns the parameter set of the distribution.
  2365.        */
  2366.       param_type
  2367.       param() const
  2368.       { return _M_param; }
  2369.  
  2370.       /**
  2371.        * @brief Sets the parameter set of the distribution.
  2372.        * @param __param The new parameter set of the distribution.
  2373.        */
  2374.       void
  2375.       param(const param_type& __param)
  2376.       { _M_param = __param; }
  2377.  
  2378.       /**
  2379.        * @brief Returns the greatest lower bound value of the distribution.
  2380.        */
  2381.       result_type
  2382.       min() const
  2383.       { return result_type(0); }
  2384.  
  2385.       /**
  2386.        * @brief Returns the least upper bound value of the distribution.
  2387.        */
  2388.       result_type
  2389.       max() const
  2390.       { return std::numeric_limits<result_type>::max(); }
  2391.  
  2392.       /**
  2393.        * @brief Generating functions.
  2394.        */
  2395.       template<typename _UniformRandomNumberGenerator>
  2396.         result_type
  2397.         operator()(_UniformRandomNumberGenerator& __urng)
  2398.         { return this->operator()(__urng, _M_param); }
  2399.  
  2400.       template<typename _UniformRandomNumberGenerator>
  2401.         result_type
  2402.         operator()(_UniformRandomNumberGenerator& __urng,
  2403.                    const param_type& __p)
  2404.         { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); }
  2405.  
  2406.       template<typename _ForwardIterator,
  2407.                typename _UniformRandomNumberGenerator>
  2408.         void
  2409.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2410.                    _UniformRandomNumberGenerator& __urng)
  2411.         { this->__generate(__f, __t, __urng, _M_param); }
  2412.  
  2413.       template<typename _ForwardIterator,
  2414.                typename _UniformRandomNumberGenerator>
  2415.         void
  2416.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2417.                    _UniformRandomNumberGenerator& __urng,
  2418.                    const param_type& __p)
  2419.         { this->__generate_impl(__f, __t, __urng, __p); }
  2420.  
  2421.       template<typename _UniformRandomNumberGenerator>
  2422.         void
  2423.         __generate(result_type* __f, result_type* __t,
  2424.                    _UniformRandomNumberGenerator& __urng,
  2425.                    const param_type& __p)
  2426.         { this->__generate_impl(__f, __t, __urng, __p); }
  2427.  
  2428.       /**
  2429.        * @brief Return true if two lognormal distributions have
  2430.        *        the same parameters and the sequences that would
  2431.        *        be generated are equal.
  2432.        */
  2433.       friend bool
  2434.       operator==(const lognormal_distribution& __d1,
  2435.                  const lognormal_distribution& __d2)
  2436.       { return (__d1._M_param == __d2._M_param
  2437.                 && __d1._M_nd == __d2._M_nd); }
  2438.  
  2439.       /**
  2440.        * @brief Inserts a %lognormal_distribution random number distribution
  2441.        * @p __x into the output stream @p __os.
  2442.        *
  2443.        * @param __os An output stream.
  2444.        * @param __x  A %lognormal_distribution random number distribution.
  2445.        *
  2446.        * @returns The output stream with the state of @p __x inserted or in
  2447.        * an error state.
  2448.        */
  2449.       template<typename _RealType1, typename _CharT, typename _Traits>
  2450.         friend std::basic_ostream<_CharT, _Traits>&
  2451.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  2452.                    const std::lognormal_distribution<_RealType1>& __x);
  2453.  
  2454.       /**
  2455.        * @brief Extracts a %lognormal_distribution random number distribution
  2456.        * @p __x from the input stream @p __is.
  2457.        *
  2458.        * @param __is An input stream.
  2459.        * @param __x A %lognormal_distribution random number
  2460.        *            generator engine.
  2461.        *
  2462.        * @returns The input stream with @p __x extracted or in an error state.
  2463.        */
  2464.       template<typename _RealType1, typename _CharT, typename _Traits>
  2465.         friend std::basic_istream<_CharT, _Traits>&
  2466.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  2467.                    std::lognormal_distribution<_RealType1>& __x);
  2468.  
  2469.     private:
  2470.       template<typename _ForwardIterator,
  2471.                typename _UniformRandomNumberGenerator>
  2472.         void
  2473.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  2474.                         _UniformRandomNumberGenerator& __urng,
  2475.                         const param_type& __p);
  2476.  
  2477.       param_type _M_param;
  2478.  
  2479.       std::normal_distribution<result_type> _M_nd;
  2480.     };
  2481.  
  2482.   /**
  2483.    * @brief Return true if two lognormal distributions are different.
  2484.    */
  2485.   template<typename _RealType>
  2486.     inline bool
  2487.     operator!=(const std::lognormal_distribution<_RealType>& __d1,
  2488.                const std::lognormal_distribution<_RealType>& __d2)
  2489.     { return !(__d1 == __d2); }
  2490.  
  2491.  
  2492.   /**
  2493.    * @brief A gamma continuous distribution for random numbers.
  2494.    *
  2495.    * The formula for the gamma probability density function is:
  2496.    * @f[
  2497.    *     p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)}
  2498.    *                         (x/\beta)^{\alpha - 1} e^{-x/\beta}
  2499.    * @f]
  2500.    */
  2501.   template<typename _RealType = double>
  2502.     class gamma_distribution
  2503.     {
  2504.       static_assert(std::is_floating_point<_RealType>::value,
  2505.                     "template argument not a floating point type");
  2506.  
  2507.     public:
  2508.       /** The type of the range of the distribution. */
  2509.       typedef _RealType result_type;
  2510.       /** Parameter type. */
  2511.       struct param_type
  2512.       {
  2513.         typedef gamma_distribution<_RealType> distribution_type;
  2514.         friend class gamma_distribution<_RealType>;
  2515.  
  2516.         explicit
  2517.         param_type(_RealType __alpha_val = _RealType(1),
  2518.                    _RealType __beta_val = _RealType(1))
  2519.         : _M_alpha(__alpha_val), _M_beta(__beta_val)
  2520.         {
  2521.           _GLIBCXX_DEBUG_ASSERT(_M_alpha > _RealType(0));
  2522.           _M_initialize();
  2523.         }
  2524.  
  2525.         _RealType
  2526.         alpha() const
  2527.         { return _M_alpha; }
  2528.  
  2529.         _RealType
  2530.         beta() const
  2531.         { return _M_beta; }
  2532.  
  2533.         friend bool
  2534.         operator==(const param_type& __p1, const param_type& __p2)
  2535.         { return (__p1._M_alpha == __p2._M_alpha
  2536.                   && __p1._M_beta == __p2._M_beta); }
  2537.  
  2538.       private:
  2539.         void
  2540.         _M_initialize();
  2541.  
  2542.         _RealType _M_alpha;
  2543.         _RealType _M_beta;
  2544.  
  2545.         _RealType _M_malpha, _M_a2;
  2546.       };
  2547.  
  2548.     public:
  2549.       /**
  2550.        * @brief Constructs a gamma distribution with parameters
  2551.        * @f$\alpha@f$ and @f$\beta@f$.
  2552.        */
  2553.       explicit
  2554.       gamma_distribution(_RealType __alpha_val = _RealType(1),
  2555.                          _RealType __beta_val = _RealType(1))
  2556.       : _M_param(__alpha_val, __beta_val), _M_nd()
  2557.       { }
  2558.  
  2559.       explicit
  2560.       gamma_distribution(const param_type& __p)
  2561.       : _M_param(__p), _M_nd()
  2562.       { }
  2563.  
  2564.       /**
  2565.        * @brief Resets the distribution state.
  2566.        */
  2567.       void
  2568.       reset()
  2569.       { _M_nd.reset(); }
  2570.  
  2571.       /**
  2572.        * @brief Returns the @f$\alpha@f$ of the distribution.
  2573.        */
  2574.       _RealType
  2575.       alpha() const
  2576.       { return _M_param.alpha(); }
  2577.  
  2578.       /**
  2579.        * @brief Returns the @f$\beta@f$ of the distribution.
  2580.        */
  2581.       _RealType
  2582.       beta() const
  2583.       { return _M_param.beta(); }
  2584.  
  2585.       /**
  2586.        * @brief Returns the parameter set of the distribution.
  2587.        */
  2588.       param_type
  2589.       param() const
  2590.       { return _M_param; }
  2591.  
  2592.       /**
  2593.        * @brief Sets the parameter set of the distribution.
  2594.        * @param __param The new parameter set of the distribution.
  2595.        */
  2596.       void
  2597.       param(const param_type& __param)
  2598.       { _M_param = __param; }
  2599.  
  2600.       /**
  2601.        * @brief Returns the greatest lower bound value of the distribution.
  2602.        */
  2603.       result_type
  2604.       min() const
  2605.       { return result_type(0); }
  2606.  
  2607.       /**
  2608.        * @brief Returns the least upper bound value of the distribution.
  2609.        */
  2610.       result_type
  2611.       max() const
  2612.       { return std::numeric_limits<result_type>::max(); }
  2613.  
  2614.       /**
  2615.        * @brief Generating functions.
  2616.        */
  2617.       template<typename _UniformRandomNumberGenerator>
  2618.         result_type
  2619.         operator()(_UniformRandomNumberGenerator& __urng)
  2620.         { return this->operator()(__urng, _M_param); }
  2621.  
  2622.       template<typename _UniformRandomNumberGenerator>
  2623.         result_type
  2624.         operator()(_UniformRandomNumberGenerator& __urng,
  2625.                    const param_type& __p);
  2626.  
  2627.       template<typename _ForwardIterator,
  2628.                typename _UniformRandomNumberGenerator>
  2629.         void
  2630.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2631.                    _UniformRandomNumberGenerator& __urng)
  2632.         { this->__generate(__f, __t, __urng, _M_param); }
  2633.  
  2634.       template<typename _ForwardIterator,
  2635.                typename _UniformRandomNumberGenerator>
  2636.         void
  2637.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2638.                    _UniformRandomNumberGenerator& __urng,
  2639.                    const param_type& __p)
  2640.         { this->__generate_impl(__f, __t, __urng, __p); }
  2641.  
  2642.       template<typename _UniformRandomNumberGenerator>
  2643.         void
  2644.         __generate(result_type* __f, result_type* __t,
  2645.                    _UniformRandomNumberGenerator& __urng,
  2646.                    const param_type& __p)
  2647.         { this->__generate_impl(__f, __t, __urng, __p); }
  2648.  
  2649.       /**
  2650.        * @brief Return true if two gamma distributions have the same
  2651.        *        parameters and the sequences that would be generated
  2652.        *        are equal.
  2653.        */
  2654.       friend bool
  2655.       operator==(const gamma_distribution& __d1,
  2656.                  const gamma_distribution& __d2)
  2657.       { return (__d1._M_param == __d2._M_param
  2658.                 && __d1._M_nd == __d2._M_nd); }
  2659.  
  2660.       /**
  2661.        * @brief Inserts a %gamma_distribution random number distribution
  2662.        * @p __x into the output stream @p __os.
  2663.        *
  2664.        * @param __os An output stream.
  2665.        * @param __x  A %gamma_distribution random number distribution.
  2666.        *
  2667.        * @returns The output stream with the state of @p __x inserted or in
  2668.        * an error state.
  2669.        */
  2670.       template<typename _RealType1, typename _CharT, typename _Traits>
  2671.         friend std::basic_ostream<_CharT, _Traits>&
  2672.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  2673.                    const std::gamma_distribution<_RealType1>& __x);
  2674.  
  2675.       /**
  2676.        * @brief Extracts a %gamma_distribution random number distribution
  2677.        * @p __x from the input stream @p __is.
  2678.        *
  2679.        * @param __is An input stream.
  2680.        * @param __x  A %gamma_distribution random number generator engine.
  2681.        *
  2682.        * @returns The input stream with @p __x extracted or in an error state.
  2683.        */
  2684.       template<typename _RealType1, typename _CharT, typename _Traits>
  2685.         friend std::basic_istream<_CharT, _Traits>&
  2686.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  2687.                    std::gamma_distribution<_RealType1>& __x);
  2688.  
  2689.     private:
  2690.       template<typename _ForwardIterator,
  2691.                typename _UniformRandomNumberGenerator>
  2692.         void
  2693.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  2694.                         _UniformRandomNumberGenerator& __urng,
  2695.                         const param_type& __p);
  2696.  
  2697.       param_type _M_param;
  2698.  
  2699.       std::normal_distribution<result_type> _M_nd;
  2700.     };
  2701.  
  2702.   /**
  2703.    * @brief Return true if two gamma distributions are different.
  2704.    */
  2705.    template<typename _RealType>
  2706.      inline bool
  2707.      operator!=(const std::gamma_distribution<_RealType>& __d1,
  2708.                 const std::gamma_distribution<_RealType>& __d2)
  2709.     { return !(__d1 == __d2); }
  2710.  
  2711.  
  2712.   /**
  2713.    * @brief A chi_squared_distribution random number distribution.
  2714.    *
  2715.    * The formula for the normal probability mass function is
  2716.    * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$
  2717.    */
  2718.   template<typename _RealType = double>
  2719.     class chi_squared_distribution
  2720.     {
  2721.       static_assert(std::is_floating_point<_RealType>::value,
  2722.                     "template argument not a floating point type");
  2723.  
  2724.     public:
  2725.       /** The type of the range of the distribution. */
  2726.       typedef _RealType result_type;
  2727.       /** Parameter type. */
  2728.       struct param_type
  2729.       {
  2730.         typedef chi_squared_distribution<_RealType> distribution_type;
  2731.  
  2732.         explicit
  2733.         param_type(_RealType __n = _RealType(1))
  2734.         : _M_n(__n)
  2735.         { }
  2736.  
  2737.         _RealType
  2738.         n() const
  2739.         { return _M_n; }
  2740.  
  2741.         friend bool
  2742.         operator==(const param_type& __p1, const param_type& __p2)
  2743.         { return __p1._M_n == __p2._M_n; }
  2744.  
  2745.       private:
  2746.         _RealType _M_n;
  2747.       };
  2748.  
  2749.       explicit
  2750.       chi_squared_distribution(_RealType __n = _RealType(1))
  2751.       : _M_param(__n), _M_gd(__n / 2)
  2752.       { }
  2753.  
  2754.       explicit
  2755.       chi_squared_distribution(const param_type& __p)
  2756.       : _M_param(__p), _M_gd(__p.n() / 2)
  2757.       { }
  2758.  
  2759.       /**
  2760.        * @brief Resets the distribution state.
  2761.        */
  2762.       void
  2763.       reset()
  2764.       { _M_gd.reset(); }
  2765.  
  2766.       /**
  2767.        *
  2768.        */
  2769.       _RealType
  2770.       n() const
  2771.       { return _M_param.n(); }
  2772.  
  2773.       /**
  2774.        * @brief Returns the parameter set of the distribution.
  2775.        */
  2776.       param_type
  2777.       param() const
  2778.       { return _M_param; }
  2779.  
  2780.       /**
  2781.        * @brief Sets the parameter set of the distribution.
  2782.        * @param __param The new parameter set of the distribution.
  2783.        */
  2784.       void
  2785.       param(const param_type& __param)
  2786.       { _M_param = __param; }
  2787.  
  2788.       /**
  2789.        * @brief Returns the greatest lower bound value of the distribution.
  2790.        */
  2791.       result_type
  2792.       min() const
  2793.       { return result_type(0); }
  2794.  
  2795.       /**
  2796.        * @brief Returns the least upper bound value of the distribution.
  2797.        */
  2798.       result_type
  2799.       max() const
  2800.       { return std::numeric_limits<result_type>::max(); }
  2801.  
  2802.       /**
  2803.        * @brief Generating functions.
  2804.        */
  2805.       template<typename _UniformRandomNumberGenerator>
  2806.         result_type
  2807.         operator()(_UniformRandomNumberGenerator& __urng)
  2808.         { return 2 * _M_gd(__urng); }
  2809.  
  2810.       template<typename _UniformRandomNumberGenerator>
  2811.         result_type
  2812.         operator()(_UniformRandomNumberGenerator& __urng,
  2813.                    const param_type& __p)
  2814.         {
  2815.           typedef typename std::gamma_distribution<result_type>::param_type
  2816.             param_type;
  2817.           return 2 * _M_gd(__urng, param_type(__p.n() / 2));
  2818.         }
  2819.  
  2820.       template<typename _ForwardIterator,
  2821.                typename _UniformRandomNumberGenerator>
  2822.         void
  2823.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2824.                    _UniformRandomNumberGenerator& __urng)
  2825.         { this->__generate_impl(__f, __t, __urng); }
  2826.  
  2827.       template<typename _ForwardIterator,
  2828.                typename _UniformRandomNumberGenerator>
  2829.         void
  2830.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  2831.                    _UniformRandomNumberGenerator& __urng,
  2832.                    const param_type& __p)
  2833.         { typename std::gamma_distribution<result_type>::param_type
  2834.             __p2(__p.n() / 2);
  2835.           this->__generate_impl(__f, __t, __urng, __p2); }
  2836.  
  2837.       template<typename _UniformRandomNumberGenerator>
  2838.         void
  2839.         __generate(result_type* __f, result_type* __t,
  2840.                    _UniformRandomNumberGenerator& __urng)
  2841.         { this->__generate_impl(__f, __t, __urng); }
  2842.  
  2843.       template<typename _UniformRandomNumberGenerator>
  2844.         void
  2845.         __generate(result_type* __f, result_type* __t,
  2846.                    _UniformRandomNumberGenerator& __urng,
  2847.                    const param_type& __p)
  2848.         { typename std::gamma_distribution<result_type>::param_type
  2849.             __p2(__p.n() / 2);
  2850.           this->__generate_impl(__f, __t, __urng, __p2); }
  2851.  
  2852.       /**
  2853.        * @brief Return true if two Chi-squared distributions have
  2854.        *        the same parameters and the sequences that would be
  2855.        *        generated are equal.
  2856.        */
  2857.       friend bool
  2858.       operator==(const chi_squared_distribution& __d1,
  2859.                  const chi_squared_distribution& __d2)
  2860.       { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
  2861.  
  2862.       /**
  2863.        * @brief Inserts a %chi_squared_distribution random number distribution
  2864.        * @p __x into the output stream @p __os.
  2865.        *
  2866.        * @param __os An output stream.
  2867.        * @param __x  A %chi_squared_distribution random number distribution.
  2868.        *
  2869.        * @returns The output stream with the state of @p __x inserted or in
  2870.        * an error state.
  2871.        */
  2872.       template<typename _RealType1, typename _CharT, typename _Traits>
  2873.         friend std::basic_ostream<_CharT, _Traits>&
  2874.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  2875.                    const std::chi_squared_distribution<_RealType1>& __x);
  2876.  
  2877.       /**
  2878.        * @brief Extracts a %chi_squared_distribution random number distribution
  2879.        * @p __x from the input stream @p __is.
  2880.        *
  2881.        * @param __is An input stream.
  2882.        * @param __x A %chi_squared_distribution random number
  2883.        *            generator engine.
  2884.        *
  2885.        * @returns The input stream with @p __x extracted or in an error state.
  2886.        */
  2887.       template<typename _RealType1, typename _CharT, typename _Traits>
  2888.         friend std::basic_istream<_CharT, _Traits>&
  2889.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  2890.                    std::chi_squared_distribution<_RealType1>& __x);
  2891.  
  2892.     private:
  2893.       template<typename _ForwardIterator,
  2894.                typename _UniformRandomNumberGenerator>
  2895.         void
  2896.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  2897.                         _UniformRandomNumberGenerator& __urng);
  2898.  
  2899.       template<typename _ForwardIterator,
  2900.                typename _UniformRandomNumberGenerator>
  2901.         void
  2902.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  2903.                         _UniformRandomNumberGenerator& __urng,
  2904.                         const typename
  2905.                         std::gamma_distribution<result_type>::param_type& __p);
  2906.  
  2907.       param_type _M_param;
  2908.  
  2909.       std::gamma_distribution<result_type> _M_gd;
  2910.     };
  2911.  
  2912.   /**
  2913.    * @brief Return true if two Chi-squared distributions are different.
  2914.    */
  2915.   template<typename _RealType>
  2916.     inline bool
  2917.     operator!=(const std::chi_squared_distribution<_RealType>& __d1,
  2918.                const std::chi_squared_distribution<_RealType>& __d2)
  2919.     { return !(__d1 == __d2); }
  2920.  
  2921.  
  2922.   /**
  2923.    * @brief A cauchy_distribution random number distribution.
  2924.    *
  2925.    * The formula for the normal probability mass function is
  2926.    * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$
  2927.    */
  2928.   template<typename _RealType = double>
  2929.     class cauchy_distribution
  2930.     {
  2931.       static_assert(std::is_floating_point<_RealType>::value,
  2932.                     "template argument not a floating point type");
  2933.  
  2934.     public:
  2935.       /** The type of the range of the distribution. */
  2936.       typedef _RealType result_type;
  2937.       /** Parameter type. */
  2938.       struct param_type
  2939.       {
  2940.         typedef cauchy_distribution<_RealType> distribution_type;
  2941.  
  2942.         explicit
  2943.         param_type(_RealType __a = _RealType(0),
  2944.                    _RealType __b = _RealType(1))
  2945.         : _M_a(__a), _M_b(__b)
  2946.         { }
  2947.  
  2948.         _RealType
  2949.         a() const
  2950.         { return _M_a; }
  2951.  
  2952.         _RealType
  2953.         b() const
  2954.         { return _M_b; }
  2955.  
  2956.         friend bool
  2957.         operator==(const param_type& __p1, const param_type& __p2)
  2958.         { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
  2959.  
  2960.       private:
  2961.         _RealType _M_a;
  2962.         _RealType _M_b;
  2963.       };
  2964.  
  2965.       explicit
  2966.       cauchy_distribution(_RealType __a = _RealType(0),
  2967.                           _RealType __b = _RealType(1))
  2968.       : _M_param(__a, __b)
  2969.       { }
  2970.  
  2971.       explicit
  2972.       cauchy_distribution(const param_type& __p)
  2973.       : _M_param(__p)
  2974.       { }
  2975.  
  2976.       /**
  2977.        * @brief Resets the distribution state.
  2978.        */
  2979.       void
  2980.       reset()
  2981.       { }
  2982.  
  2983.       /**
  2984.        *
  2985.        */
  2986.       _RealType
  2987.       a() const
  2988.       { return _M_param.a(); }
  2989.  
  2990.       _RealType
  2991.       b() const
  2992.       { return _M_param.b(); }
  2993.  
  2994.       /**
  2995.        * @brief Returns the parameter set of the distribution.
  2996.        */
  2997.       param_type
  2998.       param() const
  2999.       { return _M_param; }
  3000.  
  3001.       /**
  3002.        * @brief Sets the parameter set of the distribution.
  3003.        * @param __param The new parameter set of the distribution.
  3004.        */
  3005.       void
  3006.       param(const param_type& __param)
  3007.       { _M_param = __param; }
  3008.  
  3009.       /**
  3010.        * @brief Returns the greatest lower bound value of the distribution.
  3011.        */
  3012.       result_type
  3013.       min() const
  3014.       { return std::numeric_limits<result_type>::lowest(); }
  3015.  
  3016.       /**
  3017.        * @brief Returns the least upper bound value of the distribution.
  3018.        */
  3019.       result_type
  3020.       max() const
  3021.       { return std::numeric_limits<result_type>::max(); }
  3022.  
  3023.       /**
  3024.        * @brief Generating functions.
  3025.        */
  3026.       template<typename _UniformRandomNumberGenerator>
  3027.         result_type
  3028.         operator()(_UniformRandomNumberGenerator& __urng)
  3029.         { return this->operator()(__urng, _M_param); }
  3030.  
  3031.       template<typename _UniformRandomNumberGenerator>
  3032.         result_type
  3033.         operator()(_UniformRandomNumberGenerator& __urng,
  3034.                    const param_type& __p);
  3035.  
  3036.       template<typename _ForwardIterator,
  3037.                typename _UniformRandomNumberGenerator>
  3038.         void
  3039.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3040.                    _UniformRandomNumberGenerator& __urng)
  3041.         { this->__generate(__f, __t, __urng, _M_param); }
  3042.  
  3043.       template<typename _ForwardIterator,
  3044.                typename _UniformRandomNumberGenerator>
  3045.         void
  3046.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3047.                    _UniformRandomNumberGenerator& __urng,
  3048.                    const param_type& __p)
  3049.         { this->__generate_impl(__f, __t, __urng, __p); }
  3050.  
  3051.       template<typename _UniformRandomNumberGenerator>
  3052.         void
  3053.         __generate(result_type* __f, result_type* __t,
  3054.                    _UniformRandomNumberGenerator& __urng,
  3055.                    const param_type& __p)
  3056.         { this->__generate_impl(__f, __t, __urng, __p); }
  3057.  
  3058.       /**
  3059.        * @brief Return true if two Cauchy distributions have
  3060.        *        the same parameters.
  3061.        */
  3062.       friend bool
  3063.       operator==(const cauchy_distribution& __d1,
  3064.                  const cauchy_distribution& __d2)
  3065.       { return __d1._M_param == __d2._M_param; }
  3066.  
  3067.     private:
  3068.       template<typename _ForwardIterator,
  3069.                typename _UniformRandomNumberGenerator>
  3070.         void
  3071.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  3072.                         _UniformRandomNumberGenerator& __urng,
  3073.                         const param_type& __p);
  3074.  
  3075.       param_type _M_param;
  3076.     };
  3077.  
  3078.   /**
  3079.    * @brief Return true if two Cauchy distributions have
  3080.    *        different parameters.
  3081.    */
  3082.   template<typename _RealType>
  3083.     inline bool
  3084.     operator!=(const std::cauchy_distribution<_RealType>& __d1,
  3085.                const std::cauchy_distribution<_RealType>& __d2)
  3086.     { return !(__d1 == __d2); }
  3087.  
  3088.   /**
  3089.    * @brief Inserts a %cauchy_distribution random number distribution
  3090.    * @p __x into the output stream @p __os.
  3091.    *
  3092.    * @param __os An output stream.
  3093.    * @param __x  A %cauchy_distribution random number distribution.
  3094.    *
  3095.    * @returns The output stream with the state of @p __x inserted or in
  3096.    * an error state.
  3097.    */
  3098.   template<typename _RealType, typename _CharT, typename _Traits>
  3099.     std::basic_ostream<_CharT, _Traits>&
  3100.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  3101.                const std::cauchy_distribution<_RealType>& __x);
  3102.  
  3103.   /**
  3104.    * @brief Extracts a %cauchy_distribution random number distribution
  3105.    * @p __x from the input stream @p __is.
  3106.    *
  3107.    * @param __is An input stream.
  3108.    * @param __x A %cauchy_distribution random number
  3109.    *            generator engine.
  3110.    *
  3111.    * @returns The input stream with @p __x extracted or in an error state.
  3112.    */
  3113.   template<typename _RealType, typename _CharT, typename _Traits>
  3114.     std::basic_istream<_CharT, _Traits>&
  3115.     operator>>(std::basic_istream<_CharT, _Traits>& __is,
  3116.                std::cauchy_distribution<_RealType>& __x);
  3117.  
  3118.  
  3119.   /**
  3120.    * @brief A fisher_f_distribution random number distribution.
  3121.    *
  3122.    * The formula for the normal probability mass function is
  3123.    * @f[
  3124.    *     p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)}
  3125.    *                (\frac{m}{n})^{m/2} x^{(m/2)-1}
  3126.    *                (1 + \frac{mx}{n})^{-(m+n)/2}
  3127.    * @f]
  3128.    */
  3129.   template<typename _RealType = double>
  3130.     class fisher_f_distribution
  3131.     {
  3132.       static_assert(std::is_floating_point<_RealType>::value,
  3133.                     "template argument not a floating point type");
  3134.  
  3135.     public:
  3136.       /** The type of the range of the distribution. */
  3137.       typedef _RealType result_type;
  3138.       /** Parameter type. */
  3139.       struct param_type
  3140.       {
  3141.         typedef fisher_f_distribution<_RealType> distribution_type;
  3142.  
  3143.         explicit
  3144.         param_type(_RealType __m = _RealType(1),
  3145.                    _RealType __n = _RealType(1))
  3146.         : _M_m(__m), _M_n(__n)
  3147.         { }
  3148.  
  3149.         _RealType
  3150.         m() const
  3151.         { return _M_m; }
  3152.  
  3153.         _RealType
  3154.         n() const
  3155.         { return _M_n; }
  3156.  
  3157.         friend bool
  3158.         operator==(const param_type& __p1, const param_type& __p2)
  3159.         { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; }
  3160.  
  3161.       private:
  3162.         _RealType _M_m;
  3163.         _RealType _M_n;
  3164.       };
  3165.  
  3166.       explicit
  3167.       fisher_f_distribution(_RealType __m = _RealType(1),
  3168.                             _RealType __n = _RealType(1))
  3169.       : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2)
  3170.       { }
  3171.  
  3172.       explicit
  3173.       fisher_f_distribution(const param_type& __p)
  3174.       : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2)
  3175.       { }
  3176.  
  3177.       /**
  3178.        * @brief Resets the distribution state.
  3179.        */
  3180.       void
  3181.       reset()
  3182.       {
  3183.         _M_gd_x.reset();
  3184.         _M_gd_y.reset();
  3185.       }
  3186.  
  3187.       /**
  3188.        *
  3189.        */
  3190.       _RealType
  3191.       m() const
  3192.       { return _M_param.m(); }
  3193.  
  3194.       _RealType
  3195.       n() const
  3196.       { return _M_param.n(); }
  3197.  
  3198.       /**
  3199.        * @brief Returns the parameter set of the distribution.
  3200.        */
  3201.       param_type
  3202.       param() const
  3203.       { return _M_param; }
  3204.  
  3205.       /**
  3206.        * @brief Sets the parameter set of the distribution.
  3207.        * @param __param The new parameter set of the distribution.
  3208.        */
  3209.       void
  3210.       param(const param_type& __param)
  3211.       { _M_param = __param; }
  3212.  
  3213.       /**
  3214.        * @brief Returns the greatest lower bound value of the distribution.
  3215.        */
  3216.       result_type
  3217.       min() const
  3218.       { return result_type(0); }
  3219.  
  3220.       /**
  3221.        * @brief Returns the least upper bound value of the distribution.
  3222.        */
  3223.       result_type
  3224.       max() const
  3225.       { return std::numeric_limits<result_type>::max(); }
  3226.  
  3227.       /**
  3228.        * @brief Generating functions.
  3229.        */
  3230.       template<typename _UniformRandomNumberGenerator>
  3231.         result_type
  3232.         operator()(_UniformRandomNumberGenerator& __urng)
  3233.         { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); }
  3234.  
  3235.       template<typename _UniformRandomNumberGenerator>
  3236.         result_type
  3237.         operator()(_UniformRandomNumberGenerator& __urng,
  3238.                    const param_type& __p)
  3239.         {
  3240.           typedef typename std::gamma_distribution<result_type>::param_type
  3241.             param_type;
  3242.           return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n())
  3243.                   / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m()));
  3244.         }
  3245.  
  3246.       template<typename _ForwardIterator,
  3247.                typename _UniformRandomNumberGenerator>
  3248.         void
  3249.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3250.                    _UniformRandomNumberGenerator& __urng)
  3251.         { this->__generate_impl(__f, __t, __urng); }
  3252.  
  3253.       template<typename _ForwardIterator,
  3254.                typename _UniformRandomNumberGenerator>
  3255.         void
  3256.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3257.                    _UniformRandomNumberGenerator& __urng,
  3258.                    const param_type& __p)
  3259.         { this->__generate_impl(__f, __t, __urng, __p); }
  3260.  
  3261.       template<typename _UniformRandomNumberGenerator>
  3262.         void
  3263.         __generate(result_type* __f, result_type* __t,
  3264.                    _UniformRandomNumberGenerator& __urng)
  3265.         { this->__generate_impl(__f, __t, __urng); }
  3266.  
  3267.       template<typename _UniformRandomNumberGenerator>
  3268.         void
  3269.         __generate(result_type* __f, result_type* __t,
  3270.                    _UniformRandomNumberGenerator& __urng,
  3271.                    const param_type& __p)
  3272.         { this->__generate_impl(__f, __t, __urng, __p); }
  3273.  
  3274.       /**
  3275.        * @brief Return true if two Fisher f distributions have
  3276.        *        the same parameters and the sequences that would
  3277.        *        be generated are equal.
  3278.        */
  3279.       friend bool
  3280.       operator==(const fisher_f_distribution& __d1,
  3281.                  const fisher_f_distribution& __d2)
  3282.       { return (__d1._M_param == __d2._M_param
  3283.                 && __d1._M_gd_x == __d2._M_gd_x
  3284.                 && __d1._M_gd_y == __d2._M_gd_y); }
  3285.  
  3286.       /**
  3287.        * @brief Inserts a %fisher_f_distribution random number distribution
  3288.        * @p __x into the output stream @p __os.
  3289.        *
  3290.        * @param __os An output stream.
  3291.        * @param __x  A %fisher_f_distribution random number distribution.
  3292.        *
  3293.        * @returns The output stream with the state of @p __x inserted or in
  3294.        * an error state.
  3295.        */
  3296.       template<typename _RealType1, typename _CharT, typename _Traits>
  3297.         friend std::basic_ostream<_CharT, _Traits>&
  3298.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  3299.                    const std::fisher_f_distribution<_RealType1>& __x);
  3300.  
  3301.       /**
  3302.        * @brief Extracts a %fisher_f_distribution random number distribution
  3303.        * @p __x from the input stream @p __is.
  3304.        *
  3305.        * @param __is An input stream.
  3306.        * @param __x A %fisher_f_distribution random number
  3307.        *            generator engine.
  3308.        *
  3309.        * @returns The input stream with @p __x extracted or in an error state.
  3310.        */
  3311.       template<typename _RealType1, typename _CharT, typename _Traits>
  3312.         friend std::basic_istream<_CharT, _Traits>&
  3313.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  3314.                    std::fisher_f_distribution<_RealType1>& __x);
  3315.  
  3316.     private:
  3317.       template<typename _ForwardIterator,
  3318.                typename _UniformRandomNumberGenerator>
  3319.         void
  3320.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  3321.                         _UniformRandomNumberGenerator& __urng);
  3322.  
  3323.       template<typename _ForwardIterator,
  3324.                typename _UniformRandomNumberGenerator>
  3325.         void
  3326.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  3327.                         _UniformRandomNumberGenerator& __urng,
  3328.                         const param_type& __p);
  3329.  
  3330.       param_type _M_param;
  3331.  
  3332.       std::gamma_distribution<result_type> _M_gd_x, _M_gd_y;
  3333.     };
  3334.  
  3335.   /**
  3336.    * @brief Return true if two Fisher f distributions are diferent.
  3337.    */
  3338.   template<typename _RealType>
  3339.     inline bool
  3340.     operator!=(const std::fisher_f_distribution<_RealType>& __d1,
  3341.                const std::fisher_f_distribution<_RealType>& __d2)
  3342.     { return !(__d1 == __d2); }
  3343.  
  3344.   /**
  3345.    * @brief A student_t_distribution random number distribution.
  3346.    *
  3347.    * The formula for the normal probability mass function is:
  3348.    * @f[
  3349.    *     p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)}
  3350.    *              (1 + \frac{x^2}{n}) ^{-(n+1)/2}
  3351.    * @f]
  3352.    */
  3353.   template<typename _RealType = double>
  3354.     class student_t_distribution
  3355.     {
  3356.       static_assert(std::is_floating_point<_RealType>::value,
  3357.                     "template argument not a floating point type");
  3358.  
  3359.     public:
  3360.       /** The type of the range of the distribution. */
  3361.       typedef _RealType result_type;
  3362.       /** Parameter type. */
  3363.       struct param_type
  3364.       {
  3365.         typedef student_t_distribution<_RealType> distribution_type;
  3366.  
  3367.         explicit
  3368.         param_type(_RealType __n = _RealType(1))
  3369.         : _M_n(__n)
  3370.         { }
  3371.  
  3372.         _RealType
  3373.         n() const
  3374.         { return _M_n; }
  3375.  
  3376.         friend bool
  3377.         operator==(const param_type& __p1, const param_type& __p2)
  3378.         { return __p1._M_n == __p2._M_n; }
  3379.  
  3380.       private:
  3381.         _RealType _M_n;
  3382.       };
  3383.  
  3384.       explicit
  3385.       student_t_distribution(_RealType __n = _RealType(1))
  3386.       : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2)
  3387.       { }
  3388.  
  3389.       explicit
  3390.       student_t_distribution(const param_type& __p)
  3391.       : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2)
  3392.       { }
  3393.  
  3394.       /**
  3395.        * @brief Resets the distribution state.
  3396.        */
  3397.       void
  3398.       reset()
  3399.       {
  3400.         _M_nd.reset();
  3401.         _M_gd.reset();
  3402.       }
  3403.  
  3404.       /**
  3405.        *
  3406.        */
  3407.       _RealType
  3408.       n() const
  3409.       { return _M_param.n(); }
  3410.  
  3411.       /**
  3412.        * @brief Returns the parameter set of the distribution.
  3413.        */
  3414.       param_type
  3415.       param() const
  3416.       { return _M_param; }
  3417.  
  3418.       /**
  3419.        * @brief Sets the parameter set of the distribution.
  3420.        * @param __param The new parameter set of the distribution.
  3421.        */
  3422.       void
  3423.       param(const param_type& __param)
  3424.       { _M_param = __param; }
  3425.  
  3426.       /**
  3427.        * @brief Returns the greatest lower bound value of the distribution.
  3428.        */
  3429.       result_type
  3430.       min() const
  3431.       { return std::numeric_limits<result_type>::lowest(); }
  3432.  
  3433.       /**
  3434.        * @brief Returns the least upper bound value of the distribution.
  3435.        */
  3436.       result_type
  3437.       max() const
  3438.       { return std::numeric_limits<result_type>::max(); }
  3439.  
  3440.       /**
  3441.        * @brief Generating functions.
  3442.        */
  3443.       template<typename _UniformRandomNumberGenerator>
  3444.         result_type
  3445.         operator()(_UniformRandomNumberGenerator& __urng)
  3446.         { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); }
  3447.  
  3448.       template<typename _UniformRandomNumberGenerator>
  3449.         result_type
  3450.         operator()(_UniformRandomNumberGenerator& __urng,
  3451.                    const param_type& __p)
  3452.         {
  3453.           typedef typename std::gamma_distribution<result_type>::param_type
  3454.             param_type;
  3455.        
  3456.           const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2));
  3457.           return _M_nd(__urng) * std::sqrt(__p.n() / __g);
  3458.         }
  3459.  
  3460.       template<typename _ForwardIterator,
  3461.                typename _UniformRandomNumberGenerator>
  3462.         void
  3463.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3464.                    _UniformRandomNumberGenerator& __urng)
  3465.         { this->__generate_impl(__f, __t, __urng); }
  3466.  
  3467.       template<typename _ForwardIterator,
  3468.                typename _UniformRandomNumberGenerator>
  3469.         void
  3470.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3471.                    _UniformRandomNumberGenerator& __urng,
  3472.                    const param_type& __p)
  3473.         { this->__generate_impl(__f, __t, __urng, __p); }
  3474.  
  3475.       template<typename _UniformRandomNumberGenerator>
  3476.         void
  3477.         __generate(result_type* __f, result_type* __t,
  3478.                    _UniformRandomNumberGenerator& __urng)
  3479.         { this->__generate_impl(__f, __t, __urng); }
  3480.  
  3481.       template<typename _UniformRandomNumberGenerator>
  3482.         void
  3483.         __generate(result_type* __f, result_type* __t,
  3484.                    _UniformRandomNumberGenerator& __urng,
  3485.                    const param_type& __p)
  3486.         { this->__generate_impl(__f, __t, __urng, __p); }
  3487.  
  3488.       /**
  3489.        * @brief Return true if two Student t distributions have
  3490.        *        the same parameters and the sequences that would
  3491.        *        be generated are equal.
  3492.        */
  3493.       friend bool
  3494.       operator==(const student_t_distribution& __d1,
  3495.                  const student_t_distribution& __d2)
  3496.       { return (__d1._M_param == __d2._M_param
  3497.                 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); }
  3498.  
  3499.       /**
  3500.        * @brief Inserts a %student_t_distribution random number distribution
  3501.        * @p __x into the output stream @p __os.
  3502.        *
  3503.        * @param __os An output stream.
  3504.        * @param __x  A %student_t_distribution random number distribution.
  3505.        *
  3506.        * @returns The output stream with the state of @p __x inserted or in
  3507.        * an error state.
  3508.        */
  3509.       template<typename _RealType1, typename _CharT, typename _Traits>
  3510.         friend std::basic_ostream<_CharT, _Traits>&
  3511.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  3512.                    const std::student_t_distribution<_RealType1>& __x);
  3513.  
  3514.       /**
  3515.        * @brief Extracts a %student_t_distribution random number distribution
  3516.        * @p __x from the input stream @p __is.
  3517.        *
  3518.        * @param __is An input stream.
  3519.        * @param __x A %student_t_distribution random number
  3520.        *            generator engine.
  3521.        *
  3522.        * @returns The input stream with @p __x extracted or in an error state.
  3523.        */
  3524.       template<typename _RealType1, typename _CharT, typename _Traits>
  3525.         friend std::basic_istream<_CharT, _Traits>&
  3526.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  3527.                    std::student_t_distribution<_RealType1>& __x);
  3528.  
  3529.     private:
  3530.       template<typename _ForwardIterator,
  3531.                typename _UniformRandomNumberGenerator>
  3532.         void
  3533.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  3534.                         _UniformRandomNumberGenerator& __urng);
  3535.       template<typename _ForwardIterator,
  3536.                typename _UniformRandomNumberGenerator>
  3537.         void
  3538.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  3539.                         _UniformRandomNumberGenerator& __urng,
  3540.                         const param_type& __p);
  3541.  
  3542.       param_type _M_param;
  3543.  
  3544.       std::normal_distribution<result_type> _M_nd;
  3545.       std::gamma_distribution<result_type> _M_gd;
  3546.     };
  3547.  
  3548.   /**
  3549.    * @brief Return true if two Student t distributions are different.
  3550.    */
  3551.   template<typename _RealType>
  3552.     inline bool
  3553.     operator!=(const std::student_t_distribution<_RealType>& __d1,
  3554.                const std::student_t_distribution<_RealType>& __d2)
  3555.     { return !(__d1 == __d2); }
  3556.  
  3557.  
  3558.   /* @} */ // group random_distributions_normal
  3559.  
  3560.   /**
  3561.    * @addtogroup random_distributions_bernoulli Bernoulli Distributions
  3562.    * @ingroup random_distributions
  3563.    * @{
  3564.    */
  3565.  
  3566.   /**
  3567.    * @brief A Bernoulli random number distribution.
  3568.    *
  3569.    * Generates a sequence of true and false values with likelihood @f$p@f$
  3570.    * that true will come up and @f$(1 - p)@f$ that false will appear.
  3571.    */
  3572.   class bernoulli_distribution
  3573.   {
  3574.   public:
  3575.     /** The type of the range of the distribution. */
  3576.     typedef bool result_type;
  3577.     /** Parameter type. */
  3578.     struct param_type
  3579.     {
  3580.       typedef bernoulli_distribution distribution_type;
  3581.  
  3582.       explicit
  3583.       param_type(double __p = 0.5)
  3584.       : _M_p(__p)
  3585.       {
  3586.         _GLIBCXX_DEBUG_ASSERT((_M_p >= 0.0) && (_M_p <= 1.0));
  3587.       }
  3588.  
  3589.       double
  3590.       p() const
  3591.       { return _M_p; }
  3592.  
  3593.       friend bool
  3594.       operator==(const param_type& __p1, const param_type& __p2)
  3595.       { return __p1._M_p == __p2._M_p; }
  3596.  
  3597.     private:
  3598.       double _M_p;
  3599.     };
  3600.  
  3601.   public:
  3602.     /**
  3603.      * @brief Constructs a Bernoulli distribution with likelihood @p p.
  3604.      *
  3605.      * @param __p  [IN]  The likelihood of a true result being returned.
  3606.      *                   Must be in the interval @f$[0, 1]@f$.
  3607.      */
  3608.     explicit
  3609.     bernoulli_distribution(double __p = 0.5)
  3610.     : _M_param(__p)
  3611.     { }
  3612.  
  3613.     explicit
  3614.     bernoulli_distribution(const param_type& __p)
  3615.     : _M_param(__p)
  3616.     { }
  3617.  
  3618.     /**
  3619.      * @brief Resets the distribution state.
  3620.      *
  3621.      * Does nothing for a Bernoulli distribution.
  3622.      */
  3623.     void
  3624.     reset() { }
  3625.  
  3626.     /**
  3627.      * @brief Returns the @p p parameter of the distribution.
  3628.      */
  3629.     double
  3630.     p() const
  3631.     { return _M_param.p(); }
  3632.  
  3633.     /**
  3634.      * @brief Returns the parameter set of the distribution.
  3635.      */
  3636.     param_type
  3637.     param() const
  3638.     { return _M_param; }
  3639.  
  3640.     /**
  3641.      * @brief Sets the parameter set of the distribution.
  3642.      * @param __param The new parameter set of the distribution.
  3643.      */
  3644.     void
  3645.     param(const param_type& __param)
  3646.     { _M_param = __param; }
  3647.  
  3648.     /**
  3649.      * @brief Returns the greatest lower bound value of the distribution.
  3650.      */
  3651.     result_type
  3652.     min() const
  3653.     { return std::numeric_limits<result_type>::min(); }
  3654.  
  3655.     /**
  3656.      * @brief Returns the least upper bound value of the distribution.
  3657.      */
  3658.     result_type
  3659.     max() const
  3660.     { return std::numeric_limits<result_type>::max(); }
  3661.  
  3662.     /**
  3663.      * @brief Generating functions.
  3664.      */
  3665.     template<typename _UniformRandomNumberGenerator>
  3666.       result_type
  3667.       operator()(_UniformRandomNumberGenerator& __urng)
  3668.       { return this->operator()(__urng, _M_param); }
  3669.  
  3670.     template<typename _UniformRandomNumberGenerator>
  3671.       result_type
  3672.       operator()(_UniformRandomNumberGenerator& __urng,
  3673.                  const param_type& __p)
  3674.       {
  3675.         __detail::_Adaptor<_UniformRandomNumberGenerator, double>
  3676.           __aurng(__urng);
  3677.         if ((__aurng() - __aurng.min())
  3678.              < __p.p() * (__aurng.max() - __aurng.min()))
  3679.           return true;
  3680.         return false;
  3681.       }
  3682.  
  3683.     template<typename _ForwardIterator,
  3684.              typename _UniformRandomNumberGenerator>
  3685.       void
  3686.       __generate(_ForwardIterator __f, _ForwardIterator __t,
  3687.                  _UniformRandomNumberGenerator& __urng)
  3688.       { this->__generate(__f, __t, __urng, _M_param); }
  3689.  
  3690.     template<typename _ForwardIterator,
  3691.              typename _UniformRandomNumberGenerator>
  3692.       void
  3693.       __generate(_ForwardIterator __f, _ForwardIterator __t,
  3694.                  _UniformRandomNumberGenerator& __urng, const param_type& __p)
  3695.       { this->__generate_impl(__f, __t, __urng, __p); }
  3696.  
  3697.     template<typename _UniformRandomNumberGenerator>
  3698.       void
  3699.       __generate(result_type* __f, result_type* __t,
  3700.                  _UniformRandomNumberGenerator& __urng,
  3701.                  const param_type& __p)
  3702.       { this->__generate_impl(__f, __t, __urng, __p); }
  3703.  
  3704.     /**
  3705.      * @brief Return true if two Bernoulli distributions have
  3706.      *        the same parameters.
  3707.      */
  3708.     friend bool
  3709.     operator==(const bernoulli_distribution& __d1,
  3710.                const bernoulli_distribution& __d2)
  3711.     { return __d1._M_param == __d2._M_param; }
  3712.  
  3713.   private:
  3714.     template<typename _ForwardIterator,
  3715.              typename _UniformRandomNumberGenerator>
  3716.       void
  3717.       __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  3718.                       _UniformRandomNumberGenerator& __urng,
  3719.                       const param_type& __p);
  3720.  
  3721.     param_type _M_param;
  3722.   };
  3723.  
  3724.   /**
  3725.    * @brief Return true if two Bernoulli distributions have
  3726.    *        different parameters.
  3727.    */
  3728.   inline bool
  3729.   operator!=(const std::bernoulli_distribution& __d1,
  3730.              const std::bernoulli_distribution& __d2)
  3731.   { return !(__d1 == __d2); }
  3732.  
  3733.   /**
  3734.    * @brief Inserts a %bernoulli_distribution random number distribution
  3735.    * @p __x into the output stream @p __os.
  3736.    *
  3737.    * @param __os An output stream.
  3738.    * @param __x  A %bernoulli_distribution random number distribution.
  3739.    *
  3740.    * @returns The output stream with the state of @p __x inserted or in
  3741.    * an error state.
  3742.    */
  3743.   template<typename _CharT, typename _Traits>
  3744.     std::basic_ostream<_CharT, _Traits>&
  3745.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  3746.                const std::bernoulli_distribution& __x);
  3747.  
  3748.   /**
  3749.    * @brief Extracts a %bernoulli_distribution random number distribution
  3750.    * @p __x from the input stream @p __is.
  3751.    *
  3752.    * @param __is An input stream.
  3753.    * @param __x  A %bernoulli_distribution random number generator engine.
  3754.    *
  3755.    * @returns The input stream with @p __x extracted or in an error state.
  3756.    */
  3757.   template<typename _CharT, typename _Traits>
  3758.     std::basic_istream<_CharT, _Traits>&
  3759.     operator>>(std::basic_istream<_CharT, _Traits>& __is,
  3760.                std::bernoulli_distribution& __x)
  3761.     {
  3762.       double __p;
  3763.       __is >> __p;
  3764.       __x.param(bernoulli_distribution::param_type(__p));
  3765.       return __is;
  3766.     }
  3767.  
  3768.  
  3769.   /**
  3770.    * @brief A discrete binomial random number distribution.
  3771.    *
  3772.    * The formula for the binomial probability density function is
  3773.    * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
  3774.    * and @f$p@f$ are the parameters of the distribution.
  3775.    */
  3776.   template<typename _IntType = int>
  3777.     class binomial_distribution
  3778.     {
  3779.       static_assert(std::is_integral<_IntType>::value,
  3780.                     "template argument not an integral type");
  3781.  
  3782.     public:
  3783.       /** The type of the range of the distribution. */
  3784.       typedef _IntType result_type;
  3785.       /** Parameter type. */
  3786.       struct param_type
  3787.       {
  3788.         typedef binomial_distribution<_IntType> distribution_type;
  3789.         friend class binomial_distribution<_IntType>;
  3790.  
  3791.         explicit
  3792.         param_type(_IntType __t = _IntType(1), double __p = 0.5)
  3793.         : _M_t(__t), _M_p(__p)
  3794.         {
  3795.           _GLIBCXX_DEBUG_ASSERT((_M_t >= _IntType(0))
  3796.                                 && (_M_p >= 0.0)
  3797.                                 && (_M_p <= 1.0));
  3798.           _M_initialize();
  3799.         }
  3800.  
  3801.         _IntType
  3802.         t() const
  3803.         { return _M_t; }
  3804.  
  3805.         double
  3806.         p() const
  3807.         { return _M_p; }
  3808.  
  3809.         friend bool
  3810.         operator==(const param_type& __p1, const param_type& __p2)
  3811.         { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; }
  3812.  
  3813.       private:
  3814.         void
  3815.         _M_initialize();
  3816.  
  3817.         _IntType _M_t;
  3818.         double _M_p;
  3819.  
  3820.         double _M_q;
  3821. #if _GLIBCXX_USE_C99_MATH_TR1
  3822.         double _M_d1, _M_d2, _M_s1, _M_s2, _M_c,
  3823.                _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p;
  3824. #endif
  3825.         bool   _M_easy;
  3826.       };
  3827.  
  3828.       // constructors and member function
  3829.       explicit
  3830.       binomial_distribution(_IntType __t = _IntType(1),
  3831.                             double __p = 0.5)
  3832.       : _M_param(__t, __p), _M_nd()
  3833.       { }
  3834.  
  3835.       explicit
  3836.       binomial_distribution(const param_type& __p)
  3837.       : _M_param(__p), _M_nd()
  3838.       { }
  3839.  
  3840.       /**
  3841.        * @brief Resets the distribution state.
  3842.        */
  3843.       void
  3844.       reset()
  3845.       { _M_nd.reset(); }
  3846.  
  3847.       /**
  3848.        * @brief Returns the distribution @p t parameter.
  3849.        */
  3850.       _IntType
  3851.       t() const
  3852.       { return _M_param.t(); }
  3853.  
  3854.       /**
  3855.        * @brief Returns the distribution @p p parameter.
  3856.        */
  3857.       double
  3858.       p() const
  3859.       { return _M_param.p(); }
  3860.  
  3861.       /**
  3862.        * @brief Returns the parameter set of the distribution.
  3863.        */
  3864.       param_type
  3865.       param() const
  3866.       { return _M_param; }
  3867.  
  3868.       /**
  3869.        * @brief Sets the parameter set of the distribution.
  3870.        * @param __param The new parameter set of the distribution.
  3871.        */
  3872.       void
  3873.       param(const param_type& __param)
  3874.       { _M_param = __param; }
  3875.  
  3876.       /**
  3877.        * @brief Returns the greatest lower bound value of the distribution.
  3878.        */
  3879.       result_type
  3880.       min() const
  3881.       { return 0; }
  3882.  
  3883.       /**
  3884.        * @brief Returns the least upper bound value of the distribution.
  3885.        */
  3886.       result_type
  3887.       max() const
  3888.       { return _M_param.t(); }
  3889.  
  3890.       /**
  3891.        * @brief Generating functions.
  3892.        */
  3893.       template<typename _UniformRandomNumberGenerator>
  3894.         result_type
  3895.         operator()(_UniformRandomNumberGenerator& __urng)
  3896.         { return this->operator()(__urng, _M_param); }
  3897.  
  3898.       template<typename _UniformRandomNumberGenerator>
  3899.         result_type
  3900.         operator()(_UniformRandomNumberGenerator& __urng,
  3901.                    const param_type& __p);
  3902.  
  3903.       template<typename _ForwardIterator,
  3904.                typename _UniformRandomNumberGenerator>
  3905.         void
  3906.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3907.                    _UniformRandomNumberGenerator& __urng)
  3908.         { this->__generate(__f, __t, __urng, _M_param); }
  3909.  
  3910.       template<typename _ForwardIterator,
  3911.                typename _UniformRandomNumberGenerator>
  3912.         void
  3913.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  3914.                    _UniformRandomNumberGenerator& __urng,
  3915.                    const param_type& __p)
  3916.         { this->__generate_impl(__f, __t, __urng, __p); }
  3917.  
  3918.       template<typename _UniformRandomNumberGenerator>
  3919.         void
  3920.         __generate(result_type* __f, result_type* __t,
  3921.                    _UniformRandomNumberGenerator& __urng,
  3922.                    const param_type& __p)
  3923.         { this->__generate_impl(__f, __t, __urng, __p); }
  3924.  
  3925.       /**
  3926.        * @brief Return true if two binomial distributions have
  3927.        *        the same parameters and the sequences that would
  3928.        *        be generated are equal.
  3929.        */
  3930.         friend bool
  3931.         operator==(const binomial_distribution& __d1,
  3932.                    const binomial_distribution& __d2)
  3933. #ifdef _GLIBCXX_USE_C99_MATH_TR1
  3934.         { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
  3935. #else
  3936.         { return __d1._M_param == __d2._M_param; }
  3937. #endif
  3938.  
  3939.       /**
  3940.        * @brief Inserts a %binomial_distribution random number distribution
  3941.        * @p __x into the output stream @p __os.
  3942.        *
  3943.        * @param __os An output stream.
  3944.        * @param __x  A %binomial_distribution random number distribution.
  3945.        *
  3946.        * @returns The output stream with the state of @p __x inserted or in
  3947.        * an error state.
  3948.        */
  3949.       template<typename _IntType1,
  3950.                typename _CharT, typename _Traits>
  3951.         friend std::basic_ostream<_CharT, _Traits>&
  3952.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  3953.                    const std::binomial_distribution<_IntType1>& __x);
  3954.  
  3955.       /**
  3956.        * @brief Extracts a %binomial_distribution random number distribution
  3957.        * @p __x from the input stream @p __is.
  3958.        *
  3959.        * @param __is An input stream.
  3960.        * @param __x  A %binomial_distribution random number generator engine.
  3961.        *
  3962.        * @returns The input stream with @p __x extracted or in an error
  3963.        *          state.
  3964.        */
  3965.       template<typename _IntType1,
  3966.                typename _CharT, typename _Traits>
  3967.         friend std::basic_istream<_CharT, _Traits>&
  3968.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  3969.                    std::binomial_distribution<_IntType1>& __x);
  3970.  
  3971.     private:
  3972.       template<typename _ForwardIterator,
  3973.                typename _UniformRandomNumberGenerator>
  3974.         void
  3975.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  3976.                         _UniformRandomNumberGenerator& __urng,
  3977.                         const param_type& __p);
  3978.  
  3979.       template<typename _UniformRandomNumberGenerator>
  3980.         result_type
  3981.         _M_waiting(_UniformRandomNumberGenerator& __urng,
  3982.                    _IntType __t, double __q);
  3983.  
  3984.       param_type _M_param;
  3985.  
  3986.       // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
  3987.       std::normal_distribution<double> _M_nd;
  3988.     };
  3989.  
  3990.   /**
  3991.    * @brief Return true if two binomial distributions are different.
  3992.    */
  3993.   template<typename _IntType>
  3994.     inline bool
  3995.     operator!=(const std::binomial_distribution<_IntType>& __d1,
  3996.                const std::binomial_distribution<_IntType>& __d2)
  3997.     { return !(__d1 == __d2); }
  3998.  
  3999.  
  4000.   /**
  4001.    * @brief A discrete geometric random number distribution.
  4002.    *
  4003.    * The formula for the geometric probability density function is
  4004.    * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
  4005.    * distribution.
  4006.    */
  4007.   template<typename _IntType = int>
  4008.     class geometric_distribution
  4009.     {
  4010.       static_assert(std::is_integral<_IntType>::value,
  4011.                     "template argument not an integral type");
  4012.  
  4013.     public:
  4014.       /** The type of the range of the distribution. */
  4015.       typedef _IntType  result_type;
  4016.       /** Parameter type. */
  4017.       struct param_type
  4018.       {
  4019.         typedef geometric_distribution<_IntType> distribution_type;
  4020.         friend class geometric_distribution<_IntType>;
  4021.  
  4022.         explicit
  4023.         param_type(double __p = 0.5)
  4024.         : _M_p(__p)
  4025.         {
  4026.           _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
  4027.           _M_initialize();
  4028.         }
  4029.  
  4030.         double
  4031.         p() const
  4032.         { return _M_p; }
  4033.  
  4034.         friend bool
  4035.         operator==(const param_type& __p1, const param_type& __p2)
  4036.         { return __p1._M_p == __p2._M_p; }
  4037.  
  4038.       private:
  4039.         void
  4040.         _M_initialize()
  4041.         { _M_log_1_p = std::log(1.0 - _M_p); }
  4042.  
  4043.         double _M_p;
  4044.  
  4045.         double _M_log_1_p;
  4046.       };
  4047.  
  4048.       // constructors and member function
  4049.       explicit
  4050.       geometric_distribution(double __p = 0.5)
  4051.       : _M_param(__p)
  4052.       { }
  4053.  
  4054.       explicit
  4055.       geometric_distribution(const param_type& __p)
  4056.       : _M_param(__p)
  4057.       { }
  4058.  
  4059.       /**
  4060.        * @brief Resets the distribution state.
  4061.        *
  4062.        * Does nothing for the geometric distribution.
  4063.        */
  4064.       void
  4065.       reset() { }
  4066.  
  4067.       /**
  4068.        * @brief Returns the distribution parameter @p p.
  4069.        */
  4070.       double
  4071.       p() const
  4072.       { return _M_param.p(); }
  4073.  
  4074.       /**
  4075.        * @brief Returns the parameter set of the distribution.
  4076.        */
  4077.       param_type
  4078.       param() const
  4079.       { return _M_param; }
  4080.  
  4081.       /**
  4082.        * @brief Sets the parameter set of the distribution.
  4083.        * @param __param The new parameter set of the distribution.
  4084.        */
  4085.       void
  4086.       param(const param_type& __param)
  4087.       { _M_param = __param; }
  4088.  
  4089.       /**
  4090.        * @brief Returns the greatest lower bound value of the distribution.
  4091.        */
  4092.       result_type
  4093.       min() const
  4094.       { return 0; }
  4095.  
  4096.       /**
  4097.        * @brief Returns the least upper bound value of the distribution.
  4098.        */
  4099.       result_type
  4100.       max() const
  4101.       { return std::numeric_limits<result_type>::max(); }
  4102.  
  4103.       /**
  4104.        * @brief Generating functions.
  4105.        */
  4106.       template<typename _UniformRandomNumberGenerator>
  4107.         result_type
  4108.         operator()(_UniformRandomNumberGenerator& __urng)
  4109.         { return this->operator()(__urng, _M_param); }
  4110.  
  4111.       template<typename _UniformRandomNumberGenerator>
  4112.         result_type
  4113.         operator()(_UniformRandomNumberGenerator& __urng,
  4114.                    const param_type& __p);
  4115.  
  4116.       template<typename _ForwardIterator,
  4117.                typename _UniformRandomNumberGenerator>
  4118.         void
  4119.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4120.                    _UniformRandomNumberGenerator& __urng)
  4121.         { this->__generate(__f, __t, __urng, _M_param); }
  4122.  
  4123.       template<typename _ForwardIterator,
  4124.                typename _UniformRandomNumberGenerator>
  4125.         void
  4126.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4127.                    _UniformRandomNumberGenerator& __urng,
  4128.                    const param_type& __p)
  4129.         { this->__generate_impl(__f, __t, __urng, __p); }
  4130.  
  4131.       template<typename _UniformRandomNumberGenerator>
  4132.         void
  4133.         __generate(result_type* __f, result_type* __t,
  4134.                    _UniformRandomNumberGenerator& __urng,
  4135.                    const param_type& __p)
  4136.         { this->__generate_impl(__f, __t, __urng, __p); }
  4137.  
  4138.       /**
  4139.        * @brief Return true if two geometric distributions have
  4140.        *        the same parameters.
  4141.        */
  4142.       friend bool
  4143.       operator==(const geometric_distribution& __d1,
  4144.                  const geometric_distribution& __d2)
  4145.       { return __d1._M_param == __d2._M_param; }
  4146.  
  4147.     private:
  4148.       template<typename _ForwardIterator,
  4149.                typename _UniformRandomNumberGenerator>
  4150.         void
  4151.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  4152.                         _UniformRandomNumberGenerator& __urng,
  4153.                         const param_type& __p);
  4154.  
  4155.       param_type _M_param;
  4156.     };
  4157.  
  4158.   /**
  4159.    * @brief Return true if two geometric distributions have
  4160.    *        different parameters.
  4161.    */
  4162.   template<typename _IntType>
  4163.     inline bool
  4164.     operator!=(const std::geometric_distribution<_IntType>& __d1,
  4165.                const std::geometric_distribution<_IntType>& __d2)
  4166.     { return !(__d1 == __d2); }
  4167.  
  4168.   /**
  4169.    * @brief Inserts a %geometric_distribution random number distribution
  4170.    * @p __x into the output stream @p __os.
  4171.    *
  4172.    * @param __os An output stream.
  4173.    * @param __x  A %geometric_distribution random number distribution.
  4174.    *
  4175.    * @returns The output stream with the state of @p __x inserted or in
  4176.    * an error state.
  4177.    */
  4178.   template<typename _IntType,
  4179.            typename _CharT, typename _Traits>
  4180.     std::basic_ostream<_CharT, _Traits>&
  4181.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  4182.                const std::geometric_distribution<_IntType>& __x);
  4183.  
  4184.   /**
  4185.    * @brief Extracts a %geometric_distribution random number distribution
  4186.    * @p __x from the input stream @p __is.
  4187.    *
  4188.    * @param __is An input stream.
  4189.    * @param __x  A %geometric_distribution random number generator engine.
  4190.    *
  4191.    * @returns The input stream with @p __x extracted or in an error state.
  4192.    */
  4193.   template<typename _IntType,
  4194.            typename _CharT, typename _Traits>
  4195.     std::basic_istream<_CharT, _Traits>&
  4196.     operator>>(std::basic_istream<_CharT, _Traits>& __is,
  4197.                std::geometric_distribution<_IntType>& __x);
  4198.  
  4199.  
  4200.   /**
  4201.    * @brief A negative_binomial_distribution random number distribution.
  4202.    *
  4203.    * The formula for the negative binomial probability mass function is
  4204.    * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
  4205.    * and @f$p@f$ are the parameters of the distribution.
  4206.    */
  4207.   template<typename _IntType = int>
  4208.     class negative_binomial_distribution
  4209.     {
  4210.       static_assert(std::is_integral<_IntType>::value,
  4211.                     "template argument not an integral type");
  4212.  
  4213.     public:
  4214.       /** The type of the range of the distribution. */
  4215.       typedef _IntType result_type;
  4216.       /** Parameter type. */
  4217.       struct param_type
  4218.       {
  4219.         typedef negative_binomial_distribution<_IntType> distribution_type;
  4220.  
  4221.         explicit
  4222.         param_type(_IntType __k = 1, double __p = 0.5)
  4223.         : _M_k(__k), _M_p(__p)
  4224.         {
  4225.           _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
  4226.         }
  4227.  
  4228.         _IntType
  4229.         k() const
  4230.         { return _M_k; }
  4231.  
  4232.         double
  4233.         p() const
  4234.         { return _M_p; }
  4235.  
  4236.         friend bool
  4237.         operator==(const param_type& __p1, const param_type& __p2)
  4238.         { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
  4239.  
  4240.       private:
  4241.         _IntType _M_k;
  4242.         double _M_p;
  4243.       };
  4244.  
  4245.       explicit
  4246.       negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
  4247.       : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
  4248.       { }
  4249.  
  4250.       explicit
  4251.       negative_binomial_distribution(const param_type& __p)
  4252.       : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
  4253.       { }
  4254.  
  4255.       /**
  4256.        * @brief Resets the distribution state.
  4257.        */
  4258.       void
  4259.       reset()
  4260.       { _M_gd.reset(); }
  4261.  
  4262.       /**
  4263.        * @brief Return the @f$k@f$ parameter of the distribution.
  4264.        */
  4265.       _IntType
  4266.       k() const
  4267.       { return _M_param.k(); }
  4268.  
  4269.       /**
  4270.        * @brief Return the @f$p@f$ parameter of the distribution.
  4271.        */
  4272.       double
  4273.       p() const
  4274.       { return _M_param.p(); }
  4275.  
  4276.       /**
  4277.        * @brief Returns the parameter set of the distribution.
  4278.        */
  4279.       param_type
  4280.       param() const
  4281.       { return _M_param; }
  4282.  
  4283.       /**
  4284.        * @brief Sets the parameter set of the distribution.
  4285.        * @param __param The new parameter set of the distribution.
  4286.        */
  4287.       void
  4288.       param(const param_type& __param)
  4289.       { _M_param = __param; }
  4290.  
  4291.       /**
  4292.        * @brief Returns the greatest lower bound value of the distribution.
  4293.        */
  4294.       result_type
  4295.       min() const
  4296.       { return result_type(0); }
  4297.  
  4298.       /**
  4299.        * @brief Returns the least upper bound value of the distribution.
  4300.        */
  4301.       result_type
  4302.       max() const
  4303.       { return std::numeric_limits<result_type>::max(); }
  4304.  
  4305.       /**
  4306.        * @brief Generating functions.
  4307.        */
  4308.       template<typename _UniformRandomNumberGenerator>
  4309.         result_type
  4310.         operator()(_UniformRandomNumberGenerator& __urng);
  4311.  
  4312.       template<typename _UniformRandomNumberGenerator>
  4313.         result_type
  4314.         operator()(_UniformRandomNumberGenerator& __urng,
  4315.                    const param_type& __p);
  4316.  
  4317.       template<typename _ForwardIterator,
  4318.                typename _UniformRandomNumberGenerator>
  4319.         void
  4320.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4321.                    _UniformRandomNumberGenerator& __urng)
  4322.         { this->__generate_impl(__f, __t, __urng); }
  4323.  
  4324.       template<typename _ForwardIterator,
  4325.                typename _UniformRandomNumberGenerator>
  4326.         void
  4327.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4328.                    _UniformRandomNumberGenerator& __urng,
  4329.                    const param_type& __p)
  4330.         { this->__generate_impl(__f, __t, __urng, __p); }
  4331.  
  4332.       template<typename _UniformRandomNumberGenerator>
  4333.         void
  4334.         __generate(result_type* __f, result_type* __t,
  4335.                    _UniformRandomNumberGenerator& __urng)
  4336.         { this->__generate_impl(__f, __t, __urng); }
  4337.  
  4338.       template<typename _UniformRandomNumberGenerator>
  4339.         void
  4340.         __generate(result_type* __f, result_type* __t,
  4341.                    _UniformRandomNumberGenerator& __urng,
  4342.                    const param_type& __p)
  4343.         { this->__generate_impl(__f, __t, __urng, __p); }
  4344.  
  4345.       /**
  4346.        * @brief Return true if two negative binomial distributions have
  4347.        *        the same parameters and the sequences that would be
  4348.        *        generated are equal.
  4349.        */
  4350.       friend bool
  4351.       operator==(const negative_binomial_distribution& __d1,
  4352.                  const negative_binomial_distribution& __d2)
  4353.       { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
  4354.  
  4355.       /**
  4356.        * @brief Inserts a %negative_binomial_distribution random
  4357.        *        number distribution @p __x into the output stream @p __os.
  4358.        *
  4359.        * @param __os An output stream.
  4360.        * @param __x  A %negative_binomial_distribution random number
  4361.        *             distribution.
  4362.        *
  4363.        * @returns The output stream with the state of @p __x inserted or in
  4364.        *          an error state.
  4365.        */
  4366.       template<typename _IntType1, typename _CharT, typename _Traits>
  4367.         friend std::basic_ostream<_CharT, _Traits>&
  4368.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  4369.                    const std::negative_binomial_distribution<_IntType1>& __x);
  4370.  
  4371.       /**
  4372.        * @brief Extracts a %negative_binomial_distribution random number
  4373.        *        distribution @p __x from the input stream @p __is.
  4374.        *
  4375.        * @param __is An input stream.
  4376.        * @param __x A %negative_binomial_distribution random number
  4377.        *            generator engine.
  4378.        *
  4379.        * @returns The input stream with @p __x extracted or in an error state.
  4380.        */
  4381.       template<typename _IntType1, typename _CharT, typename _Traits>
  4382.         friend std::basic_istream<_CharT, _Traits>&
  4383.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  4384.                    std::negative_binomial_distribution<_IntType1>& __x);
  4385.  
  4386.     private:
  4387.       template<typename _ForwardIterator,
  4388.                typename _UniformRandomNumberGenerator>
  4389.         void
  4390.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  4391.                         _UniformRandomNumberGenerator& __urng);
  4392.       template<typename _ForwardIterator,
  4393.                typename _UniformRandomNumberGenerator>
  4394.         void
  4395.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  4396.                         _UniformRandomNumberGenerator& __urng,
  4397.                         const param_type& __p);
  4398.  
  4399.       param_type _M_param;
  4400.  
  4401.       std::gamma_distribution<double> _M_gd;
  4402.     };
  4403.  
  4404.   /**
  4405.    * @brief Return true if two negative binomial distributions are different.
  4406.    */
  4407.   template<typename _IntType>
  4408.     inline bool
  4409.     operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
  4410.                const std::negative_binomial_distribution<_IntType>& __d2)
  4411.     { return !(__d1 == __d2); }
  4412.  
  4413.  
  4414.   /* @} */ // group random_distributions_bernoulli
  4415.  
  4416.   /**
  4417.    * @addtogroup random_distributions_poisson Poisson Distributions
  4418.    * @ingroup random_distributions
  4419.    * @{
  4420.    */
  4421.  
  4422.   /**
  4423.    * @brief A discrete Poisson random number distribution.
  4424.    *
  4425.    * The formula for the Poisson probability density function is
  4426.    * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
  4427.    * parameter of the distribution.
  4428.    */
  4429.   template<typename _IntType = int>
  4430.     class poisson_distribution
  4431.     {
  4432.       static_assert(std::is_integral<_IntType>::value,
  4433.                     "template argument not an integral type");
  4434.  
  4435.     public:
  4436.       /** The type of the range of the distribution. */
  4437.       typedef _IntType  result_type;
  4438.       /** Parameter type. */
  4439.       struct param_type
  4440.       {
  4441.         typedef poisson_distribution<_IntType> distribution_type;
  4442.         friend class poisson_distribution<_IntType>;
  4443.  
  4444.         explicit
  4445.         param_type(double __mean = 1.0)
  4446.         : _M_mean(__mean)
  4447.         {
  4448.           _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
  4449.           _M_initialize();
  4450.         }
  4451.  
  4452.         double
  4453.         mean() const
  4454.         { return _M_mean; }
  4455.  
  4456.         friend bool
  4457.         operator==(const param_type& __p1, const param_type& __p2)
  4458.         { return __p1._M_mean == __p2._M_mean; }
  4459.  
  4460.       private:
  4461.         // Hosts either log(mean) or the threshold of the simple method.
  4462.         void
  4463.         _M_initialize();
  4464.  
  4465.         double _M_mean;
  4466.  
  4467.         double _M_lm_thr;
  4468. #if _GLIBCXX_USE_C99_MATH_TR1
  4469.         double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
  4470. #endif
  4471.       };
  4472.  
  4473.       // constructors and member function
  4474.       explicit
  4475.       poisson_distribution(double __mean = 1.0)
  4476.       : _M_param(__mean), _M_nd()
  4477.       { }
  4478.  
  4479.       explicit
  4480.       poisson_distribution(const param_type& __p)
  4481.       : _M_param(__p), _M_nd()
  4482.       { }
  4483.  
  4484.       /**
  4485.        * @brief Resets the distribution state.
  4486.        */
  4487.       void
  4488.       reset()
  4489.       { _M_nd.reset(); }
  4490.  
  4491.       /**
  4492.        * @brief Returns the distribution parameter @p mean.
  4493.        */
  4494.       double
  4495.       mean() const
  4496.       { return _M_param.mean(); }
  4497.  
  4498.       /**
  4499.        * @brief Returns the parameter set of the distribution.
  4500.        */
  4501.       param_type
  4502.       param() const
  4503.       { return _M_param; }
  4504.  
  4505.       /**
  4506.        * @brief Sets the parameter set of the distribution.
  4507.        * @param __param The new parameter set of the distribution.
  4508.        */
  4509.       void
  4510.       param(const param_type& __param)
  4511.       { _M_param = __param; }
  4512.  
  4513.       /**
  4514.        * @brief Returns the greatest lower bound value of the distribution.
  4515.        */
  4516.       result_type
  4517.       min() const
  4518.       { return 0; }
  4519.  
  4520.       /**
  4521.        * @brief Returns the least upper bound value of the distribution.
  4522.        */
  4523.       result_type
  4524.       max() const
  4525.       { return std::numeric_limits<result_type>::max(); }
  4526.  
  4527.       /**
  4528.        * @brief Generating functions.
  4529.        */
  4530.       template<typename _UniformRandomNumberGenerator>
  4531.         result_type
  4532.         operator()(_UniformRandomNumberGenerator& __urng)
  4533.         { return this->operator()(__urng, _M_param); }
  4534.  
  4535.       template<typename _UniformRandomNumberGenerator>
  4536.         result_type
  4537.         operator()(_UniformRandomNumberGenerator& __urng,
  4538.                    const param_type& __p);
  4539.  
  4540.       template<typename _ForwardIterator,
  4541.                typename _UniformRandomNumberGenerator>
  4542.         void
  4543.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4544.                    _UniformRandomNumberGenerator& __urng)
  4545.         { this->__generate(__f, __t, __urng, _M_param); }
  4546.  
  4547.       template<typename _ForwardIterator,
  4548.                typename _UniformRandomNumberGenerator>
  4549.         void
  4550.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4551.                    _UniformRandomNumberGenerator& __urng,
  4552.                    const param_type& __p)
  4553.         { this->__generate_impl(__f, __t, __urng, __p); }
  4554.  
  4555.       template<typename _UniformRandomNumberGenerator>
  4556.         void
  4557.         __generate(result_type* __f, result_type* __t,
  4558.                    _UniformRandomNumberGenerator& __urng,
  4559.                    const param_type& __p)
  4560.         { this->__generate_impl(__f, __t, __urng, __p); }
  4561.  
  4562.        /**
  4563.         * @brief Return true if two Poisson distributions have the same
  4564.         *        parameters and the sequences that would be generated
  4565.         *        are equal.
  4566.         */
  4567.       friend bool
  4568.       operator==(const poisson_distribution& __d1,
  4569.                  const poisson_distribution& __d2)
  4570. #ifdef _GLIBCXX_USE_C99_MATH_TR1
  4571.       { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
  4572. #else
  4573.       { return __d1._M_param == __d2._M_param; }
  4574. #endif
  4575.  
  4576.       /**
  4577.        * @brief Inserts a %poisson_distribution random number distribution
  4578.        * @p __x into the output stream @p __os.
  4579.        *
  4580.        * @param __os An output stream.
  4581.        * @param __x  A %poisson_distribution random number distribution.
  4582.        *
  4583.        * @returns The output stream with the state of @p __x inserted or in
  4584.        * an error state.
  4585.        */
  4586.       template<typename _IntType1, typename _CharT, typename _Traits>
  4587.         friend std::basic_ostream<_CharT, _Traits>&
  4588.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  4589.                    const std::poisson_distribution<_IntType1>& __x);
  4590.  
  4591.       /**
  4592.        * @brief Extracts a %poisson_distribution random number distribution
  4593.        * @p __x from the input stream @p __is.
  4594.        *
  4595.        * @param __is An input stream.
  4596.        * @param __x  A %poisson_distribution random number generator engine.
  4597.        *
  4598.        * @returns The input stream with @p __x extracted or in an error
  4599.        *          state.
  4600.        */
  4601.       template<typename _IntType1, typename _CharT, typename _Traits>
  4602.         friend std::basic_istream<_CharT, _Traits>&
  4603.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  4604.                    std::poisson_distribution<_IntType1>& __x);
  4605.  
  4606.     private:
  4607.       template<typename _ForwardIterator,
  4608.                typename _UniformRandomNumberGenerator>
  4609.         void
  4610.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  4611.                         _UniformRandomNumberGenerator& __urng,
  4612.                         const param_type& __p);
  4613.  
  4614.       param_type _M_param;
  4615.  
  4616.       // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
  4617.       std::normal_distribution<double> _M_nd;
  4618.     };
  4619.  
  4620.   /**
  4621.    * @brief Return true if two Poisson distributions are different.
  4622.    */
  4623.   template<typename _IntType>
  4624.     inline bool
  4625.     operator!=(const std::poisson_distribution<_IntType>& __d1,
  4626.                const std::poisson_distribution<_IntType>& __d2)
  4627.     { return !(__d1 == __d2); }
  4628.  
  4629.  
  4630.   /**
  4631.    * @brief An exponential continuous distribution for random numbers.
  4632.    *
  4633.    * The formula for the exponential probability density function is
  4634.    * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
  4635.    *
  4636.    * <table border=1 cellpadding=10 cellspacing=0>
  4637.    * <caption align=top>Distribution Statistics</caption>
  4638.    * <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
  4639.    * <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr>
  4640.    * <tr><td>Mode</td><td>@f$zero@f$</td></tr>
  4641.    * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
  4642.    * <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
  4643.    * </table>
  4644.    */
  4645.   template<typename _RealType = double>
  4646.     class exponential_distribution
  4647.     {
  4648.       static_assert(std::is_floating_point<_RealType>::value,
  4649.                     "template argument not a floating point type");
  4650.  
  4651.     public:
  4652.       /** The type of the range of the distribution. */
  4653.       typedef _RealType result_type;
  4654.       /** Parameter type. */
  4655.       struct param_type
  4656.       {
  4657.         typedef exponential_distribution<_RealType> distribution_type;
  4658.  
  4659.         explicit
  4660.         param_type(_RealType __lambda = _RealType(1))
  4661.         : _M_lambda(__lambda)
  4662.         {
  4663.           _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0));
  4664.         }
  4665.  
  4666.         _RealType
  4667.         lambda() const
  4668.         { return _M_lambda; }
  4669.  
  4670.         friend bool
  4671.         operator==(const param_type& __p1, const param_type& __p2)
  4672.         { return __p1._M_lambda == __p2._M_lambda; }
  4673.  
  4674.       private:
  4675.         _RealType _M_lambda;
  4676.       };
  4677.  
  4678.     public:
  4679.       /**
  4680.        * @brief Constructs an exponential distribution with inverse scale
  4681.        *        parameter @f$\lambda@f$.
  4682.        */
  4683.       explicit
  4684.       exponential_distribution(const result_type& __lambda = result_type(1))
  4685.       : _M_param(__lambda)
  4686.       { }
  4687.  
  4688.       explicit
  4689.       exponential_distribution(const param_type& __p)
  4690.       : _M_param(__p)
  4691.       { }
  4692.  
  4693.       /**
  4694.        * @brief Resets the distribution state.
  4695.        *
  4696.        * Has no effect on exponential distributions.
  4697.        */
  4698.       void
  4699.       reset() { }
  4700.  
  4701.       /**
  4702.        * @brief Returns the inverse scale parameter of the distribution.
  4703.        */
  4704.       _RealType
  4705.       lambda() const
  4706.       { return _M_param.lambda(); }
  4707.  
  4708.       /**
  4709.        * @brief Returns the parameter set of the distribution.
  4710.        */
  4711.       param_type
  4712.       param() const
  4713.       { return _M_param; }
  4714.  
  4715.       /**
  4716.        * @brief Sets the parameter set of the distribution.
  4717.        * @param __param The new parameter set of the distribution.
  4718.        */
  4719.       void
  4720.       param(const param_type& __param)
  4721.       { _M_param = __param; }
  4722.  
  4723.       /**
  4724.        * @brief Returns the greatest lower bound value of the distribution.
  4725.        */
  4726.       result_type
  4727.       min() const
  4728.       { return result_type(0); }
  4729.  
  4730.       /**
  4731.        * @brief Returns the least upper bound value of the distribution.
  4732.        */
  4733.       result_type
  4734.       max() const
  4735.       { return std::numeric_limits<result_type>::max(); }
  4736.  
  4737.       /**
  4738.        * @brief Generating functions.
  4739.        */
  4740.       template<typename _UniformRandomNumberGenerator>
  4741.         result_type
  4742.         operator()(_UniformRandomNumberGenerator& __urng)
  4743.         { return this->operator()(__urng, _M_param); }
  4744.  
  4745.       template<typename _UniformRandomNumberGenerator>
  4746.         result_type
  4747.         operator()(_UniformRandomNumberGenerator& __urng,
  4748.                    const param_type& __p)
  4749.         {
  4750.           __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
  4751.             __aurng(__urng);
  4752.           return -std::log(result_type(1) - __aurng()) / __p.lambda();
  4753.         }
  4754.  
  4755.       template<typename _ForwardIterator,
  4756.                typename _UniformRandomNumberGenerator>
  4757.         void
  4758.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4759.                    _UniformRandomNumberGenerator& __urng)
  4760.         { this->__generate(__f, __t, __urng, _M_param); }
  4761.  
  4762.       template<typename _ForwardIterator,
  4763.                typename _UniformRandomNumberGenerator>
  4764.         void
  4765.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4766.                    _UniformRandomNumberGenerator& __urng,
  4767.                    const param_type& __p)
  4768.         { this->__generate_impl(__f, __t, __urng, __p); }
  4769.  
  4770.       template<typename _UniformRandomNumberGenerator>
  4771.         void
  4772.         __generate(result_type* __f, result_type* __t,
  4773.                    _UniformRandomNumberGenerator& __urng,
  4774.                    const param_type& __p)
  4775.         { this->__generate_impl(__f, __t, __urng, __p); }
  4776.  
  4777.       /**
  4778.        * @brief Return true if two exponential distributions have the same
  4779.        *        parameters.
  4780.        */
  4781.       friend bool
  4782.       operator==(const exponential_distribution& __d1,
  4783.                  const exponential_distribution& __d2)
  4784.       { return __d1._M_param == __d2._M_param; }
  4785.  
  4786.     private:
  4787.       template<typename _ForwardIterator,
  4788.                typename _UniformRandomNumberGenerator>
  4789.         void
  4790.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  4791.                         _UniformRandomNumberGenerator& __urng,
  4792.                         const param_type& __p);
  4793.  
  4794.       param_type _M_param;
  4795.     };
  4796.  
  4797.   /**
  4798.    * @brief Return true if two exponential distributions have different
  4799.    *        parameters.
  4800.    */
  4801.   template<typename _RealType>
  4802.     inline bool
  4803.     operator!=(const std::exponential_distribution<_RealType>& __d1,
  4804.                const std::exponential_distribution<_RealType>& __d2)
  4805.     { return !(__d1 == __d2); }
  4806.  
  4807.   /**
  4808.    * @brief Inserts a %exponential_distribution random number distribution
  4809.    * @p __x into the output stream @p __os.
  4810.    *
  4811.    * @param __os An output stream.
  4812.    * @param __x  A %exponential_distribution random number distribution.
  4813.    *
  4814.    * @returns The output stream with the state of @p __x inserted or in
  4815.    * an error state.
  4816.    */
  4817.   template<typename _RealType, typename _CharT, typename _Traits>
  4818.     std::basic_ostream<_CharT, _Traits>&
  4819.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  4820.                const std::exponential_distribution<_RealType>& __x);
  4821.  
  4822.   /**
  4823.    * @brief Extracts a %exponential_distribution random number distribution
  4824.    * @p __x from the input stream @p __is.
  4825.    *
  4826.    * @param __is An input stream.
  4827.    * @param __x A %exponential_distribution random number
  4828.    *            generator engine.
  4829.    *
  4830.    * @returns The input stream with @p __x extracted or in an error state.
  4831.    */
  4832.   template<typename _RealType, typename _CharT, typename _Traits>
  4833.     std::basic_istream<_CharT, _Traits>&
  4834.     operator>>(std::basic_istream<_CharT, _Traits>& __is,
  4835.                std::exponential_distribution<_RealType>& __x);
  4836.  
  4837.  
  4838.   /**
  4839.    * @brief A weibull_distribution random number distribution.
  4840.    *
  4841.    * The formula for the normal probability density function is:
  4842.    * @f[
  4843.    *     p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
  4844.    *                         \exp{(-(\frac{x}{\beta})^\alpha)}
  4845.    * @f]
  4846.    */
  4847.   template<typename _RealType = double>
  4848.     class weibull_distribution
  4849.     {
  4850.       static_assert(std::is_floating_point<_RealType>::value,
  4851.                     "template argument not a floating point type");
  4852.  
  4853.     public:
  4854.       /** The type of the range of the distribution. */
  4855.       typedef _RealType result_type;
  4856.       /** Parameter type. */
  4857.       struct param_type
  4858.       {
  4859.         typedef weibull_distribution<_RealType> distribution_type;
  4860.  
  4861.         explicit
  4862.         param_type(_RealType __a = _RealType(1),
  4863.                    _RealType __b = _RealType(1))
  4864.         : _M_a(__a), _M_b(__b)
  4865.         { }
  4866.  
  4867.         _RealType
  4868.         a() const
  4869.         { return _M_a; }
  4870.  
  4871.         _RealType
  4872.         b() const
  4873.         { return _M_b; }
  4874.  
  4875.         friend bool
  4876.         operator==(const param_type& __p1, const param_type& __p2)
  4877.         { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
  4878.  
  4879.       private:
  4880.         _RealType _M_a;
  4881.         _RealType _M_b;
  4882.       };
  4883.  
  4884.       explicit
  4885.       weibull_distribution(_RealType __a = _RealType(1),
  4886.                            _RealType __b = _RealType(1))
  4887.       : _M_param(__a, __b)
  4888.       { }
  4889.  
  4890.       explicit
  4891.       weibull_distribution(const param_type& __p)
  4892.       : _M_param(__p)
  4893.       { }
  4894.  
  4895.       /**
  4896.        * @brief Resets the distribution state.
  4897.        */
  4898.       void
  4899.       reset()
  4900.       { }
  4901.  
  4902.       /**
  4903.        * @brief Return the @f$a@f$ parameter of the distribution.
  4904.        */
  4905.       _RealType
  4906.       a() const
  4907.       { return _M_param.a(); }
  4908.  
  4909.       /**
  4910.        * @brief Return the @f$b@f$ parameter of the distribution.
  4911.        */
  4912.       _RealType
  4913.       b() const
  4914.       { return _M_param.b(); }
  4915.  
  4916.       /**
  4917.        * @brief Returns the parameter set of the distribution.
  4918.        */
  4919.       param_type
  4920.       param() const
  4921.       { return _M_param; }
  4922.  
  4923.       /**
  4924.        * @brief Sets the parameter set of the distribution.
  4925.        * @param __param The new parameter set of the distribution.
  4926.        */
  4927.       void
  4928.       param(const param_type& __param)
  4929.       { _M_param = __param; }
  4930.  
  4931.       /**
  4932.        * @brief Returns the greatest lower bound value of the distribution.
  4933.        */
  4934.       result_type
  4935.       min() const
  4936.       { return result_type(0); }
  4937.  
  4938.       /**
  4939.        * @brief Returns the least upper bound value of the distribution.
  4940.        */
  4941.       result_type
  4942.       max() const
  4943.       { return std::numeric_limits<result_type>::max(); }
  4944.  
  4945.       /**
  4946.        * @brief Generating functions.
  4947.        */
  4948.       template<typename _UniformRandomNumberGenerator>
  4949.         result_type
  4950.         operator()(_UniformRandomNumberGenerator& __urng)
  4951.         { return this->operator()(__urng, _M_param); }
  4952.  
  4953.       template<typename _UniformRandomNumberGenerator>
  4954.         result_type
  4955.         operator()(_UniformRandomNumberGenerator& __urng,
  4956.                    const param_type& __p);
  4957.  
  4958.       template<typename _ForwardIterator,
  4959.                typename _UniformRandomNumberGenerator>
  4960.         void
  4961.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4962.                    _UniformRandomNumberGenerator& __urng)
  4963.         { this->__generate(__f, __t, __urng, _M_param); }
  4964.  
  4965.       template<typename _ForwardIterator,
  4966.                typename _UniformRandomNumberGenerator>
  4967.         void
  4968.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  4969.                    _UniformRandomNumberGenerator& __urng,
  4970.                    const param_type& __p)
  4971.         { this->__generate_impl(__f, __t, __urng, __p); }
  4972.  
  4973.       template<typename _UniformRandomNumberGenerator>
  4974.         void
  4975.         __generate(result_type* __f, result_type* __t,
  4976.                    _UniformRandomNumberGenerator& __urng,
  4977.                    const param_type& __p)
  4978.         { this->__generate_impl(__f, __t, __urng, __p); }
  4979.  
  4980.       /**
  4981.        * @brief Return true if two Weibull distributions have the same
  4982.        *        parameters.
  4983.        */
  4984.       friend bool
  4985.       operator==(const weibull_distribution& __d1,
  4986.                  const weibull_distribution& __d2)
  4987.       { return __d1._M_param == __d2._M_param; }
  4988.  
  4989.     private:
  4990.       template<typename _ForwardIterator,
  4991.                typename _UniformRandomNumberGenerator>
  4992.         void
  4993.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  4994.                         _UniformRandomNumberGenerator& __urng,
  4995.                         const param_type& __p);
  4996.  
  4997.       param_type _M_param;
  4998.     };
  4999.  
  5000.    /**
  5001.     * @brief Return true if two Weibull distributions have different
  5002.     *        parameters.
  5003.     */
  5004.   template<typename _RealType>
  5005.     inline bool
  5006.     operator!=(const std::weibull_distribution<_RealType>& __d1,
  5007.                const std::weibull_distribution<_RealType>& __d2)
  5008.     { return !(__d1 == __d2); }
  5009.  
  5010.   /**
  5011.    * @brief Inserts a %weibull_distribution random number distribution
  5012.    * @p __x into the output stream @p __os.
  5013.    *
  5014.    * @param __os An output stream.
  5015.    * @param __x  A %weibull_distribution random number distribution.
  5016.    *
  5017.    * @returns The output stream with the state of @p __x inserted or in
  5018.    * an error state.
  5019.    */
  5020.   template<typename _RealType, typename _CharT, typename _Traits>
  5021.     std::basic_ostream<_CharT, _Traits>&
  5022.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  5023.                const std::weibull_distribution<_RealType>& __x);
  5024.  
  5025.   /**
  5026.    * @brief Extracts a %weibull_distribution random number distribution
  5027.    * @p __x from the input stream @p __is.
  5028.    *
  5029.    * @param __is An input stream.
  5030.    * @param __x A %weibull_distribution random number
  5031.    *            generator engine.
  5032.    *
  5033.    * @returns The input stream with @p __x extracted or in an error state.
  5034.    */
  5035.   template<typename _RealType, typename _CharT, typename _Traits>
  5036.     std::basic_istream<_CharT, _Traits>&
  5037.     operator>>(std::basic_istream<_CharT, _Traits>& __is,
  5038.                std::weibull_distribution<_RealType>& __x);
  5039.  
  5040.  
  5041.   /**
  5042.    * @brief A extreme_value_distribution random number distribution.
  5043.    *
  5044.    * The formula for the normal probability mass function is
  5045.    * @f[
  5046.    *     p(x|a,b) = \frac{1}{b}
  5047.    *                \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
  5048.    * @f]
  5049.    */
  5050.   template<typename _RealType = double>
  5051.     class extreme_value_distribution
  5052.     {
  5053.       static_assert(std::is_floating_point<_RealType>::value,
  5054.                     "template argument not a floating point type");
  5055.  
  5056.     public:
  5057.       /** The type of the range of the distribution. */
  5058.       typedef _RealType result_type;
  5059.       /** Parameter type. */
  5060.       struct param_type
  5061.       {
  5062.         typedef extreme_value_distribution<_RealType> distribution_type;
  5063.  
  5064.         explicit
  5065.         param_type(_RealType __a = _RealType(0),
  5066.                    _RealType __b = _RealType(1))
  5067.         : _M_a(__a), _M_b(__b)
  5068.         { }
  5069.  
  5070.         _RealType
  5071.         a() const
  5072.         { return _M_a; }
  5073.  
  5074.         _RealType
  5075.         b() const
  5076.         { return _M_b; }
  5077.  
  5078.         friend bool
  5079.         operator==(const param_type& __p1, const param_type& __p2)
  5080.         { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
  5081.  
  5082.       private:
  5083.         _RealType _M_a;
  5084.         _RealType _M_b;
  5085.       };
  5086.  
  5087.       explicit
  5088.       extreme_value_distribution(_RealType __a = _RealType(0),
  5089.                                  _RealType __b = _RealType(1))
  5090.       : _M_param(__a, __b)
  5091.       { }
  5092.  
  5093.       explicit
  5094.       extreme_value_distribution(const param_type& __p)
  5095.       : _M_param(__p)
  5096.       { }
  5097.  
  5098.       /**
  5099.        * @brief Resets the distribution state.
  5100.        */
  5101.       void
  5102.       reset()
  5103.       { }
  5104.  
  5105.       /**
  5106.        * @brief Return the @f$a@f$ parameter of the distribution.
  5107.        */
  5108.       _RealType
  5109.       a() const
  5110.       { return _M_param.a(); }
  5111.  
  5112.       /**
  5113.        * @brief Return the @f$b@f$ parameter of the distribution.
  5114.        */
  5115.       _RealType
  5116.       b() const
  5117.       { return _M_param.b(); }
  5118.  
  5119.       /**
  5120.        * @brief Returns the parameter set of the distribution.
  5121.        */
  5122.       param_type
  5123.       param() const
  5124.       { return _M_param; }
  5125.  
  5126.       /**
  5127.        * @brief Sets the parameter set of the distribution.
  5128.        * @param __param The new parameter set of the distribution.
  5129.        */
  5130.       void
  5131.       param(const param_type& __param)
  5132.       { _M_param = __param; }
  5133.  
  5134.       /**
  5135.        * @brief Returns the greatest lower bound value of the distribution.
  5136.        */
  5137.       result_type
  5138.       min() const
  5139.       { return std::numeric_limits<result_type>::lowest(); }
  5140.  
  5141.       /**
  5142.        * @brief Returns the least upper bound value of the distribution.
  5143.        */
  5144.       result_type
  5145.       max() const
  5146.       { return std::numeric_limits<result_type>::max(); }
  5147.  
  5148.       /**
  5149.        * @brief Generating functions.
  5150.        */
  5151.       template<typename _UniformRandomNumberGenerator>
  5152.         result_type
  5153.         operator()(_UniformRandomNumberGenerator& __urng)
  5154.         { return this->operator()(__urng, _M_param); }
  5155.  
  5156.       template<typename _UniformRandomNumberGenerator>
  5157.         result_type
  5158.         operator()(_UniformRandomNumberGenerator& __urng,
  5159.                    const param_type& __p);
  5160.  
  5161.       template<typename _ForwardIterator,
  5162.                typename _UniformRandomNumberGenerator>
  5163.         void
  5164.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5165.                    _UniformRandomNumberGenerator& __urng)
  5166.         { this->__generate(__f, __t, __urng, _M_param); }
  5167.  
  5168.       template<typename _ForwardIterator,
  5169.                typename _UniformRandomNumberGenerator>
  5170.         void
  5171.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5172.                    _UniformRandomNumberGenerator& __urng,
  5173.                    const param_type& __p)
  5174.         { this->__generate_impl(__f, __t, __urng, __p); }
  5175.  
  5176.       template<typename _UniformRandomNumberGenerator>
  5177.         void
  5178.         __generate(result_type* __f, result_type* __t,
  5179.                    _UniformRandomNumberGenerator& __urng,
  5180.                    const param_type& __p)
  5181.         { this->__generate_impl(__f, __t, __urng, __p); }
  5182.  
  5183.       /**
  5184.        * @brief Return true if two extreme value distributions have the same
  5185.        *        parameters.
  5186.        */
  5187.       friend bool
  5188.       operator==(const extreme_value_distribution& __d1,
  5189.                  const extreme_value_distribution& __d2)
  5190.       { return __d1._M_param == __d2._M_param; }
  5191.  
  5192.     private:
  5193.       template<typename _ForwardIterator,
  5194.                typename _UniformRandomNumberGenerator>
  5195.         void
  5196.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  5197.                         _UniformRandomNumberGenerator& __urng,
  5198.                         const param_type& __p);
  5199.  
  5200.       param_type _M_param;
  5201.     };
  5202.  
  5203.   /**
  5204.     * @brief Return true if two extreme value distributions have different
  5205.     *        parameters.
  5206.    */
  5207.   template<typename _RealType>
  5208.     inline bool
  5209.     operator!=(const std::extreme_value_distribution<_RealType>& __d1,
  5210.                const std::extreme_value_distribution<_RealType>& __d2)
  5211.     { return !(__d1 == __d2); }
  5212.  
  5213.   /**
  5214.    * @brief Inserts a %extreme_value_distribution random number distribution
  5215.    * @p __x into the output stream @p __os.
  5216.    *
  5217.    * @param __os An output stream.
  5218.    * @param __x  A %extreme_value_distribution random number distribution.
  5219.    *
  5220.    * @returns The output stream with the state of @p __x inserted or in
  5221.    * an error state.
  5222.    */
  5223.   template<typename _RealType, typename _CharT, typename _Traits>
  5224.     std::basic_ostream<_CharT, _Traits>&
  5225.     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  5226.                const std::extreme_value_distribution<_RealType>& __x);
  5227.  
  5228.   /**
  5229.    * @brief Extracts a %extreme_value_distribution random number
  5230.    *        distribution @p __x from the input stream @p __is.
  5231.    *
  5232.    * @param __is An input stream.
  5233.    * @param __x A %extreme_value_distribution random number
  5234.    *            generator engine.
  5235.    *
  5236.    * @returns The input stream with @p __x extracted or in an error state.
  5237.    */
  5238.   template<typename _RealType, typename _CharT, typename _Traits>
  5239.     std::basic_istream<_CharT, _Traits>&
  5240.     operator>>(std::basic_istream<_CharT, _Traits>& __is,
  5241.                std::extreme_value_distribution<_RealType>& __x);
  5242.  
  5243.  
  5244.   /**
  5245.    * @brief A discrete_distribution random number distribution.
  5246.    *
  5247.    * The formula for the discrete probability mass function is
  5248.    *
  5249.    */
  5250.   template<typename _IntType = int>
  5251.     class discrete_distribution
  5252.     {
  5253.       static_assert(std::is_integral<_IntType>::value,
  5254.                     "template argument not an integral type");
  5255.  
  5256.     public:
  5257.       /** The type of the range of the distribution. */
  5258.       typedef _IntType result_type;
  5259.       /** Parameter type. */
  5260.       struct param_type
  5261.       {
  5262.         typedef discrete_distribution<_IntType> distribution_type;
  5263.         friend class discrete_distribution<_IntType>;
  5264.  
  5265.         param_type()
  5266.         : _M_prob(), _M_cp()
  5267.         { }
  5268.  
  5269.         template<typename _InputIterator>
  5270.           param_type(_InputIterator __wbegin,
  5271.                      _InputIterator __wend)
  5272.           : _M_prob(__wbegin, __wend), _M_cp()
  5273.           { _M_initialize(); }
  5274.  
  5275.         param_type(initializer_list<double> __wil)
  5276.         : _M_prob(__wil.begin(), __wil.end()), _M_cp()
  5277.         { _M_initialize(); }
  5278.  
  5279.         template<typename _Func>
  5280.           param_type(size_t __nw, double __xmin, double __xmax,
  5281.                      _Func __fw);
  5282.  
  5283.         // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
  5284.         param_type(const param_type&) = default;
  5285.         param_type& operator=(const param_type&) = default;
  5286.  
  5287.         std::vector<double>
  5288.         probabilities() const
  5289.         { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
  5290.  
  5291.         friend bool
  5292.         operator==(const param_type& __p1, const param_type& __p2)
  5293.         { return __p1._M_prob == __p2._M_prob; }
  5294.  
  5295.       private:
  5296.         void
  5297.         _M_initialize();
  5298.  
  5299.         std::vector<double> _M_prob;
  5300.         std::vector<double> _M_cp;
  5301.       };
  5302.  
  5303.       discrete_distribution()
  5304.       : _M_param()
  5305.       { }
  5306.  
  5307.       template<typename _InputIterator>
  5308.         discrete_distribution(_InputIterator __wbegin,
  5309.                               _InputIterator __wend)
  5310.         : _M_param(__wbegin, __wend)
  5311.         { }
  5312.  
  5313.       discrete_distribution(initializer_list<double> __wl)
  5314.       : _M_param(__wl)
  5315.       { }
  5316.  
  5317.       template<typename _Func>
  5318.         discrete_distribution(size_t __nw, double __xmin, double __xmax,
  5319.                               _Func __fw)
  5320.         : _M_param(__nw, __xmin, __xmax, __fw)
  5321.         { }
  5322.  
  5323.       explicit
  5324.       discrete_distribution(const param_type& __p)
  5325.       : _M_param(__p)
  5326.       { }
  5327.  
  5328.       /**
  5329.        * @brief Resets the distribution state.
  5330.        */
  5331.       void
  5332.       reset()
  5333.       { }
  5334.  
  5335.       /**
  5336.        * @brief Returns the probabilities of the distribution.
  5337.        */
  5338.       std::vector<double>
  5339.       probabilities() const
  5340.       {
  5341.         return _M_param._M_prob.empty()
  5342.           ? std::vector<double>(1, 1.0) : _M_param._M_prob;
  5343.       }
  5344.  
  5345.       /**
  5346.        * @brief Returns the parameter set of the distribution.
  5347.        */
  5348.       param_type
  5349.       param() const
  5350.       { return _M_param; }
  5351.  
  5352.       /**
  5353.        * @brief Sets the parameter set of the distribution.
  5354.        * @param __param The new parameter set of the distribution.
  5355.        */
  5356.       void
  5357.       param(const param_type& __param)
  5358.       { _M_param = __param; }
  5359.  
  5360.       /**
  5361.        * @brief Returns the greatest lower bound value of the distribution.
  5362.        */
  5363.       result_type
  5364.       min() const
  5365.       { return result_type(0); }
  5366.  
  5367.       /**
  5368.        * @brief Returns the least upper bound value of the distribution.
  5369.        */
  5370.       result_type
  5371.       max() const
  5372.       {
  5373.         return _M_param._M_prob.empty()
  5374.           ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
  5375.       }
  5376.  
  5377.       /**
  5378.        * @brief Generating functions.
  5379.        */
  5380.       template<typename _UniformRandomNumberGenerator>
  5381.         result_type
  5382.         operator()(_UniformRandomNumberGenerator& __urng)
  5383.         { return this->operator()(__urng, _M_param); }
  5384.  
  5385.       template<typename _UniformRandomNumberGenerator>
  5386.         result_type
  5387.         operator()(_UniformRandomNumberGenerator& __urng,
  5388.                    const param_type& __p);
  5389.  
  5390.       template<typename _ForwardIterator,
  5391.                typename _UniformRandomNumberGenerator>
  5392.         void
  5393.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5394.                    _UniformRandomNumberGenerator& __urng)
  5395.         { this->__generate(__f, __t, __urng, _M_param); }
  5396.  
  5397.       template<typename _ForwardIterator,
  5398.                typename _UniformRandomNumberGenerator>
  5399.         void
  5400.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5401.                    _UniformRandomNumberGenerator& __urng,
  5402.                    const param_type& __p)
  5403.         { this->__generate_impl(__f, __t, __urng, __p); }
  5404.  
  5405.       template<typename _UniformRandomNumberGenerator>
  5406.         void
  5407.         __generate(result_type* __f, result_type* __t,
  5408.                    _UniformRandomNumberGenerator& __urng,
  5409.                    const param_type& __p)
  5410.         { this->__generate_impl(__f, __t, __urng, __p); }
  5411.  
  5412.       /**
  5413.        * @brief Return true if two discrete distributions have the same
  5414.        *        parameters.
  5415.        */
  5416.       friend bool
  5417.       operator==(const discrete_distribution& __d1,
  5418.                  const discrete_distribution& __d2)
  5419.       { return __d1._M_param == __d2._M_param; }
  5420.  
  5421.       /**
  5422.        * @brief Inserts a %discrete_distribution random number distribution
  5423.        * @p __x into the output stream @p __os.
  5424.        *
  5425.        * @param __os An output stream.
  5426.        * @param __x  A %discrete_distribution random number distribution.
  5427.        *
  5428.        * @returns The output stream with the state of @p __x inserted or in
  5429.        * an error state.
  5430.        */
  5431.       template<typename _IntType1, typename _CharT, typename _Traits>
  5432.         friend std::basic_ostream<_CharT, _Traits>&
  5433.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  5434.                    const std::discrete_distribution<_IntType1>& __x);
  5435.  
  5436.       /**
  5437.        * @brief Extracts a %discrete_distribution random number distribution
  5438.        * @p __x from the input stream @p __is.
  5439.        *
  5440.        * @param __is An input stream.
  5441.        * @param __x A %discrete_distribution random number
  5442.        *            generator engine.
  5443.        *
  5444.        * @returns The input stream with @p __x extracted or in an error
  5445.        *          state.
  5446.        */
  5447.       template<typename _IntType1, typename _CharT, typename _Traits>
  5448.         friend std::basic_istream<_CharT, _Traits>&
  5449.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  5450.                    std::discrete_distribution<_IntType1>& __x);
  5451.  
  5452.     private:
  5453.       template<typename _ForwardIterator,
  5454.                typename _UniformRandomNumberGenerator>
  5455.         void
  5456.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  5457.                         _UniformRandomNumberGenerator& __urng,
  5458.                         const param_type& __p);
  5459.  
  5460.       param_type _M_param;
  5461.     };
  5462.  
  5463.   /**
  5464.     * @brief Return true if two discrete distributions have different
  5465.     *        parameters.
  5466.     */
  5467.   template<typename _IntType>
  5468.     inline bool
  5469.     operator!=(const std::discrete_distribution<_IntType>& __d1,
  5470.                const std::discrete_distribution<_IntType>& __d2)
  5471.     { return !(__d1 == __d2); }
  5472.  
  5473.  
  5474.   /**
  5475.    * @brief A piecewise_constant_distribution random number distribution.
  5476.    *
  5477.    * The formula for the piecewise constant probability mass function is
  5478.    *
  5479.    */
  5480.   template<typename _RealType = double>
  5481.     class piecewise_constant_distribution
  5482.     {
  5483.       static_assert(std::is_floating_point<_RealType>::value,
  5484.                     "template argument not a floating point type");
  5485.  
  5486.     public:
  5487.       /** The type of the range of the distribution. */
  5488.       typedef _RealType result_type;
  5489.       /** Parameter type. */
  5490.       struct param_type
  5491.       {
  5492.         typedef piecewise_constant_distribution<_RealType> distribution_type;
  5493.         friend class piecewise_constant_distribution<_RealType>;
  5494.  
  5495.         param_type()
  5496.         : _M_int(), _M_den(), _M_cp()
  5497.         { }
  5498.  
  5499.         template<typename _InputIteratorB, typename _InputIteratorW>
  5500.           param_type(_InputIteratorB __bfirst,
  5501.                      _InputIteratorB __bend,
  5502.                      _InputIteratorW __wbegin);
  5503.  
  5504.         template<typename _Func>
  5505.           param_type(initializer_list<_RealType> __bi, _Func __fw);
  5506.  
  5507.         template<typename _Func>
  5508.           param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
  5509.                      _Func __fw);
  5510.  
  5511.         // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
  5512.         param_type(const param_type&) = default;
  5513.         param_type& operator=(const param_type&) = default;
  5514.  
  5515.         std::vector<_RealType>
  5516.         intervals() const
  5517.         {
  5518.           if (_M_int.empty())
  5519.             {
  5520.               std::vector<_RealType> __tmp(2);
  5521.               __tmp[1] = _RealType(1);
  5522.               return __tmp;
  5523.             }
  5524.           else
  5525.             return _M_int;
  5526.         }
  5527.  
  5528.         std::vector<double>
  5529.         densities() const
  5530.         { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
  5531.  
  5532.         friend bool
  5533.         operator==(const param_type& __p1, const param_type& __p2)
  5534.         { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
  5535.  
  5536.       private:
  5537.         void
  5538.         _M_initialize();
  5539.  
  5540.         std::vector<_RealType> _M_int;
  5541.         std::vector<double> _M_den;
  5542.         std::vector<double> _M_cp;
  5543.       };
  5544.  
  5545.       explicit
  5546.       piecewise_constant_distribution()
  5547.       : _M_param()
  5548.       { }
  5549.  
  5550.       template<typename _InputIteratorB, typename _InputIteratorW>
  5551.         piecewise_constant_distribution(_InputIteratorB __bfirst,
  5552.                                         _InputIteratorB __bend,
  5553.                                         _InputIteratorW __wbegin)
  5554.         : _M_param(__bfirst, __bend, __wbegin)
  5555.         { }
  5556.  
  5557.       template<typename _Func>
  5558.         piecewise_constant_distribution(initializer_list<_RealType> __bl,
  5559.                                         _Func __fw)
  5560.         : _M_param(__bl, __fw)
  5561.         { }
  5562.  
  5563.       template<typename _Func>
  5564.         piecewise_constant_distribution(size_t __nw,
  5565.                                         _RealType __xmin, _RealType __xmax,
  5566.                                         _Func __fw)
  5567.         : _M_param(__nw, __xmin, __xmax, __fw)
  5568.         { }
  5569.  
  5570.       explicit
  5571.       piecewise_constant_distribution(const param_type& __p)
  5572.       : _M_param(__p)
  5573.       { }
  5574.  
  5575.       /**
  5576.        * @brief Resets the distribution state.
  5577.        */
  5578.       void
  5579.       reset()
  5580.       { }
  5581.  
  5582.       /**
  5583.        * @brief Returns a vector of the intervals.
  5584.        */
  5585.       std::vector<_RealType>
  5586.       intervals() const
  5587.       {
  5588.         if (_M_param._M_int.empty())
  5589.           {
  5590.             std::vector<_RealType> __tmp(2);
  5591.             __tmp[1] = _RealType(1);
  5592.             return __tmp;
  5593.           }
  5594.         else
  5595.           return _M_param._M_int;
  5596.       }
  5597.  
  5598.       /**
  5599.        * @brief Returns a vector of the probability densities.
  5600.        */
  5601.       std::vector<double>
  5602.       densities() const
  5603.       {
  5604.         return _M_param._M_den.empty()
  5605.           ? std::vector<double>(1, 1.0) : _M_param._M_den;
  5606.       }
  5607.  
  5608.       /**
  5609.        * @brief Returns the parameter set of the distribution.
  5610.        */
  5611.       param_type
  5612.       param() const
  5613.       { return _M_param; }
  5614.  
  5615.       /**
  5616.        * @brief Sets the parameter set of the distribution.
  5617.        * @param __param The new parameter set of the distribution.
  5618.        */
  5619.       void
  5620.       param(const param_type& __param)
  5621.       { _M_param = __param; }
  5622.  
  5623.       /**
  5624.        * @brief Returns the greatest lower bound value of the distribution.
  5625.        */
  5626.       result_type
  5627.       min() const
  5628.       {
  5629.         return _M_param._M_int.empty()
  5630.           ? result_type(0) : _M_param._M_int.front();
  5631.       }
  5632.  
  5633.       /**
  5634.        * @brief Returns the least upper bound value of the distribution.
  5635.        */
  5636.       result_type
  5637.       max() const
  5638.       {
  5639.         return _M_param._M_int.empty()
  5640.           ? result_type(1) : _M_param._M_int.back();
  5641.       }
  5642.  
  5643.       /**
  5644.        * @brief Generating functions.
  5645.        */
  5646.       template<typename _UniformRandomNumberGenerator>
  5647.         result_type
  5648.         operator()(_UniformRandomNumberGenerator& __urng)
  5649.         { return this->operator()(__urng, _M_param); }
  5650.  
  5651.       template<typename _UniformRandomNumberGenerator>
  5652.         result_type
  5653.         operator()(_UniformRandomNumberGenerator& __urng,
  5654.                    const param_type& __p);
  5655.  
  5656.       template<typename _ForwardIterator,
  5657.                typename _UniformRandomNumberGenerator>
  5658.         void
  5659.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5660.                    _UniformRandomNumberGenerator& __urng)
  5661.         { this->__generate(__f, __t, __urng, _M_param); }
  5662.  
  5663.       template<typename _ForwardIterator,
  5664.                typename _UniformRandomNumberGenerator>
  5665.         void
  5666.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5667.                    _UniformRandomNumberGenerator& __urng,
  5668.                    const param_type& __p)
  5669.         { this->__generate_impl(__f, __t, __urng, __p); }
  5670.  
  5671.       template<typename _UniformRandomNumberGenerator>
  5672.         void
  5673.         __generate(result_type* __f, result_type* __t,
  5674.                    _UniformRandomNumberGenerator& __urng,
  5675.                    const param_type& __p)
  5676.         { this->__generate_impl(__f, __t, __urng, __p); }
  5677.  
  5678.       /**
  5679.        * @brief Return true if two piecewise constant distributions have the
  5680.        *        same parameters.
  5681.        */
  5682.       friend bool
  5683.       operator==(const piecewise_constant_distribution& __d1,
  5684.                  const piecewise_constant_distribution& __d2)
  5685.       { return __d1._M_param == __d2._M_param; }
  5686.  
  5687.       /**
  5688.        * @brief Inserts a %piecewise_constan_distribution random
  5689.        *        number distribution @p __x into the output stream @p __os.
  5690.        *
  5691.        * @param __os An output stream.
  5692.        * @param __x  A %piecewise_constan_distribution random number
  5693.        *             distribution.
  5694.        *
  5695.        * @returns The output stream with the state of @p __x inserted or in
  5696.        * an error state.
  5697.        */
  5698.       template<typename _RealType1, typename _CharT, typename _Traits>
  5699.         friend std::basic_ostream<_CharT, _Traits>&
  5700.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  5701.                    const std::piecewise_constant_distribution<_RealType1>& __x);
  5702.  
  5703.       /**
  5704.        * @brief Extracts a %piecewise_constan_distribution random
  5705.        *        number distribution @p __x from the input stream @p __is.
  5706.        *
  5707.        * @param __is An input stream.
  5708.        * @param __x A %piecewise_constan_distribution random number
  5709.        *            generator engine.
  5710.        *
  5711.        * @returns The input stream with @p __x extracted or in an error
  5712.        *          state.
  5713.        */
  5714.       template<typename _RealType1, typename _CharT, typename _Traits>
  5715.         friend std::basic_istream<_CharT, _Traits>&
  5716.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  5717.                    std::piecewise_constant_distribution<_RealType1>& __x);
  5718.  
  5719.     private:
  5720.       template<typename _ForwardIterator,
  5721.                typename _UniformRandomNumberGenerator>
  5722.         void
  5723.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  5724.                         _UniformRandomNumberGenerator& __urng,
  5725.                         const param_type& __p);
  5726.  
  5727.       param_type _M_param;
  5728.     };
  5729.  
  5730.   /**
  5731.     * @brief Return true if two piecewise constant distributions have
  5732.     *        different parameters.
  5733.    */
  5734.   template<typename _RealType>
  5735.     inline bool
  5736.     operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
  5737.                const std::piecewise_constant_distribution<_RealType>& __d2)
  5738.     { return !(__d1 == __d2); }
  5739.  
  5740.  
  5741.   /**
  5742.    * @brief A piecewise_linear_distribution random number distribution.
  5743.    *
  5744.    * The formula for the piecewise linear probability mass function is
  5745.    *
  5746.    */
  5747.   template<typename _RealType = double>
  5748.     class piecewise_linear_distribution
  5749.     {
  5750.       static_assert(std::is_floating_point<_RealType>::value,
  5751.                     "template argument not a floating point type");
  5752.  
  5753.     public:
  5754.       /** The type of the range of the distribution. */
  5755.       typedef _RealType result_type;
  5756.       /** Parameter type. */
  5757.       struct param_type
  5758.       {
  5759.         typedef piecewise_linear_distribution<_RealType> distribution_type;
  5760.         friend class piecewise_linear_distribution<_RealType>;
  5761.  
  5762.         param_type()
  5763.         : _M_int(), _M_den(), _M_cp(), _M_m()
  5764.         { }
  5765.  
  5766.         template<typename _InputIteratorB, typename _InputIteratorW>
  5767.           param_type(_InputIteratorB __bfirst,
  5768.                      _InputIteratorB __bend,
  5769.                      _InputIteratorW __wbegin);
  5770.  
  5771.         template<typename _Func>
  5772.           param_type(initializer_list<_RealType> __bl, _Func __fw);
  5773.  
  5774.         template<typename _Func>
  5775.           param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
  5776.                      _Func __fw);
  5777.  
  5778.         // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
  5779.         param_type(const param_type&) = default;
  5780.         param_type& operator=(const param_type&) = default;
  5781.  
  5782.         std::vector<_RealType>
  5783.         intervals() const
  5784.         {
  5785.           if (_M_int.empty())
  5786.             {
  5787.               std::vector<_RealType> __tmp(2);
  5788.               __tmp[1] = _RealType(1);
  5789.               return __tmp;
  5790.             }
  5791.           else
  5792.             return _M_int;
  5793.         }
  5794.  
  5795.         std::vector<double>
  5796.         densities() const
  5797.         { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
  5798.  
  5799.         friend bool
  5800.         operator==(const param_type& __p1, const param_type& __p2)
  5801.         { return (__p1._M_int == __p2._M_int
  5802.                   && __p1._M_den == __p2._M_den); }
  5803.  
  5804.       private:
  5805.         void
  5806.         _M_initialize();
  5807.  
  5808.         std::vector<_RealType> _M_int;
  5809.         std::vector<double> _M_den;
  5810.         std::vector<double> _M_cp;
  5811.         std::vector<double> _M_m;
  5812.       };
  5813.  
  5814.       explicit
  5815.       piecewise_linear_distribution()
  5816.       : _M_param()
  5817.       { }
  5818.  
  5819.       template<typename _InputIteratorB, typename _InputIteratorW>
  5820.         piecewise_linear_distribution(_InputIteratorB __bfirst,
  5821.                                       _InputIteratorB __bend,
  5822.                                       _InputIteratorW __wbegin)
  5823.         : _M_param(__bfirst, __bend, __wbegin)
  5824.         { }
  5825.  
  5826.       template<typename _Func>
  5827.         piecewise_linear_distribution(initializer_list<_RealType> __bl,
  5828.                                       _Func __fw)
  5829.         : _M_param(__bl, __fw)
  5830.         { }
  5831.  
  5832.       template<typename _Func>
  5833.         piecewise_linear_distribution(size_t __nw,
  5834.                                       _RealType __xmin, _RealType __xmax,
  5835.                                       _Func __fw)
  5836.         : _M_param(__nw, __xmin, __xmax, __fw)
  5837.         { }
  5838.  
  5839.       explicit
  5840.       piecewise_linear_distribution(const param_type& __p)
  5841.       : _M_param(__p)
  5842.       { }
  5843.  
  5844.       /**
  5845.        * Resets the distribution state.
  5846.        */
  5847.       void
  5848.       reset()
  5849.       { }
  5850.  
  5851.       /**
  5852.        * @brief Return the intervals of the distribution.
  5853.        */
  5854.       std::vector<_RealType>
  5855.       intervals() const
  5856.       {
  5857.         if (_M_param._M_int.empty())
  5858.           {
  5859.             std::vector<_RealType> __tmp(2);
  5860.             __tmp[1] = _RealType(1);
  5861.             return __tmp;
  5862.           }
  5863.         else
  5864.           return _M_param._M_int;
  5865.       }
  5866.  
  5867.       /**
  5868.        * @brief Return a vector of the probability densities of the
  5869.        *        distribution.
  5870.        */
  5871.       std::vector<double>
  5872.       densities() const
  5873.       {
  5874.         return _M_param._M_den.empty()
  5875.           ? std::vector<double>(2, 1.0) : _M_param._M_den;
  5876.       }
  5877.  
  5878.       /**
  5879.        * @brief Returns the parameter set of the distribution.
  5880.        */
  5881.       param_type
  5882.       param() const
  5883.       { return _M_param; }
  5884.  
  5885.       /**
  5886.        * @brief Sets the parameter set of the distribution.
  5887.        * @param __param The new parameter set of the distribution.
  5888.        */
  5889.       void
  5890.       param(const param_type& __param)
  5891.       { _M_param = __param; }
  5892.  
  5893.       /**
  5894.        * @brief Returns the greatest lower bound value of the distribution.
  5895.        */
  5896.       result_type
  5897.       min() const
  5898.       {
  5899.         return _M_param._M_int.empty()
  5900.           ? result_type(0) : _M_param._M_int.front();
  5901.       }
  5902.  
  5903.       /**
  5904.        * @brief Returns the least upper bound value of the distribution.
  5905.        */
  5906.       result_type
  5907.       max() const
  5908.       {
  5909.         return _M_param._M_int.empty()
  5910.           ? result_type(1) : _M_param._M_int.back();
  5911.       }
  5912.  
  5913.       /**
  5914.        * @brief Generating functions.
  5915.        */
  5916.       template<typename _UniformRandomNumberGenerator>
  5917.         result_type
  5918.         operator()(_UniformRandomNumberGenerator& __urng)
  5919.         { return this->operator()(__urng, _M_param); }
  5920.  
  5921.       template<typename _UniformRandomNumberGenerator>
  5922.         result_type
  5923.         operator()(_UniformRandomNumberGenerator& __urng,
  5924.                    const param_type& __p);
  5925.  
  5926.       template<typename _ForwardIterator,
  5927.                typename _UniformRandomNumberGenerator>
  5928.         void
  5929.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5930.                    _UniformRandomNumberGenerator& __urng)
  5931.         { this->__generate(__f, __t, __urng, _M_param); }
  5932.  
  5933.       template<typename _ForwardIterator,
  5934.                typename _UniformRandomNumberGenerator>
  5935.         void
  5936.         __generate(_ForwardIterator __f, _ForwardIterator __t,
  5937.                    _UniformRandomNumberGenerator& __urng,
  5938.                    const param_type& __p)
  5939.         { this->__generate_impl(__f, __t, __urng, __p); }
  5940.  
  5941.       template<typename _UniformRandomNumberGenerator>
  5942.         void
  5943.         __generate(result_type* __f, result_type* __t,
  5944.                    _UniformRandomNumberGenerator& __urng,
  5945.                    const param_type& __p)
  5946.         { this->__generate_impl(__f, __t, __urng, __p); }
  5947.  
  5948.       /**
  5949.        * @brief Return true if two piecewise linear distributions have the
  5950.        *        same parameters.
  5951.        */
  5952.       friend bool
  5953.       operator==(const piecewise_linear_distribution& __d1,
  5954.                  const piecewise_linear_distribution& __d2)
  5955.       { return __d1._M_param == __d2._M_param; }
  5956.  
  5957.       /**
  5958.        * @brief Inserts a %piecewise_linear_distribution random number
  5959.        *        distribution @p __x into the output stream @p __os.
  5960.        *
  5961.        * @param __os An output stream.
  5962.        * @param __x  A %piecewise_linear_distribution random number
  5963.        *             distribution.
  5964.        *
  5965.        * @returns The output stream with the state of @p __x inserted or in
  5966.        *          an error state.
  5967.        */
  5968.       template<typename _RealType1, typename _CharT, typename _Traits>
  5969.         friend std::basic_ostream<_CharT, _Traits>&
  5970.         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
  5971.                    const std::piecewise_linear_distribution<_RealType1>& __x);
  5972.  
  5973.       /**
  5974.        * @brief Extracts a %piecewise_linear_distribution random number
  5975.        *        distribution @p __x from the input stream @p __is.
  5976.        *
  5977.        * @param __is An input stream.
  5978.        * @param __x  A %piecewise_linear_distribution random number
  5979.        *             generator engine.
  5980.        *
  5981.        * @returns The input stream with @p __x extracted or in an error
  5982.        *          state.
  5983.        */
  5984.       template<typename _RealType1, typename _CharT, typename _Traits>
  5985.         friend std::basic_istream<_CharT, _Traits>&
  5986.         operator>>(std::basic_istream<_CharT, _Traits>& __is,
  5987.                    std::piecewise_linear_distribution<_RealType1>& __x);
  5988.  
  5989.     private:
  5990.       template<typename _ForwardIterator,
  5991.                typename _UniformRandomNumberGenerator>
  5992.         void
  5993.         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
  5994.                         _UniformRandomNumberGenerator& __urng,
  5995.                         const param_type& __p);
  5996.  
  5997.       param_type _M_param;
  5998.     };
  5999.  
  6000.   /**
  6001.     * @brief Return true if two piecewise linear distributions have
  6002.     *        different parameters.
  6003.    */
  6004.   template<typename _RealType>
  6005.     inline bool
  6006.     operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
  6007.                const std::piecewise_linear_distribution<_RealType>& __d2)
  6008.     { return !(__d1 == __d2); }
  6009.  
  6010.  
  6011.   /* @} */ // group random_distributions_poisson
  6012.  
  6013.   /* @} */ // group random_distributions
  6014.  
  6015.   /**
  6016.    * @addtogroup random_utilities Random Number Utilities
  6017.    * @ingroup random
  6018.    * @{
  6019.    */
  6020.  
  6021.   /**
  6022.    * @brief The seed_seq class generates sequences of seeds for random
  6023.    *        number generators.
  6024.    */
  6025.   class seed_seq
  6026.   {
  6027.  
  6028.   public:
  6029.     /** The type of the seed vales. */
  6030.     typedef uint_least32_t result_type;
  6031.  
  6032.     /** Default constructor. */
  6033.     seed_seq()
  6034.     : _M_v()
  6035.     { }
  6036.  
  6037.     template<typename _IntType>
  6038.       seed_seq(std::initializer_list<_IntType> il);
  6039.  
  6040.     template<typename _InputIterator>
  6041.       seed_seq(_InputIterator __begin, _InputIterator __end);
  6042.  
  6043.     // generating functions
  6044.     template<typename _RandomAccessIterator>
  6045.       void
  6046.       generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
  6047.  
  6048.     // property functions
  6049.     size_t size() const
  6050.     { return _M_v.size(); }
  6051.  
  6052.     template<typename OutputIterator>
  6053.       void
  6054.       param(OutputIterator __dest) const
  6055.       { std::copy(_M_v.begin(), _M_v.end(), __dest); }
  6056.  
  6057.   private:
  6058.     ///
  6059.     std::vector<result_type> _M_v;
  6060.   };
  6061.  
  6062.   /* @} */ // group random_utilities
  6063.  
  6064.   /* @} */ // group random
  6065.  
  6066. _GLIBCXX_END_NAMESPACE_VERSION
  6067. } // namespace std
  6068.  
  6069. #endif
  6070.