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