libstdc++-v3/include/bits/random.h

   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>::min(); }
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>::min(); }
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>::min(); }
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, _IntType __t);
3982
3983       param_type _M_param;
3984
3985       // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
3986       std::normal_distribution<double> _M_nd;
3987     };
3988
3989   /**
3990    * @brief Return true if two binomial distributions are different.
3991    */
3992   template<typename _IntType>
3993     inline bool
3994     operator!=(const std::binomial_distribution<_IntType>& __d1,
3995                const std::binomial_distribution<_IntType>& __d2)
3996     { return !(__d1 == __d2); }
3997
3998
3999   /**
4000    * @brief A discrete geometric random number distribution.
4001    *
4002    * The formula for the geometric probability density function is
4003    * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the
4004    * distribution.
4005    */
4006   template<typename _IntType = int>
4007     class geometric_distribution
4008     {
4009       static_assert(std::is_integral<_IntType>::value,
4010                     "template argument not an integral type");
4011
4012     public:
4013       /** The type of the range of the distribution. */
4014       typedef _IntType  result_type;
4015       /** Parameter type. */
4016       struct param_type
4017       {
4018         typedef geometric_distribution<_IntType> distribution_type;
4019         friend class geometric_distribution<_IntType>;
4020
4021         explicit
4022         param_type(double __p = 0.5)
4023         : _M_p(__p)
4024         {
4025           _GLIBCXX_DEBUG_ASSERT((_M_p > 0.0) && (_M_p < 1.0));
4026           _M_initialize();
4027         }
4028
4029         double
4030         p() const
4031         { return _M_p; }
4032
4033         friend bool
4034         operator==(const param_type& __p1, const param_type& __p2)
4035         { return __p1._M_p == __p2._M_p; }
4036
4037       private:
4038         void
4039         _M_initialize()
4040         { _M_log_1_p = std::log(1.0 - _M_p); }
4041
4042         double _M_p;
4043
4044         double _M_log_1_p;
4045       };
4046
4047       // constructors and member function
4048       explicit
4049       geometric_distribution(double __p = 0.5)
4050       : _M_param(__p)
4051       { }
4052
4053       explicit
4054       geometric_distribution(const param_type& __p)
4055       : _M_param(__p)
4056       { }
4057
4058       /**
4059        * @brief Resets the distribution state.
4060        *
4061        * Does nothing for the geometric distribution.
4062        */
4063       void
4064       reset() { }
4065
4066       /**
4067        * @brief Returns the distribution parameter @p p.
4068        */
4069       double
4070       p() const
4071       { return _M_param.p(); }
4072
4073       /**
4074        * @brief Returns the parameter set of the distribution.
4075        */
4076       param_type
4077       param() const
4078       { return _M_param; }
4079
4080       /**
4081        * @brief Sets the parameter set of the distribution.
4082        * @param __param The new parameter set of the distribution.
4083        */
4084       void
4085       param(const param_type& __param)
4086       { _M_param = __param; }
4087
4088       /**
4089        * @brief Returns the greatest lower bound value of the distribution.
4090        */
4091       result_type
4092       min() const
4093       { return 0; }
4094
4095       /**
4096        * @brief Returns the least upper bound value of the distribution.
4097        */
4098       result_type
4099       max() const
4100       { return std::numeric_limits<result_type>::max(); }
4101
4102       /**
4103        * @brief Generating functions.
4104        */
4105       template<typename _UniformRandomNumberGenerator>
4106         result_type
4107         operator()(_UniformRandomNumberGenerator& __urng)
4108         { return this->operator()(__urng, _M_param); }
4109
4110       template<typename _UniformRandomNumberGenerator>
4111         result_type
4112         operator()(_UniformRandomNumberGenerator& __urng,
4113                    const param_type& __p);
4114
4115       template<typename _ForwardIterator,
4116                typename _UniformRandomNumberGenerator>
4117         void
4118         __generate(_ForwardIterator __f, _ForwardIterator __t,
4119                    _UniformRandomNumberGenerator& __urng)
4120         { this->__generate(__f, __t, __urng, _M_param); }
4121
4122       template<typename _ForwardIterator,
4123                typename _UniformRandomNumberGenerator>
4124         void
4125         __generate(_ForwardIterator __f, _ForwardIterator __t,
4126                    _UniformRandomNumberGenerator& __urng,
4127                    const param_type& __p)
4128         { this->__generate_impl(__f, __t, __urng, __p); }
4129
4130       template<typename _UniformRandomNumberGenerator>
4131         void
4132         __generate(result_type* __f, result_type* __t,
4133                    _UniformRandomNumberGenerator& __urng,
4134                    const param_type& __p)
4135         { this->__generate_impl(__f, __t, __urng, __p); }
4136
4137       /**
4138        * @brief Return true if two geometric distributions have
4139        *        the same parameters.
4140        */
4141       friend bool
4142       operator==(const geometric_distribution& __d1,
4143                  const geometric_distribution& __d2)
4144       { return __d1._M_param == __d2._M_param; }
4145
4146     private:
4147       template<typename _ForwardIterator,
4148                typename _UniformRandomNumberGenerator>
4149         void
4150         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4151                         _UniformRandomNumberGenerator& __urng,
4152                         const param_type& __p);
4153
4154       param_type _M_param;
4155     };
4156
4157   /**
4158    * @brief Return true if two geometric distributions have
4159    *        different parameters.
4160    */
4161   template<typename _IntType>
4162     inline bool
4163     operator!=(const std::geometric_distribution<_IntType>& __d1,
4164                const std::geometric_distribution<_IntType>& __d2)
4165     { return !(__d1 == __d2); }
4166
4167   /**
4168    * @brief Inserts a %geometric_distribution random number distribution
4169    * @p __x into the output stream @p __os.
4170    *
4171    * @param __os An output stream.
4172    * @param __x  A %geometric_distribution random number distribution.
4173    *
4174    * @returns The output stream with the state of @p __x inserted or in
4175    * an error state.
4176    */
4177   template<typename _IntType,
4178            typename _CharT, typename _Traits>
4179     std::basic_ostream<_CharT, _Traits>&
4180     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4181                const std::geometric_distribution<_IntType>& __x);
4182
4183   /**
4184    * @brief Extracts a %geometric_distribution random number distribution
4185    * @p __x from the input stream @p __is.
4186    *
4187    * @param __is An input stream.
4188    * @param __x  A %geometric_distribution random number generator engine.
4189    *
4190    * @returns The input stream with @p __x extracted or in an error state.
4191    */
4192   template<typename _IntType,
4193            typename _CharT, typename _Traits>
4194     std::basic_istream<_CharT, _Traits>&
4195     operator>>(std::basic_istream<_CharT, _Traits>& __is,
4196                std::geometric_distribution<_IntType>& __x);
4197
4198
4199   /**
4200    * @brief A negative_binomial_distribution random number distribution.
4201    *
4202    * The formula for the negative binomial probability mass function is
4203    * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$
4204    * and @f$p@f$ are the parameters of the distribution.
4205    */
4206   template<typename _IntType = int>
4207     class negative_binomial_distribution
4208     {
4209       static_assert(std::is_integral<_IntType>::value,
4210                     "template argument not an integral type");
4211
4212     public:
4213       /** The type of the range of the distribution. */
4214       typedef _IntType result_type;
4215       /** Parameter type. */
4216       struct param_type
4217       {
4218         typedef negative_binomial_distribution<_IntType> distribution_type;
4219
4220         explicit
4221         param_type(_IntType __k = 1, double __p = 0.5)
4222         : _M_k(__k), _M_p(__p)
4223         {
4224           _GLIBCXX_DEBUG_ASSERT((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0));
4225         }
4226
4227         _IntType
4228         k() const
4229         { return _M_k; }
4230
4231         double
4232         p() const
4233         { return _M_p; }
4234
4235         friend bool
4236         operator==(const param_type& __p1, const param_type& __p2)
4237         { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; }
4238
4239       private:
4240         _IntType _M_k;
4241         double _M_p;
4242       };
4243
4244       explicit
4245       negative_binomial_distribution(_IntType __k = 1, double __p = 0.5)
4246       : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p)
4247       { }
4248
4249       explicit
4250       negative_binomial_distribution(const param_type& __p)
4251       : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p())
4252       { }
4253
4254       /**
4255        * @brief Resets the distribution state.
4256        */
4257       void
4258       reset()
4259       { _M_gd.reset(); }
4260
4261       /**
4262        * @brief Return the @f$k@f$ parameter of the distribution.
4263        */
4264       _IntType
4265       k() const
4266       { return _M_param.k(); }
4267
4268       /**
4269        * @brief Return the @f$p@f$ parameter of the distribution.
4270        */
4271       double
4272       p() const
4273       { return _M_param.p(); }
4274
4275       /**
4276        * @brief Returns the parameter set of the distribution.
4277        */
4278       param_type
4279       param() const
4280       { return _M_param; }
4281
4282       /**
4283        * @brief Sets the parameter set of the distribution.
4284        * @param __param The new parameter set of the distribution.
4285        */
4286       void
4287       param(const param_type& __param)
4288       { _M_param = __param; }
4289
4290       /**
4291        * @brief Returns the greatest lower bound value of the distribution.
4292        */
4293       result_type
4294       min() const
4295       { return result_type(0); }
4296
4297       /**
4298        * @brief Returns the least upper bound value of the distribution.
4299        */
4300       result_type
4301       max() const
4302       { return std::numeric_limits<result_type>::max(); }
4303
4304       /**
4305        * @brief Generating functions.
4306        */
4307       template<typename _UniformRandomNumberGenerator>
4308         result_type
4309         operator()(_UniformRandomNumberGenerator& __urng);
4310
4311       template<typename _UniformRandomNumberGenerator>
4312         result_type
4313         operator()(_UniformRandomNumberGenerator& __urng,
4314                    const param_type& __p);
4315
4316       template<typename _ForwardIterator,
4317                typename _UniformRandomNumberGenerator>
4318         void
4319         __generate(_ForwardIterator __f, _ForwardIterator __t,
4320                    _UniformRandomNumberGenerator& __urng)
4321         { this->__generate_impl(__f, __t, __urng); }
4322
4323       template<typename _ForwardIterator,
4324                typename _UniformRandomNumberGenerator>
4325         void
4326         __generate(_ForwardIterator __f, _ForwardIterator __t,
4327                    _UniformRandomNumberGenerator& __urng,
4328                    const param_type& __p)
4329         { this->__generate_impl(__f, __t, __urng, __p); }
4330
4331       template<typename _UniformRandomNumberGenerator>
4332         void
4333         __generate(result_type* __f, result_type* __t,
4334                    _UniformRandomNumberGenerator& __urng)
4335         { this->__generate_impl(__f, __t, __urng); }
4336
4337       template<typename _UniformRandomNumberGenerator>
4338         void
4339         __generate(result_type* __f, result_type* __t,
4340                    _UniformRandomNumberGenerator& __urng,
4341                    const param_type& __p)
4342         { this->__generate_impl(__f, __t, __urng, __p); }
4343
4344       /**
4345        * @brief Return true if two negative binomial distributions have
4346        *        the same parameters and the sequences that would be
4347        *        generated are equal.
4348        */
4349       friend bool
4350       operator==(const negative_binomial_distribution& __d1,
4351                  const negative_binomial_distribution& __d2)
4352       { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; }
4353
4354       /**
4355        * @brief Inserts a %negative_binomial_distribution random
4356        *        number distribution @p __x into the output stream @p __os.
4357        *
4358        * @param __os An output stream.
4359        * @param __x  A %negative_binomial_distribution random number
4360        *             distribution.
4361        *
4362        * @returns The output stream with the state of @p __x inserted or in
4363        *          an error state.
4364        */
4365       template<typename _IntType1, typename _CharT, typename _Traits>
4366         friend std::basic_ostream<_CharT, _Traits>&
4367         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4368                    const std::negative_binomial_distribution<_IntType1>& __x);
4369
4370       /**
4371        * @brief Extracts a %negative_binomial_distribution random number
4372        *        distribution @p __x from the input stream @p __is.
4373        *
4374        * @param __is An input stream.
4375        * @param __x A %negative_binomial_distribution random number
4376        *            generator engine.
4377        *
4378        * @returns The input stream with @p __x extracted or in an error state.
4379        */
4380       template<typename _IntType1, typename _CharT, typename _Traits>
4381         friend std::basic_istream<_CharT, _Traits>&
4382         operator>>(std::basic_istream<_CharT, _Traits>& __is,
4383                    std::negative_binomial_distribution<_IntType1>& __x);
4384
4385     private:
4386       template<typename _ForwardIterator,
4387                typename _UniformRandomNumberGenerator>
4388         void
4389         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4390                         _UniformRandomNumberGenerator& __urng);
4391       template<typename _ForwardIterator,
4392                typename _UniformRandomNumberGenerator>
4393         void
4394         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4395                         _UniformRandomNumberGenerator& __urng,
4396                         const param_type& __p);
4397
4398       param_type _M_param;
4399
4400       std::gamma_distribution<double> _M_gd;
4401     };
4402
4403   /**
4404    * @brief Return true if two negative binomial distributions are different.
4405    */
4406   template<typename _IntType>
4407     inline bool
4408     operator!=(const std::negative_binomial_distribution<_IntType>& __d1,
4409                const std::negative_binomial_distribution<_IntType>& __d2)
4410     { return !(__d1 == __d2); }
4411
4412
4413   /* @} */ // group random_distributions_bernoulli
4414
4415   /**
4416    * @addtogroup random_distributions_poisson Poisson Distributions
4417    * @ingroup random_distributions
4418    * @{
4419    */
4420
4421   /**
4422    * @brief A discrete Poisson random number distribution.
4423    *
4424    * The formula for the Poisson probability density function is
4425    * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the
4426    * parameter of the distribution.
4427    */
4428   template<typename _IntType = int>
4429     class poisson_distribution
4430     {
4431       static_assert(std::is_integral<_IntType>::value,
4432                     "template argument not an integral type");
4433
4434     public:
4435       /** The type of the range of the distribution. */
4436       typedef _IntType  result_type;
4437       /** Parameter type. */
4438       struct param_type
4439       {
4440         typedef poisson_distribution<_IntType> distribution_type;
4441         friend class poisson_distribution<_IntType>;
4442
4443         explicit
4444         param_type(double __mean = 1.0)
4445         : _M_mean(__mean)
4446         {
4447           _GLIBCXX_DEBUG_ASSERT(_M_mean > 0.0);
4448           _M_initialize();
4449         }
4450
4451         double
4452         mean() const
4453         { return _M_mean; }
4454
4455         friend bool
4456         operator==(const param_type& __p1, const param_type& __p2)
4457         { return __p1._M_mean == __p2._M_mean; }
4458
4459       private:
4460         // Hosts either log(mean) or the threshold of the simple method.
4461         void
4462         _M_initialize();
4463
4464         double _M_mean;
4465
4466         double _M_lm_thr;
4467 #if _GLIBCXX_USE_C99_MATH_TR1
4468         double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb;
4469 #endif
4470       };
4471
4472       // constructors and member function
4473       explicit
4474       poisson_distribution(double __mean = 1.0)
4475       : _M_param(__mean), _M_nd()
4476       { }
4477
4478       explicit
4479       poisson_distribution(const param_type& __p)
4480       : _M_param(__p), _M_nd()
4481       { }
4482
4483       /**
4484        * @brief Resets the distribution state.
4485        */
4486       void
4487       reset()
4488       { _M_nd.reset(); }
4489
4490       /**
4491        * @brief Returns the distribution parameter @p mean.
4492        */
4493       double
4494       mean() const
4495       { return _M_param.mean(); }
4496
4497       /**
4498        * @brief Returns the parameter set of the distribution.
4499        */
4500       param_type
4501       param() const
4502       { return _M_param; }
4503
4504       /**
4505        * @brief Sets the parameter set of the distribution.
4506        * @param __param The new parameter set of the distribution.
4507        */
4508       void
4509       param(const param_type& __param)
4510       { _M_param = __param; }
4511
4512       /**
4513        * @brief Returns the greatest lower bound value of the distribution.
4514        */
4515       result_type
4516       min() const
4517       { return 0; }
4518
4519       /**
4520        * @brief Returns the least upper bound value of the distribution.
4521        */
4522       result_type
4523       max() const
4524       { return std::numeric_limits<result_type>::max(); }
4525
4526       /**
4527        * @brief Generating functions.
4528        */
4529       template<typename _UniformRandomNumberGenerator>
4530         result_type
4531         operator()(_UniformRandomNumberGenerator& __urng)
4532         { return this->operator()(__urng, _M_param); }
4533
4534       template<typename _UniformRandomNumberGenerator>
4535         result_type
4536         operator()(_UniformRandomNumberGenerator& __urng,
4537                    const param_type& __p);
4538
4539       template<typename _ForwardIterator,
4540                typename _UniformRandomNumberGenerator>
4541         void
4542         __generate(_ForwardIterator __f, _ForwardIterator __t,
4543                    _UniformRandomNumberGenerator& __urng)
4544         { this->__generate(__f, __t, __urng, _M_param); }
4545
4546       template<typename _ForwardIterator,
4547                typename _UniformRandomNumberGenerator>
4548         void
4549         __generate(_ForwardIterator __f, _ForwardIterator __t,
4550                    _UniformRandomNumberGenerator& __urng,
4551                    const param_type& __p)
4552         { this->__generate_impl(__f, __t, __urng, __p); }
4553
4554       template<typename _UniformRandomNumberGenerator>
4555         void
4556         __generate(result_type* __f, result_type* __t,
4557                    _UniformRandomNumberGenerator& __urng,
4558                    const param_type& __p)
4559         { this->__generate_impl(__f, __t, __urng, __p); }
4560
4561        /**
4562         * @brief Return true if two Poisson distributions have the same
4563         *        parameters and the sequences that would be generated
4564         *        are equal.
4565         */
4566       friend bool
4567       operator==(const poisson_distribution& __d1,
4568                  const poisson_distribution& __d2)
4569 #ifdef _GLIBCXX_USE_C99_MATH_TR1
4570       { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; }
4571 #else
4572       { return __d1._M_param == __d2._M_param; }
4573 #endif
4574
4575       /**
4576        * @brief Inserts a %poisson_distribution random number distribution
4577        * @p __x into the output stream @p __os.
4578        *
4579        * @param __os An output stream.
4580        * @param __x  A %poisson_distribution random number distribution.
4581        *
4582        * @returns The output stream with the state of @p __x inserted or in
4583        * an error state.
4584        */
4585       template<typename _IntType1, typename _CharT, typename _Traits>
4586         friend std::basic_ostream<_CharT, _Traits>&
4587         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4588                    const std::poisson_distribution<_IntType1>& __x);
4589
4590       /**
4591        * @brief Extracts a %poisson_distribution random number distribution
4592        * @p __x from the input stream @p __is.
4593        *
4594        * @param __is An input stream.
4595        * @param __x  A %poisson_distribution random number generator engine.
4596        *
4597        * @returns The input stream with @p __x extracted or in an error
4598        *          state.
4599        */
4600       template<typename _IntType1, typename _CharT, typename _Traits>
4601         friend std::basic_istream<_CharT, _Traits>&
4602         operator>>(std::basic_istream<_CharT, _Traits>& __is,
4603                    std::poisson_distribution<_IntType1>& __x);
4604
4605     private:
4606       template<typename _ForwardIterator,
4607                typename _UniformRandomNumberGenerator>
4608         void
4609         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4610                         _UniformRandomNumberGenerator& __urng,
4611                         const param_type& __p);
4612
4613       param_type _M_param;
4614
4615       // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined.
4616       std::normal_distribution<double> _M_nd;
4617     };
4618
4619   /**
4620    * @brief Return true if two Poisson distributions are different.
4621    */
4622   template<typename _IntType>
4623     inline bool
4624     operator!=(const std::poisson_distribution<_IntType>& __d1,
4625                const std::poisson_distribution<_IntType>& __d2)
4626     { return !(__d1 == __d2); }
4627
4628
4629   /**
4630    * @brief An exponential continuous distribution for random numbers.
4631    *
4632    * The formula for the exponential probability density function is
4633    * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$.
4634    *
4635    * <table border=1 cellpadding=10 cellspacing=0>
4636    * <caption align=top>Distribution Statistics</caption>
4637    * <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4638    * <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr>
4639    * <tr><td>Mode</td><td>@f$zero@f$</td></tr>
4640    * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr>
4641    * <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr>
4642    * </table>
4643    */
4644   template<typename _RealType = double>
4645     class exponential_distribution
4646     {
4647       static_assert(std::is_floating_point<_RealType>::value,
4648                     "template argument not a floating point type");
4649
4650     public:
4651       /** The type of the range of the distribution. */
4652       typedef _RealType result_type;
4653       /** Parameter type. */
4654       struct param_type
4655       {
4656         typedef exponential_distribution<_RealType> distribution_type;
4657
4658         explicit
4659         param_type(_RealType __lambda = _RealType(1))
4660         : _M_lambda(__lambda)
4661         {
4662           _GLIBCXX_DEBUG_ASSERT(_M_lambda > _RealType(0));
4663         }
4664
4665         _RealType
4666         lambda() const
4667         { return _M_lambda; }
4668
4669         friend bool
4670         operator==(const param_type& __p1, const param_type& __p2)
4671         { return __p1._M_lambda == __p2._M_lambda; }
4672
4673       private:
4674         _RealType _M_lambda;
4675       };
4676
4677     public:
4678       /**
4679        * @brief Constructs an exponential distribution with inverse scale
4680        *        parameter @f$\lambda@f$.
4681        */
4682       explicit
4683       exponential_distribution(const result_type& __lambda = result_type(1))
4684       : _M_param(__lambda)
4685       { }
4686
4687       explicit
4688       exponential_distribution(const param_type& __p)
4689       : _M_param(__p)
4690       { }
4691
4692       /**
4693        * @brief Resets the distribution state.
4694        *
4695        * Has no effect on exponential distributions.
4696        */
4697       void
4698       reset() { }
4699
4700       /**
4701        * @brief Returns the inverse scale parameter of the distribution.
4702        */
4703       _RealType
4704       lambda() const
4705       { return _M_param.lambda(); }
4706
4707       /**
4708        * @brief Returns the parameter set of the distribution.
4709        */
4710       param_type
4711       param() const
4712       { return _M_param; }
4713
4714       /**
4715        * @brief Sets the parameter set of the distribution.
4716        * @param __param The new parameter set of the distribution.
4717        */
4718       void
4719       param(const param_type& __param)
4720       { _M_param = __param; }
4721
4722       /**
4723        * @brief Returns the greatest lower bound value of the distribution.
4724        */
4725       result_type
4726       min() const
4727       { return result_type(0); }
4728
4729       /**
4730        * @brief Returns the least upper bound value of the distribution.
4731        */
4732       result_type
4733       max() const
4734       { return std::numeric_limits<result_type>::max(); }
4735
4736       /**
4737        * @brief Generating functions.
4738        */
4739       template<typename _UniformRandomNumberGenerator>
4740         result_type
4741         operator()(_UniformRandomNumberGenerator& __urng)
4742         { return this->operator()(__urng, _M_param); }
4743
4744       template<typename _UniformRandomNumberGenerator>
4745         result_type
4746         operator()(_UniformRandomNumberGenerator& __urng,
4747                    const param_type& __p)
4748         {
4749           __detail::_Adaptor<_UniformRandomNumberGenerator, result_type>
4750             __aurng(__urng);
4751           return -std::log(result_type(1) - __aurng()) / __p.lambda();
4752         }
4753
4754       template<typename _ForwardIterator,
4755                typename _UniformRandomNumberGenerator>
4756         void
4757         __generate(_ForwardIterator __f, _ForwardIterator __t,
4758                    _UniformRandomNumberGenerator& __urng)
4759         { this->__generate(__f, __t, __urng, _M_param); }
4760
4761       template<typename _ForwardIterator,
4762                typename _UniformRandomNumberGenerator>
4763         void
4764         __generate(_ForwardIterator __f, _ForwardIterator __t,
4765                    _UniformRandomNumberGenerator& __urng,
4766                    const param_type& __p)
4767         { this->__generate_impl(__f, __t, __urng, __p); }
4768
4769       template<typename _UniformRandomNumberGenerator>
4770         void
4771         __generate(result_type* __f, result_type* __t,
4772                    _UniformRandomNumberGenerator& __urng,
4773                    const param_type& __p)
4774         { this->__generate_impl(__f, __t, __urng, __p); }
4775
4776       /**
4777        * @brief Return true if two exponential distributions have the same
4778        *        parameters.
4779        */
4780       friend bool
4781       operator==(const exponential_distribution& __d1,
4782                  const exponential_distribution& __d2)
4783       { return __d1._M_param == __d2._M_param; }
4784
4785     private:
4786       template<typename _ForwardIterator,
4787                typename _UniformRandomNumberGenerator>
4788         void
4789         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4790                         _UniformRandomNumberGenerator& __urng,
4791                         const param_type& __p);
4792
4793       param_type _M_param;
4794     };
4795
4796   /**
4797    * @brief Return true if two exponential distributions have different
4798    *        parameters.
4799    */
4800   template<typename _RealType>
4801     inline bool
4802     operator!=(const std::exponential_distribution<_RealType>& __d1,
4803                const std::exponential_distribution<_RealType>& __d2)
4804     { return !(__d1 == __d2); }
4805
4806   /**
4807    * @brief Inserts a %exponential_distribution random number distribution
4808    * @p __x into the output stream @p __os.
4809    *
4810    * @param __os An output stream.
4811    * @param __x  A %exponential_distribution random number distribution.
4812    *
4813    * @returns The output stream with the state of @p __x inserted or in
4814    * an error state.
4815    */
4816   template<typename _RealType, typename _CharT, typename _Traits>
4817     std::basic_ostream<_CharT, _Traits>&
4818     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
4819                const std::exponential_distribution<_RealType>& __x);
4820
4821   /**
4822    * @brief Extracts a %exponential_distribution random number distribution
4823    * @p __x from the input stream @p __is.
4824    *
4825    * @param __is An input stream.
4826    * @param __x A %exponential_distribution random number
4827    *            generator engine.
4828    *
4829    * @returns The input stream with @p __x extracted or in an error state.
4830    */
4831   template<typename _RealType, typename _CharT, typename _Traits>
4832     std::basic_istream<_CharT, _Traits>&
4833     operator>>(std::basic_istream<_CharT, _Traits>& __is,
4834                std::exponential_distribution<_RealType>& __x);
4835
4836
4837   /**
4838    * @brief A weibull_distribution random number distribution.
4839    *
4840    * The formula for the normal probability density function is:
4841    * @f[
4842    *     p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1}
4843    *                         \exp{(-(\frac{x}{\beta})^\alpha)}
4844    * @f]
4845    */
4846   template<typename _RealType = double>
4847     class weibull_distribution
4848     {
4849       static_assert(std::is_floating_point<_RealType>::value,
4850                     "template argument not a floating point type");
4851
4852     public:
4853       /** The type of the range of the distribution. */
4854       typedef _RealType result_type;
4855       /** Parameter type. */
4856       struct param_type
4857       {
4858         typedef weibull_distribution<_RealType> distribution_type;
4859
4860         explicit
4861         param_type(_RealType __a = _RealType(1),
4862                    _RealType __b = _RealType(1))
4863         : _M_a(__a), _M_b(__b)
4864         { }
4865
4866         _RealType
4867         a() const
4868         { return _M_a; }
4869
4870         _RealType
4871         b() const
4872         { return _M_b; }
4873
4874         friend bool
4875         operator==(const param_type& __p1, const param_type& __p2)
4876         { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
4877
4878       private:
4879         _RealType _M_a;
4880         _RealType _M_b;
4881       };
4882
4883       explicit
4884       weibull_distribution(_RealType __a = _RealType(1),
4885                            _RealType __b = _RealType(1))
4886       : _M_param(__a, __b)
4887       { }
4888
4889       explicit
4890       weibull_distribution(const param_type& __p)
4891       : _M_param(__p)
4892       { }
4893
4894       /**
4895        * @brief Resets the distribution state.
4896        */
4897       void
4898       reset()
4899       { }
4900
4901       /**
4902        * @brief Return the @f$a@f$ parameter of the distribution.
4903        */
4904       _RealType
4905       a() const
4906       { return _M_param.a(); }
4907
4908       /**
4909        * @brief Return the @f$b@f$ parameter of the distribution.
4910        */
4911       _RealType
4912       b() const
4913       { return _M_param.b(); }
4914
4915       /**
4916        * @brief Returns the parameter set of the distribution.
4917        */
4918       param_type
4919       param() const
4920       { return _M_param; }
4921
4922       /**
4923        * @brief Sets the parameter set of the distribution.
4924        * @param __param The new parameter set of the distribution.
4925        */
4926       void
4927       param(const param_type& __param)
4928       { _M_param = __param; }
4929
4930       /**
4931        * @brief Returns the greatest lower bound value of the distribution.
4932        */
4933       result_type
4934       min() const
4935       { return result_type(0); }
4936
4937       /**
4938        * @brief Returns the least upper bound value of the distribution.
4939        */
4940       result_type
4941       max() const
4942       { return std::numeric_limits<result_type>::max(); }
4943
4944       /**
4945        * @brief Generating functions.
4946        */
4947       template<typename _UniformRandomNumberGenerator>
4948         result_type
4949         operator()(_UniformRandomNumberGenerator& __urng)
4950         { return this->operator()(__urng, _M_param); }
4951
4952       template<typename _UniformRandomNumberGenerator>
4953         result_type
4954         operator()(_UniformRandomNumberGenerator& __urng,
4955                    const param_type& __p);
4956
4957       template<typename _ForwardIterator,
4958                typename _UniformRandomNumberGenerator>
4959         void
4960         __generate(_ForwardIterator __f, _ForwardIterator __t,
4961                    _UniformRandomNumberGenerator& __urng)
4962         { this->__generate(__f, __t, __urng, _M_param); }
4963
4964       template<typename _ForwardIterator,
4965                typename _UniformRandomNumberGenerator>
4966         void
4967         __generate(_ForwardIterator __f, _ForwardIterator __t,
4968                    _UniformRandomNumberGenerator& __urng,
4969                    const param_type& __p)
4970         { this->__generate_impl(__f, __t, __urng, __p); }
4971
4972       template<typename _UniformRandomNumberGenerator>
4973         void
4974         __generate(result_type* __f, result_type* __t,
4975                    _UniformRandomNumberGenerator& __urng,
4976                    const param_type& __p)
4977         { this->__generate_impl(__f, __t, __urng, __p); }
4978
4979       /**
4980        * @brief Return true if two Weibull distributions have the same
4981        *        parameters.
4982        */
4983       friend bool
4984       operator==(const weibull_distribution& __d1,
4985                  const weibull_distribution& __d2)
4986       { return __d1._M_param == __d2._M_param; }
4987
4988     private:
4989       template<typename _ForwardIterator,
4990                typename _UniformRandomNumberGenerator>
4991         void
4992         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
4993                         _UniformRandomNumberGenerator& __urng,
4994                         const param_type& __p);
4995
4996       param_type _M_param;
4997     };
4998
4999    /**
5000     * @brief Return true if two Weibull distributions have different
5001     *        parameters.
5002     */
5003   template<typename _RealType>
5004     inline bool
5005     operator!=(const std::weibull_distribution<_RealType>& __d1,
5006                const std::weibull_distribution<_RealType>& __d2)
5007     { return !(__d1 == __d2); }
5008
5009   /**
5010    * @brief Inserts a %weibull_distribution random number distribution
5011    * @p __x into the output stream @p __os.
5012    *
5013    * @param __os An output stream.
5014    * @param __x  A %weibull_distribution random number distribution.
5015    *
5016    * @returns The output stream with the state of @p __x inserted or in
5017    * an error state.
5018    */
5019   template<typename _RealType, typename _CharT, typename _Traits>
5020     std::basic_ostream<_CharT, _Traits>&
5021     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5022                const std::weibull_distribution<_RealType>& __x);
5023
5024   /**
5025    * @brief Extracts a %weibull_distribution random number distribution
5026    * @p __x from the input stream @p __is.
5027    *
5028    * @param __is An input stream.
5029    * @param __x A %weibull_distribution random number
5030    *            generator engine.
5031    *
5032    * @returns The input stream with @p __x extracted or in an error state.
5033    */
5034   template<typename _RealType, typename _CharT, typename _Traits>
5035     std::basic_istream<_CharT, _Traits>&
5036     operator>>(std::basic_istream<_CharT, _Traits>& __is,
5037                std::weibull_distribution<_RealType>& __x);
5038
5039
5040   /**
5041    * @brief A extreme_value_distribution random number distribution.
5042    *
5043    * The formula for the normal probability mass function is
5044    * @f[
5045    *     p(x|a,b) = \frac{1}{b}
5046    *                \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b}))
5047    * @f]
5048    */
5049   template<typename _RealType = double>
5050     class extreme_value_distribution
5051     {
5052       static_assert(std::is_floating_point<_RealType>::value,
5053                     "template argument not a floating point type");
5054
5055     public:
5056       /** The type of the range of the distribution. */
5057       typedef _RealType result_type;
5058       /** Parameter type. */
5059       struct param_type
5060       {
5061         typedef extreme_value_distribution<_RealType> distribution_type;
5062
5063         explicit
5064         param_type(_RealType __a = _RealType(0),
5065                    _RealType __b = _RealType(1))
5066         : _M_a(__a), _M_b(__b)
5067         { }
5068
5069         _RealType
5070         a() const
5071         { return _M_a; }
5072
5073         _RealType
5074         b() const
5075         { return _M_b; }
5076
5077         friend bool
5078         operator==(const param_type& __p1, const param_type& __p2)
5079         { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; }
5080
5081       private:
5082         _RealType _M_a;
5083         _RealType _M_b;
5084       };
5085
5086       explicit
5087       extreme_value_distribution(_RealType __a = _RealType(0),
5088                                  _RealType __b = _RealType(1))
5089       : _M_param(__a, __b)
5090       { }
5091
5092       explicit
5093       extreme_value_distribution(const param_type& __p)
5094       : _M_param(__p)
5095       { }
5096
5097       /**
5098        * @brief Resets the distribution state.
5099        */
5100       void
5101       reset()
5102       { }
5103
5104       /**
5105        * @brief Return the @f$a@f$ parameter of the distribution.
5106        */
5107       _RealType
5108       a() const
5109       { return _M_param.a(); }
5110
5111       /**
5112        * @brief Return the @f$b@f$ parameter of the distribution.
5113        */
5114       _RealType
5115       b() const
5116       { return _M_param.b(); }
5117
5118       /**
5119        * @brief Returns the parameter set of the distribution.
5120        */
5121       param_type
5122       param() const
5123       { return _M_param; }
5124
5125       /**
5126        * @brief Sets the parameter set of the distribution.
5127        * @param __param The new parameter set of the distribution.
5128        */
5129       void
5130       param(const param_type& __param)
5131       { _M_param = __param; }
5132
5133       /**
5134        * @brief Returns the greatest lower bound value of the distribution.
5135        */
5136       result_type
5137       min() const
5138       { return std::numeric_limits<result_type>::min(); }
5139
5140       /**
5141        * @brief Returns the least upper bound value of the distribution.
5142        */
5143       result_type
5144       max() const
5145       { return std::numeric_limits<result_type>::max(); }
5146
5147       /**
5148        * @brief Generating functions.
5149        */
5150       template<typename _UniformRandomNumberGenerator>
5151         result_type
5152         operator()(_UniformRandomNumberGenerator& __urng)
5153         { return this->operator()(__urng, _M_param); }
5154
5155       template<typename _UniformRandomNumberGenerator>
5156         result_type
5157         operator()(_UniformRandomNumberGenerator& __urng,
5158                    const param_type& __p);
5159
5160       template<typename _ForwardIterator,
5161                typename _UniformRandomNumberGenerator>
5162         void
5163         __generate(_ForwardIterator __f, _ForwardIterator __t,
5164                    _UniformRandomNumberGenerator& __urng)
5165         { this->__generate(__f, __t, __urng, _M_param); }
5166
5167       template<typename _ForwardIterator,
5168                typename _UniformRandomNumberGenerator>
5169         void
5170         __generate(_ForwardIterator __f, _ForwardIterator __t,
5171                    _UniformRandomNumberGenerator& __urng,
5172                    const param_type& __p)
5173         { this->__generate_impl(__f, __t, __urng, __p); }
5174
5175       template<typename _UniformRandomNumberGenerator>
5176         void
5177         __generate(result_type* __f, result_type* __t,
5178                    _UniformRandomNumberGenerator& __urng,
5179                    const param_type& __p)
5180         { this->__generate_impl(__f, __t, __urng, __p); }
5181
5182       /**
5183        * @brief Return true if two extreme value distributions have the same
5184        *        parameters.
5185        */
5186       friend bool
5187       operator==(const extreme_value_distribution& __d1,
5188                  const extreme_value_distribution& __d2)
5189       { return __d1._M_param == __d2._M_param; }
5190
5191     private:
5192       template<typename _ForwardIterator,
5193                typename _UniformRandomNumberGenerator>
5194         void
5195         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5196                         _UniformRandomNumberGenerator& __urng,
5197                         const param_type& __p);
5198
5199       param_type _M_param;
5200     };
5201
5202   /**
5203     * @brief Return true if two extreme value distributions have different
5204     *        parameters.
5205    */
5206   template<typename _RealType>
5207     inline bool
5208     operator!=(const std::extreme_value_distribution<_RealType>& __d1,
5209                const std::extreme_value_distribution<_RealType>& __d2)
5210     { return !(__d1 == __d2); }
5211
5212   /**
5213    * @brief Inserts a %extreme_value_distribution random number distribution
5214    * @p __x into the output stream @p __os.
5215    *
5216    * @param __os An output stream.
5217    * @param __x  A %extreme_value_distribution random number distribution.
5218    *
5219    * @returns The output stream with the state of @p __x inserted or in
5220    * an error state.
5221    */
5222   template<typename _RealType, typename _CharT, typename _Traits>
5223     std::basic_ostream<_CharT, _Traits>&
5224     operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5225                const std::extreme_value_distribution<_RealType>& __x);
5226
5227   /**
5228    * @brief Extracts a %extreme_value_distribution random number
5229    *        distribution @p __x from the input stream @p __is.
5230    *
5231    * @param __is An input stream.
5232    * @param __x A %extreme_value_distribution random number
5233    *            generator engine.
5234    *
5235    * @returns The input stream with @p __x extracted or in an error state.
5236    */
5237   template<typename _RealType, typename _CharT, typename _Traits>
5238     std::basic_istream<_CharT, _Traits>&
5239     operator>>(std::basic_istream<_CharT, _Traits>& __is,
5240                std::extreme_value_distribution<_RealType>& __x);
5241
5242
5243   /**
5244    * @brief A discrete_distribution random number distribution.
5245    *
5246    * The formula for the discrete probability mass function is
5247    *
5248    */
5249   template<typename _IntType = int>
5250     class discrete_distribution
5251     {
5252       static_assert(std::is_integral<_IntType>::value,
5253                     "template argument not an integral type");
5254
5255     public:
5256       /** The type of the range of the distribution. */
5257       typedef _IntType result_type;
5258       /** Parameter type. */
5259       struct param_type
5260       {
5261         typedef discrete_distribution<_IntType> distribution_type;
5262         friend class discrete_distribution<_IntType>;
5263
5264         param_type()
5265         : _M_prob(), _M_cp()
5266         { }
5267
5268         template<typename _InputIterator>
5269           param_type(_InputIterator __wbegin,
5270                      _InputIterator __wend)
5271           : _M_prob(__wbegin, __wend), _M_cp()
5272           { _M_initialize(); }
5273
5274         param_type(initializer_list<double> __wil)
5275         : _M_prob(__wil.begin(), __wil.end()), _M_cp()
5276         { _M_initialize(); }
5277
5278         template<typename _Func>
5279           param_type(size_t __nw, double __xmin, double __xmax,
5280                      _Func __fw);
5281
5282         // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5283         param_type(const param_type&) = default;
5284         param_type& operator=(const param_type&) = default;
5285
5286         std::vector<double>
5287         probabilities() const
5288         { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; }
5289
5290         friend bool
5291         operator==(const param_type& __p1, const param_type& __p2)
5292         { return __p1._M_prob == __p2._M_prob; }
5293
5294       private:
5295         void
5296         _M_initialize();
5297
5298         std::vector<double> _M_prob;
5299         std::vector<double> _M_cp;
5300       };
5301
5302       discrete_distribution()
5303       : _M_param()
5304       { }
5305
5306       template<typename _InputIterator>
5307         discrete_distribution(_InputIterator __wbegin,
5308                               _InputIterator __wend)
5309         : _M_param(__wbegin, __wend)
5310         { }
5311
5312       discrete_distribution(initializer_list<double> __wl)
5313       : _M_param(__wl)
5314       { }
5315
5316       template<typename _Func>
5317         discrete_distribution(size_t __nw, double __xmin, double __xmax,
5318                               _Func __fw)
5319         : _M_param(__nw, __xmin, __xmax, __fw)
5320         { }
5321
5322       explicit
5323       discrete_distribution(const param_type& __p)
5324       : _M_param(__p)
5325       { }
5326
5327       /**
5328        * @brief Resets the distribution state.
5329        */
5330       void
5331       reset()
5332       { }
5333
5334       /**
5335        * @brief Returns the probabilities of the distribution.
5336        */
5337       std::vector<double>
5338       probabilities() const
5339       {
5340         return _M_param._M_prob.empty()
5341           ? std::vector<double>(1, 1.0) : _M_param._M_prob;
5342       }
5343
5344       /**
5345        * @brief Returns the parameter set of the distribution.
5346        */
5347       param_type
5348       param() const
5349       { return _M_param; }
5350
5351       /**
5352        * @brief Sets the parameter set of the distribution.
5353        * @param __param The new parameter set of the distribution.
5354        */
5355       void
5356       param(const param_type& __param)
5357       { _M_param = __param; }
5358
5359       /**
5360        * @brief Returns the greatest lower bound value of the distribution.
5361        */
5362       result_type
5363       min() const
5364       { return result_type(0); }
5365
5366       /**
5367        * @brief Returns the least upper bound value of the distribution.
5368        */
5369       result_type
5370       max() const
5371       {
5372         return _M_param._M_prob.empty()
5373           ? result_type(0) : result_type(_M_param._M_prob.size() - 1);
5374       }
5375
5376       /**
5377        * @brief Generating functions.
5378        */
5379       template<typename _UniformRandomNumberGenerator>
5380         result_type
5381         operator()(_UniformRandomNumberGenerator& __urng)
5382         { return this->operator()(__urng, _M_param); }
5383
5384       template<typename _UniformRandomNumberGenerator>
5385         result_type
5386         operator()(_UniformRandomNumberGenerator& __urng,
5387                    const param_type& __p);
5388
5389       template<typename _ForwardIterator,
5390                typename _UniformRandomNumberGenerator>
5391         void
5392         __generate(_ForwardIterator __f, _ForwardIterator __t,
5393                    _UniformRandomNumberGenerator& __urng)
5394         { this->__generate(__f, __t, __urng, _M_param); }
5395
5396       template<typename _ForwardIterator,
5397                typename _UniformRandomNumberGenerator>
5398         void
5399         __generate(_ForwardIterator __f, _ForwardIterator __t,
5400                    _UniformRandomNumberGenerator& __urng,
5401                    const param_type& __p)
5402         { this->__generate_impl(__f, __t, __urng, __p); }
5403
5404       template<typename _UniformRandomNumberGenerator>
5405         void
5406         __generate(result_type* __f, result_type* __t,
5407                    _UniformRandomNumberGenerator& __urng,
5408                    const param_type& __p)
5409         { this->__generate_impl(__f, __t, __urng, __p); }
5410
5411       /**
5412        * @brief Return true if two discrete distributions have the same
5413        *        parameters.
5414        */
5415       friend bool
5416       operator==(const discrete_distribution& __d1,
5417                  const discrete_distribution& __d2)
5418       { return __d1._M_param == __d2._M_param; }
5419
5420       /**
5421        * @brief Inserts a %discrete_distribution random number distribution
5422        * @p __x into the output stream @p __os.
5423        *
5424        * @param __os An output stream.
5425        * @param __x  A %discrete_distribution random number distribution.
5426        *
5427        * @returns The output stream with the state of @p __x inserted or in
5428        * an error state.
5429        */
5430       template<typename _IntType1, typename _CharT, typename _Traits>
5431         friend std::basic_ostream<_CharT, _Traits>&
5432         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5433                    const std::discrete_distribution<_IntType1>& __x);
5434
5435       /**
5436        * @brief Extracts a %discrete_distribution random number distribution
5437        * @p __x from the input stream @p __is.
5438        *
5439        * @param __is An input stream.
5440        * @param __x A %discrete_distribution random number
5441        *            generator engine.
5442        *
5443        * @returns The input stream with @p __x extracted or in an error
5444        *          state.
5445        */
5446       template<typename _IntType1, typename _CharT, typename _Traits>
5447         friend std::basic_istream<_CharT, _Traits>&
5448         operator>>(std::basic_istream<_CharT, _Traits>& __is,
5449                    std::discrete_distribution<_IntType1>& __x);
5450
5451     private:
5452       template<typename _ForwardIterator,
5453                typename _UniformRandomNumberGenerator>
5454         void
5455         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5456                         _UniformRandomNumberGenerator& __urng,
5457                         const param_type& __p);
5458
5459       param_type _M_param;
5460     };
5461
5462   /**
5463     * @brief Return true if two discrete distributions have different
5464     *        parameters.
5465     */
5466   template<typename _IntType>
5467     inline bool
5468     operator!=(const std::discrete_distribution<_IntType>& __d1,
5469                const std::discrete_distribution<_IntType>& __d2)
5470     { return !(__d1 == __d2); }
5471
5472
5473   /**
5474    * @brief A piecewise_constant_distribution random number distribution.
5475    *
5476    * The formula for the piecewise constant probability mass function is
5477    *
5478    */
5479   template<typename _RealType = double>
5480     class piecewise_constant_distribution
5481     {
5482       static_assert(std::is_floating_point<_RealType>::value,
5483                     "template argument not a floating point type");
5484
5485     public:
5486       /** The type of the range of the distribution. */
5487       typedef _RealType result_type;
5488       /** Parameter type. */
5489       struct param_type
5490       {
5491         typedef piecewise_constant_distribution<_RealType> distribution_type;
5492         friend class piecewise_constant_distribution<_RealType>;
5493
5494         param_type()
5495         : _M_int(), _M_den(), _M_cp()
5496         { }
5497
5498         template<typename _InputIteratorB, typename _InputIteratorW>
5499           param_type(_InputIteratorB __bfirst,
5500                      _InputIteratorB __bend,
5501                      _InputIteratorW __wbegin);
5502
5503         template<typename _Func>
5504           param_type(initializer_list<_RealType> __bi, _Func __fw);
5505
5506         template<typename _Func>
5507           param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
5508                      _Func __fw);
5509
5510         // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5511         param_type(const param_type&) = default;
5512         param_type& operator=(const param_type&) = default;
5513
5514         std::vector<_RealType>
5515         intervals() const
5516         {
5517           if (_M_int.empty())
5518             {
5519               std::vector<_RealType> __tmp(2);
5520               __tmp[1] = _RealType(1);
5521               return __tmp;
5522             }
5523           else
5524             return _M_int;
5525         }
5526
5527         std::vector<double>
5528         densities() const
5529         { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; }
5530
5531         friend bool
5532         operator==(const param_type& __p1, const param_type& __p2)
5533         { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; }
5534
5535       private:
5536         void
5537         _M_initialize();
5538
5539         std::vector<_RealType> _M_int;
5540         std::vector<double> _M_den;
5541         std::vector<double> _M_cp;
5542       };
5543
5544       explicit
5545       piecewise_constant_distribution()
5546       : _M_param()
5547       { }
5548
5549       template<typename _InputIteratorB, typename _InputIteratorW>
5550         piecewise_constant_distribution(_InputIteratorB __bfirst,
5551                                         _InputIteratorB __bend,
5552                                         _InputIteratorW __wbegin)
5553         : _M_param(__bfirst, __bend, __wbegin)
5554         { }
5555
5556       template<typename _Func>
5557         piecewise_constant_distribution(initializer_list<_RealType> __bl,
5558                                         _Func __fw)
5559         : _M_param(__bl, __fw)
5560         { }
5561
5562       template<typename _Func>
5563         piecewise_constant_distribution(size_t __nw,
5564                                         _RealType __xmin, _RealType __xmax,
5565                                         _Func __fw)
5566         : _M_param(__nw, __xmin, __xmax, __fw)
5567         { }
5568
5569       explicit
5570       piecewise_constant_distribution(const param_type& __p)
5571       : _M_param(__p)
5572       { }
5573
5574       /**
5575        * @brief Resets the distribution state.
5576        */
5577       void
5578       reset()
5579       { }
5580
5581       /**
5582        * @brief Returns a vector of the intervals.
5583        */
5584       std::vector<_RealType>
5585       intervals() const
5586       {
5587         if (_M_param._M_int.empty())
5588           {
5589             std::vector<_RealType> __tmp(2);
5590             __tmp[1] = _RealType(1);
5591             return __tmp;
5592           }
5593         else
5594           return _M_param._M_int;
5595       }
5596
5597       /**
5598        * @brief Returns a vector of the probability densities.
5599        */
5600       std::vector<double>
5601       densities() const
5602       {
5603         return _M_param._M_den.empty()
5604           ? std::vector<double>(1, 1.0) : _M_param._M_den;
5605       }
5606
5607       /**
5608        * @brief Returns the parameter set of the distribution.
5609        */
5610       param_type
5611       param() const
5612       { return _M_param; }
5613
5614       /**
5615        * @brief Sets the parameter set of the distribution.
5616        * @param __param The new parameter set of the distribution.
5617        */
5618       void
5619       param(const param_type& __param)
5620       { _M_param = __param; }
5621
5622       /**
5623        * @brief Returns the greatest lower bound value of the distribution.
5624        */
5625       result_type
5626       min() const
5627       {
5628         return _M_param._M_int.empty()
5629           ? result_type(0) : _M_param._M_int.front();
5630       }
5631
5632       /**
5633        * @brief Returns the least upper bound value of the distribution.
5634        */
5635       result_type
5636       max() const
5637       {
5638         return _M_param._M_int.empty()
5639           ? result_type(1) : _M_param._M_int.back();
5640       }
5641
5642       /**
5643        * @brief Generating functions.
5644        */
5645       template<typename _UniformRandomNumberGenerator>
5646         result_type
5647         operator()(_UniformRandomNumberGenerator& __urng)
5648         { return this->operator()(__urng, _M_param); }
5649
5650       template<typename _UniformRandomNumberGenerator>
5651         result_type
5652         operator()(_UniformRandomNumberGenerator& __urng,
5653                    const param_type& __p);
5654
5655       template<typename _ForwardIterator,
5656                typename _UniformRandomNumberGenerator>
5657         void
5658         __generate(_ForwardIterator __f, _ForwardIterator __t,
5659                    _UniformRandomNumberGenerator& __urng)
5660         { this->__generate(__f, __t, __urng, _M_param); }
5661
5662       template<typename _ForwardIterator,
5663                typename _UniformRandomNumberGenerator>
5664         void
5665         __generate(_ForwardIterator __f, _ForwardIterator __t,
5666                    _UniformRandomNumberGenerator& __urng,
5667                    const param_type& __p)
5668         { this->__generate_impl(__f, __t, __urng, __p); }
5669
5670       template<typename _UniformRandomNumberGenerator>
5671         void
5672         __generate(result_type* __f, result_type* __t,
5673                    _UniformRandomNumberGenerator& __urng,
5674                    const param_type& __p)
5675         { this->__generate_impl(__f, __t, __urng, __p); }
5676
5677       /**
5678        * @brief Return true if two piecewise constant distributions have the
5679        *        same parameters.
5680        */
5681       friend bool
5682       operator==(const piecewise_constant_distribution& __d1,
5683                  const piecewise_constant_distribution& __d2)
5684       { return __d1._M_param == __d2._M_param; }
5685
5686       /**
5687        * @brief Inserts a %piecewise_constan_distribution random
5688        *        number distribution @p __x into the output stream @p __os.
5689        *
5690        * @param __os An output stream.
5691        * @param __x  A %piecewise_constan_distribution random number
5692        *             distribution.
5693        *
5694        * @returns The output stream with the state of @p __x inserted or in
5695        * an error state.
5696        */
5697       template<typename _RealType1, typename _CharT, typename _Traits>
5698         friend std::basic_ostream<_CharT, _Traits>&
5699         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5700                    const std::piecewise_constant_distribution<_RealType1>& __x);
5701
5702       /**
5703        * @brief Extracts a %piecewise_constan_distribution random
5704        *        number distribution @p __x from the input stream @p __is.
5705        *
5706        * @param __is An input stream.
5707        * @param __x A %piecewise_constan_distribution random number
5708        *            generator engine.
5709        *
5710        * @returns The input stream with @p __x extracted or in an error
5711        *          state.
5712        */
5713       template<typename _RealType1, typename _CharT, typename _Traits>
5714         friend std::basic_istream<_CharT, _Traits>&
5715         operator>>(std::basic_istream<_CharT, _Traits>& __is,
5716                    std::piecewise_constant_distribution<_RealType1>& __x);
5717
5718     private:
5719       template<typename _ForwardIterator,
5720                typename _UniformRandomNumberGenerator>
5721         void
5722         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5723                         _UniformRandomNumberGenerator& __urng,
5724                         const param_type& __p);
5725
5726       param_type _M_param;
5727     };
5728
5729   /**
5730     * @brief Return true if two piecewise constant distributions have
5731     *        different parameters.
5732    */
5733   template<typename _RealType>
5734     inline bool
5735     operator!=(const std::piecewise_constant_distribution<_RealType>& __d1,
5736                const std::piecewise_constant_distribution<_RealType>& __d2)
5737     { return !(__d1 == __d2); }
5738
5739
5740   /**
5741    * @brief A piecewise_linear_distribution random number distribution.
5742    *
5743    * The formula for the piecewise linear probability mass function is
5744    *
5745    */
5746   template<typename _RealType = double>
5747     class piecewise_linear_distribution
5748     {
5749       static_assert(std::is_floating_point<_RealType>::value,
5750                     "template argument not a floating point type");
5751
5752     public:
5753       /** The type of the range of the distribution. */
5754       typedef _RealType result_type;
5755       /** Parameter type. */
5756       struct param_type
5757       {
5758         typedef piecewise_linear_distribution<_RealType> distribution_type;
5759         friend class piecewise_linear_distribution<_RealType>;
5760
5761         param_type()
5762         : _M_int(), _M_den(), _M_cp(), _M_m()
5763         { }
5764
5765         template<typename _InputIteratorB, typename _InputIteratorW>
5766           param_type(_InputIteratorB __bfirst,
5767                      _InputIteratorB __bend,
5768                      _InputIteratorW __wbegin);
5769
5770         template<typename _Func>
5771           param_type(initializer_list<_RealType> __bl, _Func __fw);
5772
5773         template<typename _Func>
5774           param_type(size_t __nw, _RealType __xmin, _RealType __xmax,
5775                      _Func __fw);
5776
5777         // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/
5778         param_type(const param_type&) = default;
5779         param_type& operator=(const param_type&) = default;
5780
5781         std::vector<_RealType>
5782         intervals() const
5783         {
5784           if (_M_int.empty())
5785             {
5786               std::vector<_RealType> __tmp(2);
5787               __tmp[1] = _RealType(1);
5788               return __tmp;
5789             }
5790           else
5791             return _M_int;
5792         }
5793
5794         std::vector<double>
5795         densities() const
5796         { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; }
5797
5798         friend bool
5799         operator==(const param_type& __p1, const param_type& __p2)
5800         { return (__p1._M_int == __p2._M_int
5801                   && __p1._M_den == __p2._M_den); }
5802
5803       private:
5804         void
5805         _M_initialize();
5806
5807         std::vector<_RealType> _M_int;
5808         std::vector<double> _M_den;
5809         std::vector<double> _M_cp;
5810         std::vector<double> _M_m;
5811       };
5812
5813       explicit
5814       piecewise_linear_distribution()
5815       : _M_param()
5816       { }
5817
5818       template<typename _InputIteratorB, typename _InputIteratorW>
5819         piecewise_linear_distribution(_InputIteratorB __bfirst,
5820                                       _InputIteratorB __bend,
5821                                       _InputIteratorW __wbegin)
5822         : _M_param(__bfirst, __bend, __wbegin)
5823         { }
5824
5825       template<typename _Func>
5826         piecewise_linear_distribution(initializer_list<_RealType> __bl,
5827                                       _Func __fw)
5828         : _M_param(__bl, __fw)
5829         { }
5830
5831       template<typename _Func>
5832         piecewise_linear_distribution(size_t __nw,
5833                                       _RealType __xmin, _RealType __xmax,
5834                                       _Func __fw)
5835         : _M_param(__nw, __xmin, __xmax, __fw)
5836         { }
5837
5838       explicit
5839       piecewise_linear_distribution(const param_type& __p)
5840       : _M_param(__p)
5841       { }
5842
5843       /**
5844        * Resets the distribution state.
5845        */
5846       void
5847       reset()
5848       { }
5849
5850       /**
5851        * @brief Return the intervals of the distribution.
5852        */
5853       std::vector<_RealType>
5854       intervals() const
5855       {
5856         if (_M_param._M_int.empty())
5857           {
5858             std::vector<_RealType> __tmp(2);
5859             __tmp[1] = _RealType(1);
5860             return __tmp;
5861           }
5862         else
5863           return _M_param._M_int;
5864       }
5865
5866       /**
5867        * @brief Return a vector of the probability densities of the
5868        *        distribution.
5869        */
5870       std::vector<double>
5871       densities() const
5872       {
5873         return _M_param._M_den.empty()
5874           ? std::vector<double>(2, 1.0) : _M_param._M_den;
5875       }
5876
5877       /**
5878        * @brief Returns the parameter set of the distribution.
5879        */
5880       param_type
5881       param() const
5882       { return _M_param; }
5883
5884       /**
5885        * @brief Sets the parameter set of the distribution.
5886        * @param __param The new parameter set of the distribution.
5887        */
5888       void
5889       param(const param_type& __param)
5890       { _M_param = __param; }
5891
5892       /**
5893        * @brief Returns the greatest lower bound value of the distribution.
5894        */
5895       result_type
5896       min() const
5897       {
5898         return _M_param._M_int.empty()
5899           ? result_type(0) : _M_param._M_int.front();
5900       }
5901
5902       /**
5903        * @brief Returns the least upper bound value of the distribution.
5904        */
5905       result_type
5906       max() const
5907       {
5908         return _M_param._M_int.empty()
5909           ? result_type(1) : _M_param._M_int.back();
5910       }
5911
5912       /**
5913        * @brief Generating functions.
5914        */
5915       template<typename _UniformRandomNumberGenerator>
5916         result_type
5917         operator()(_UniformRandomNumberGenerator& __urng)
5918         { return this->operator()(__urng, _M_param); }
5919
5920       template<typename _UniformRandomNumberGenerator>
5921         result_type
5922         operator()(_UniformRandomNumberGenerator& __urng,
5923                    const param_type& __p);
5924
5925       template<typename _ForwardIterator,
5926                typename _UniformRandomNumberGenerator>
5927         void
5928         __generate(_ForwardIterator __f, _ForwardIterator __t,
5929                    _UniformRandomNumberGenerator& __urng)
5930         { this->__generate(__f, __t, __urng, _M_param); }
5931
5932       template<typename _ForwardIterator,
5933                typename _UniformRandomNumberGenerator>
5934         void
5935         __generate(_ForwardIterator __f, _ForwardIterator __t,
5936                    _UniformRandomNumberGenerator& __urng,
5937                    const param_type& __p)
5938         { this->__generate_impl(__f, __t, __urng, __p); }
5939
5940       template<typename _UniformRandomNumberGenerator>
5941         void
5942         __generate(result_type* __f, result_type* __t,
5943                    _UniformRandomNumberGenerator& __urng,
5944                    const param_type& __p)
5945         { this->__generate_impl(__f, __t, __urng, __p); }
5946
5947       /**
5948        * @brief Return true if two piecewise linear distributions have the
5949        *        same parameters.
5950        */
5951       friend bool
5952       operator==(const piecewise_linear_distribution& __d1,
5953                  const piecewise_linear_distribution& __d2)
5954       { return __d1._M_param == __d2._M_param; }
5955
5956       /**
5957        * @brief Inserts a %piecewise_linear_distribution random number
5958        *        distribution @p __x into the output stream @p __os.
5959        *
5960        * @param __os An output stream.
5961        * @param __x  A %piecewise_linear_distribution random number
5962        *             distribution.
5963        *
5964        * @returns The output stream with the state of @p __x inserted or in
5965        *          an error state.
5966        */
5967       template<typename _RealType1, typename _CharT, typename _Traits>
5968         friend std::basic_ostream<_CharT, _Traits>&
5969         operator<<(std::basic_ostream<_CharT, _Traits>& __os,
5970                    const std::piecewise_linear_distribution<_RealType1>& __x);
5971
5972       /**
5973        * @brief Extracts a %piecewise_linear_distribution random number
5974        *        distribution @p __x from the input stream @p __is.
5975        *
5976        * @param __is An input stream.
5977        * @param __x  A %piecewise_linear_distribution random number
5978        *             generator engine.
5979        *
5980        * @returns The input stream with @p __x extracted or in an error
5981        *          state.
5982        */
5983       template<typename _RealType1, typename _CharT, typename _Traits>
5984         friend std::basic_istream<_CharT, _Traits>&
5985         operator>>(std::basic_istream<_CharT, _Traits>& __is,
5986                    std::piecewise_linear_distribution<_RealType1>& __x);
5987
5988     private:
5989       template<typename _ForwardIterator,
5990                typename _UniformRandomNumberGenerator>
5991         void
5992         __generate_impl(_ForwardIterator __f, _ForwardIterator __t,
5993                         _UniformRandomNumberGenerator& __urng,
5994                         const param_type& __p);
5995
5996       param_type _M_param;
5997     };
5998
5999   /**
6000     * @brief Return true if two piecewise linear distributions have
6001     *        different parameters.
6002    */
6003   template<typename _RealType>
6004     inline bool
6005     operator!=(const std::piecewise_linear_distribution<_RealType>& __d1,
6006                const std::piecewise_linear_distribution<_RealType>& __d2)
6007     { return !(__d1 == __d2); }
6008
6009
6010   /* @} */ // group random_distributions_poisson
6011
6012   /* @} */ // group random_distributions
6013
6014   /**
6015    * @addtogroup random_utilities Random Number Utilities
6016    * @ingroup random
6017    * @{
6018    */
6019
6020   /**
6021    * @brief The seed_seq class generates sequences of seeds for random
6022    *        number generators.
6023    */
6024   class seed_seq
6025   {
6026
6027   public:
6028     /** The type of the seed vales. */
6029     typedef uint_least32_t result_type;
6030
6031     /** Default constructor. */
6032     seed_seq()
6033     : _M_v()
6034     { }
6035
6036     template<typename _IntType>
6037       seed_seq(std::initializer_list<_IntType> il);
6038
6039     template<typename _InputIterator>
6040       seed_seq(_InputIterator __begin, _InputIterator __end);
6041
6042     // generating functions
6043     template<typename _RandomAccessIterator>
6044       void
6045       generate(_RandomAccessIterator __begin, _RandomAccessIterator __end);
6046
6047     // property functions
6048     size_t size() const
6049     { return _M_v.size(); }
6050
6051     template<typename OutputIterator>
6052       void
6053       param(OutputIterator __dest) const
6054       { std::copy(_M_v.begin(), _M_v.end(), __dest); }
6055
6056   private:
6057     ///
6058     std::vector<result_type> _M_v;
6059   };
6060
6061   /* @} */ // group random_utilities
6062
6063   /* @} */ // group random
6064
6065 _GLIBCXX_END_NAMESPACE_VERSION
6066 } // namespace std
6067
6068 #endif