Home | History | Annotate | Download | only in v1
      1 // -*- C++ -*-
      2 //===--------------------------- random -----------------------------------===//
      3 //
      4 //                     The LLVM Compiler Infrastructure
      5 //
      6 // This file is dual licensed under the MIT and the University of Illinois Open
      7 // Source Licenses. See LICENSE.TXT for details.
      8 //
      9 //===----------------------------------------------------------------------===//
     10 
     11 #ifndef _LIBCPP_RANDOM
     12 #define _LIBCPP_RANDOM
     13 
     14 /*
     15     random synopsis
     16 
     17 #include <initializer_list>
     18 
     19 namespace std
     20 {
     21 
     22 // Engines
     23 
     24 template <class UIntType, UIntType a, UIntType c, UIntType m>
     25 class linear_congruential_engine
     26 {
     27 public:
     28     // types
     29     typedef UIntType result_type;
     30 
     31     // engine characteristics
     32     static constexpr result_type multiplier = a;
     33     static constexpr result_type increment = c;
     34     static constexpr result_type modulus = m;
     35     static constexpr result_type min() { return c == 0u ? 1u: 0u;}
     36     static constexpr result_type max() { return m - 1u;}
     37     static constexpr result_type default_seed = 1u;
     38 
     39     // constructors and seeding functions
     40     explicit linear_congruential_engine(result_type s = default_seed);
     41     template<class Sseq> explicit linear_congruential_engine(Sseq& q);
     42     void seed(result_type s = default_seed);
     43     template<class Sseq> void seed(Sseq& q);
     44 
     45     // generating functions
     46     result_type operator()();
     47     void discard(unsigned long long z);
     48 };
     49 
     50 template <class UIntType, UIntType a, UIntType c, UIntType m>
     51 bool
     52 operator==(const linear_congruential_engine<UIntType, a, c, m>& x,
     53            const linear_congruential_engine<UIntType, a, c, m>& y);
     54 
     55 template <class UIntType, UIntType a, UIntType c, UIntType m>
     56 bool
     57 operator!=(const linear_congruential_engine<UIntType, a, c, m>& x,
     58            const linear_congruential_engine<UIntType, a, c, m>& y);
     59 
     60 template <class charT, class traits,
     61           class UIntType, UIntType a, UIntType c, UIntType m>
     62 basic_ostream<charT, traits>&
     63 operator<<(basic_ostream<charT, traits>& os,
     64            const linear_congruential_engine<UIntType, a, c, m>& x);
     65 
     66 template <class charT, class traits,
     67           class UIntType, UIntType a, UIntType c, UIntType m>
     68 basic_istream<charT, traits>&
     69 operator>>(basic_istream<charT, traits>& is,
     70            linear_congruential_engine<UIntType, a, c, m>& x);
     71 
     72 template <class UIntType, size_t w, size_t n, size_t m, size_t r,
     73           UIntType a, size_t u, UIntType d, size_t s,
     74           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
     75 class mersenne_twister_engine
     76 {
     77 public:
     78     // types
     79     typedef UIntType result_type;
     80 
     81     // engine characteristics
     82     static constexpr size_t word_size = w;
     83     static constexpr size_t state_size = n;
     84     static constexpr size_t shift_size = m;
     85     static constexpr size_t mask_bits = r;
     86     static constexpr result_type xor_mask = a;
     87     static constexpr size_t tempering_u = u;
     88     static constexpr result_type tempering_d = d;
     89     static constexpr size_t tempering_s = s;
     90     static constexpr result_type tempering_b = b;
     91     static constexpr size_t tempering_t = t;
     92     static constexpr result_type tempering_c = c;
     93     static constexpr size_t tempering_l = l;
     94     static constexpr result_type initialization_multiplier = f;
     95     static constexpr result_type min () { return 0; }
     96     static constexpr result_type max() { return 2^w - 1; }
     97     static constexpr result_type default_seed = 5489u;
     98 
     99     // constructors and seeding functions
    100     explicit mersenne_twister_engine(result_type value = default_seed);
    101     template<class Sseq> explicit mersenne_twister_engine(Sseq& q);
    102     void seed(result_type value = default_seed);
    103     template<class Sseq> void seed(Sseq& q);
    104 
    105     // generating functions
    106     result_type operator()();
    107     void discard(unsigned long long z);
    108 };
    109 
    110 template <class UIntType, size_t w, size_t n, size_t m, size_t r,
    111           UIntType a, size_t u, UIntType d, size_t s,
    112           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
    113 bool
    114 operator==(
    115     const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
    116     const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);
    117 
    118 template <class UIntType, size_t w, size_t n, size_t m, size_t r,
    119           UIntType a, size_t u, UIntType d, size_t s,
    120           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
    121 bool
    122 operator!=(
    123     const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x,
    124     const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y);
    125 
    126 template <class charT, class traits,
    127           class UIntType, size_t w, size_t n, size_t m, size_t r,
    128           UIntType a, size_t u, UIntType d, size_t s,
    129           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
    130 basic_ostream<charT, traits>&
    131 operator<<(basic_ostream<charT, traits>& os,
    132            const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);
    133 
    134 template <class charT, class traits,
    135           class UIntType, size_t w, size_t n, size_t m, size_t r,
    136           UIntType a, size_t u, UIntType d, size_t s,
    137           UIntType b, size_t t, UIntType c, size_t l, UIntType f>
    138 basic_istream<charT, traits>&
    139 operator>>(basic_istream<charT, traits>& is,
    140            mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x);
    141 
    142 template<class UIntType, size_t w, size_t s, size_t r>
    143 class subtract_with_carry_engine
    144 {
    145 public:
    146     // types
    147     typedef UIntType result_type;
    148 
    149     // engine characteristics
    150     static constexpr size_t word_size = w;
    151     static constexpr size_t short_lag = s;
    152     static constexpr size_t long_lag = r;
    153     static constexpr result_type min() { return 0; }
    154     static constexpr result_type max() { return m-1; }
    155     static constexpr result_type default_seed = 19780503u;
    156 
    157     // constructors and seeding functions
    158     explicit subtract_with_carry_engine(result_type value = default_seed);
    159     template<class Sseq> explicit subtract_with_carry_engine(Sseq& q);
    160     void seed(result_type value = default_seed);
    161     template<class Sseq> void seed(Sseq& q);
    162 
    163     // generating functions
    164     result_type operator()();
    165     void discard(unsigned long long z);
    166 };
    167 
    168 template<class UIntType, size_t w, size_t s, size_t r>
    169 bool
    170 operator==(
    171     const subtract_with_carry_engine<UIntType, w, s, r>& x,
    172     const subtract_with_carry_engine<UIntType, w, s, r>& y);
    173 
    174 template<class UIntType, size_t w, size_t s, size_t r>
    175 bool
    176 operator!=(
    177     const subtract_with_carry_engine<UIntType, w, s, r>& x,
    178     const subtract_with_carry_engine<UIntType, w, s, r>& y);
    179 
    180 template <class charT, class traits,
    181           class UIntType, size_t w, size_t s, size_t r>
    182 basic_ostream<charT, traits>&
    183 operator<<(basic_ostream<charT, traits>& os,
    184            const subtract_with_carry_engine<UIntType, w, s, r>& x);
    185 
    186 template <class charT, class traits,
    187           class UIntType, size_t w, size_t s, size_t r>
    188 basic_istream<charT, traits>&
    189 operator>>(basic_istream<charT, traits>& is,
    190            subtract_with_carry_engine<UIntType, w, s, r>& x);
    191 
    192 template<class Engine, size_t p, size_t r>
    193 class discard_block_engine
    194 {
    195 public:
    196     // types
    197     typedef typename Engine::result_type result_type;
    198 
    199     // engine characteristics
    200     static constexpr size_t block_size = p;
    201     static constexpr size_t used_block = r;
    202     static constexpr result_type min() { return Engine::min(); }
    203     static constexpr result_type max() { return Engine::max(); }
    204 
    205     // constructors and seeding functions
    206     discard_block_engine();
    207     explicit discard_block_engine(const Engine& e);
    208     explicit discard_block_engine(Engine&& e);
    209     explicit discard_block_engine(result_type s);
    210     template<class Sseq> explicit discard_block_engine(Sseq& q);
    211     void seed();
    212     void seed(result_type s);
    213     template<class Sseq> void seed(Sseq& q);
    214 
    215     // generating functions
    216     result_type operator()();
    217     void discard(unsigned long long z);
    218 
    219     // property functions
    220     const Engine& base() const noexcept;
    221 };
    222 
    223 template<class Engine, size_t p, size_t r>
    224 bool
    225 operator==(
    226     const discard_block_engine<Engine, p, r>& x,
    227     const discard_block_engine<Engine, p, r>& y);
    228 
    229 template<class Engine, size_t p, size_t r>
    230 bool
    231 operator!=(
    232     const discard_block_engine<Engine, p, r>& x,
    233     const discard_block_engine<Engine, p, r>& y);
    234 
    235 template <class charT, class traits,
    236           class Engine, size_t p, size_t r>
    237 basic_ostream<charT, traits>&
    238 operator<<(basic_ostream<charT, traits>& os,
    239            const discard_block_engine<Engine, p, r>& x);
    240 
    241 template <class charT, class traits,
    242           class Engine, size_t p, size_t r>
    243 basic_istream<charT, traits>&
    244 operator>>(basic_istream<charT, traits>& is,
    245            discard_block_engine<Engine, p, r>& x);
    246 
    247 template<class Engine, size_t w, class UIntType>
    248 class independent_bits_engine
    249 {
    250 public:
    251     // types
    252     typedef UIntType result_type;
    253 
    254     // engine characteristics
    255     static constexpr result_type min() { return 0; }
    256     static constexpr result_type max() { return 2^w - 1; }
    257 
    258     // constructors and seeding functions
    259     independent_bits_engine();
    260     explicit independent_bits_engine(const Engine& e);
    261     explicit independent_bits_engine(Engine&& e);
    262     explicit independent_bits_engine(result_type s);
    263     template<class Sseq> explicit independent_bits_engine(Sseq& q);
    264     void seed();
    265     void seed(result_type s);
    266     template<class Sseq> void seed(Sseq& q);
    267 
    268     // generating functions
    269     result_type operator()(); void discard(unsigned long long z);
    270 
    271     // property functions
    272     const Engine& base() const noexcept;
    273 };
    274 
    275 template<class Engine, size_t w, class UIntType>
    276 bool
    277 operator==(
    278     const independent_bits_engine<Engine, w, UIntType>& x,
    279     const independent_bits_engine<Engine, w, UIntType>& y);
    280 
    281 template<class Engine, size_t w, class UIntType>
    282 bool
    283 operator!=(
    284     const independent_bits_engine<Engine, w, UIntType>& x,
    285     const independent_bits_engine<Engine, w, UIntType>& y);
    286 
    287 template <class charT, class traits,
    288           class Engine, size_t w, class UIntType>
    289 basic_ostream<charT, traits>&
    290 operator<<(basic_ostream<charT, traits>& os,
    291            const independent_bits_engine<Engine, w, UIntType>& x);
    292 
    293 template <class charT, class traits,
    294           class Engine, size_t w, class UIntType>
    295 basic_istream<charT, traits>&
    296 operator>>(basic_istream<charT, traits>& is,
    297            independent_bits_engine<Engine, w, UIntType>& x);
    298 
    299 template<class Engine, size_t k>
    300 class shuffle_order_engine
    301 {
    302 public:
    303     // types
    304     typedef typename Engine::result_type result_type;
    305 
    306     // engine characteristics
    307     static constexpr size_t table_size = k;
    308     static constexpr result_type min() { return Engine::min; }
    309     static constexpr result_type max() { return Engine::max; }
    310 
    311     // constructors and seeding functions
    312     shuffle_order_engine();
    313     explicit shuffle_order_engine(const Engine& e);
    314     explicit shuffle_order_engine(Engine&& e);
    315     explicit shuffle_order_engine(result_type s);
    316     template<class Sseq> explicit shuffle_order_engine(Sseq& q);
    317     void seed();
    318     void seed(result_type s);
    319     template<class Sseq> void seed(Sseq& q);
    320 
    321     // generating functions
    322     result_type operator()();
    323     void discard(unsigned long long z);
    324 
    325     // property functions
    326     const Engine& base() const noexcept;
    327 };
    328 
    329 template<class Engine, size_t k>
    330 bool
    331 operator==(
    332     const shuffle_order_engine<Engine, k>& x,
    333     const shuffle_order_engine<Engine, k>& y);
    334 
    335 template<class Engine, size_t k>
    336 bool
    337 operator!=(
    338     const shuffle_order_engine<Engine, k>& x,
    339     const shuffle_order_engine<Engine, k>& y);
    340 
    341 template <class charT, class traits,
    342           class Engine, size_t k>
    343 basic_ostream<charT, traits>&
    344 operator<<(basic_ostream<charT, traits>& os,
    345            const shuffle_order_engine<Engine, k>& x);
    346 
    347 template <class charT, class traits,
    348           class Engine, size_t k>
    349 basic_istream<charT, traits>&
    350 operator>>(basic_istream<charT, traits>& is,
    351            shuffle_order_engine<Engine, k>& x);
    352 
    353 typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
    354                                                                    minstd_rand0;
    355 typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
    356                                                                     minstd_rand;
    357 typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
    358                                 0x9908b0df,
    359                                 11, 0xffffffff,
    360                                 7,  0x9d2c5680,
    361                                 15, 0xefc60000,
    362                                 18, 1812433253>                         mt19937;
    363 typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
    364                                 0xb5026f5aa96619e9,
    365                                 29, 0x5555555555555555,
    366                                 17, 0x71d67fffeda60000,
    367                                 37, 0xfff7eee000000000,
    368                                 43, 6364136223846793005>             mt19937_64;
    369 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>     ranlux24_base;
    370 typedef subtract_with_carry_engine<uint_fast64_t, 48,  5, 12>     ranlux48_base;
    371 typedef discard_block_engine<ranlux24_base, 223, 23>                   ranlux24;
    372 typedef discard_block_engine<ranlux48_base, 389, 11>                   ranlux48;
    373 typedef shuffle_order_engine<minstd_rand0, 256>                         knuth_b;
    374 typedef minstd_rand                                       default_random_engine;
    375 
    376 // Generators
    377 
    378 class random_device
    379 {
    380 public:
    381     // types
    382     typedef unsigned int result_type;
    383 
    384     // generator characteristics
    385     static constexpr result_type min() { return numeric_limits<result_type>::min(); }
    386     static constexpr result_type max() { return numeric_limits<result_type>::max(); }
    387 
    388     // constructors
    389     explicit random_device(const string& token = "/dev/urandom");
    390 
    391     // generating functions
    392     result_type operator()();
    393 
    394     // property functions
    395     double entropy() const noexcept;
    396 
    397     // no copy functions
    398     random_device(const random_device& ) = delete;
    399     void operator=(const random_device& ) = delete;
    400 };
    401 
    402 // Utilities
    403 
    404 class seed_seq
    405 {
    406 public:
    407     // types
    408     typedef uint_least32_t result_type;
    409 
    410     // constructors
    411     seed_seq();
    412     template<class T>
    413         seed_seq(initializer_list<T> il);
    414     template<class InputIterator>
    415         seed_seq(InputIterator begin, InputIterator end);
    416 
    417     // generating functions
    418     template<class RandomAccessIterator>
    419         void generate(RandomAccessIterator begin, RandomAccessIterator end);
    420 
    421     // property functions
    422     size_t size() const;
    423     template<class OutputIterator>
    424         void param(OutputIterator dest) const;
    425 
    426     // no copy functions
    427     seed_seq(const seed_seq&) = delete;
    428     void operator=(const seed_seq& ) = delete;
    429 };
    430 
    431 template<class RealType, size_t bits, class URNG>
    432     RealType generate_canonical(URNG& g);
    433 
    434 // Distributions
    435 
    436 template<class IntType = int>
    437 class uniform_int_distribution
    438 {
    439 public:
    440     // types
    441     typedef IntType result_type;
    442 
    443     class param_type
    444     {
    445     public:
    446         typedef uniform_int_distribution distribution_type;
    447 
    448         explicit param_type(IntType a = 0,
    449                                     IntType b = numeric_limits<IntType>::max());
    450 
    451         result_type a() const;
    452         result_type b() const;
    453 
    454         friend bool operator==(const param_type& x, const param_type& y);
    455         friend bool operator!=(const param_type& x, const param_type& y);
    456     };
    457 
    458     // constructors and reset functions
    459     explicit uniform_int_distribution(IntType a = 0,
    460                                     IntType b = numeric_limits<IntType>::max());
    461     explicit uniform_int_distribution(const param_type& parm);
    462     void reset();
    463 
    464     // generating functions
    465     template<class URNG> result_type operator()(URNG& g);
    466     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    467 
    468     // property functions
    469     result_type a() const;
    470     result_type b() const;
    471 
    472     param_type param() const;
    473     void param(const param_type& parm);
    474 
    475     result_type min() const;
    476     result_type max() const;
    477 
    478     friend bool operator==(const uniform_int_distribution& x,
    479                            const uniform_int_distribution& y);
    480     friend bool operator!=(const uniform_int_distribution& x,
    481                            const uniform_int_distribution& y);
    482 
    483     template <class charT, class traits>
    484     friend
    485     basic_ostream<charT, traits>&
    486     operator<<(basic_ostream<charT, traits>& os,
    487                const uniform_int_distribution& x);
    488 
    489     template <class charT, class traits>
    490     friend
    491     basic_istream<charT, traits>&
    492     operator>>(basic_istream<charT, traits>& is,
    493                uniform_int_distribution& x);
    494 };
    495 
    496 template<class RealType = double>
    497 class uniform_real_distribution
    498 {
    499 public:
    500     // types
    501     typedef RealType result_type;
    502 
    503     class param_type
    504     {
    505     public:
    506         typedef uniform_real_distribution distribution_type;
    507 
    508         explicit param_type(RealType a = 0,
    509                             RealType b = 1);
    510 
    511         result_type a() const;
    512         result_type b() const;
    513 
    514         friend bool operator==(const param_type& x, const param_type& y);
    515         friend bool operator!=(const param_type& x, const param_type& y);
    516     };
    517 
    518     // constructors and reset functions
    519     explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0);
    520     explicit uniform_real_distribution(const param_type& parm);
    521     void reset();
    522 
    523     // generating functions
    524     template<class URNG> result_type operator()(URNG& g);
    525     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    526 
    527     // property functions
    528     result_type a() const;
    529     result_type b() const;
    530 
    531     param_type param() const;
    532     void param(const param_type& parm);
    533 
    534     result_type min() const;
    535     result_type max() const;
    536 
    537     friend bool operator==(const uniform_real_distribution& x,
    538                            const uniform_real_distribution& y);
    539     friend bool operator!=(const uniform_real_distribution& x,
    540                            const uniform_real_distribution& y);
    541 
    542     template <class charT, class traits>
    543     friend
    544     basic_ostream<charT, traits>&
    545     operator<<(basic_ostream<charT, traits>& os,
    546                const uniform_real_distribution& x);
    547 
    548     template <class charT, class traits>
    549     friend
    550     basic_istream<charT, traits>&
    551     operator>>(basic_istream<charT, traits>& is,
    552                uniform_real_distribution& x);
    553 };
    554 
    555 class bernoulli_distribution
    556 {
    557 public:
    558     // types
    559     typedef bool result_type;
    560 
    561     class param_type
    562     {
    563     public:
    564         typedef bernoulli_distribution distribution_type;
    565 
    566         explicit param_type(double p = 0.5);
    567 
    568         double p() const;
    569 
    570         friend bool operator==(const param_type& x, const param_type& y);
    571         friend bool operator!=(const param_type& x, const param_type& y);
    572     };
    573 
    574     // constructors and reset functions
    575     explicit bernoulli_distribution(double p = 0.5);
    576     explicit bernoulli_distribution(const param_type& parm);
    577     void reset();
    578 
    579     // generating functions
    580     template<class URNG> result_type operator()(URNG& g);
    581     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    582 
    583     // property functions
    584     double p() const;
    585 
    586     param_type param() const;
    587     void param(const param_type& parm);
    588 
    589     result_type min() const;
    590     result_type max() const;
    591 
    592     friend bool operator==(const bernoulli_distribution& x,
    593                            const bernoulli_distribution& y);
    594     friend bool operator!=(const bernoulli_distribution& x,
    595                            const bernoulli_distribution& y);
    596 
    597     template <class charT, class traits>
    598     friend
    599     basic_ostream<charT, traits>&
    600     operator<<(basic_ostream<charT, traits>& os,
    601                const bernoulli_distribution& x);
    602 
    603     template <class charT, class traits>
    604     friend
    605     basic_istream<charT, traits>&
    606     operator>>(basic_istream<charT, traits>& is,
    607                bernoulli_distribution& x);
    608 };
    609 
    610 template<class IntType = int>
    611 class binomial_distribution
    612 {
    613 public:
    614     // types
    615     typedef IntType result_type;
    616 
    617     class param_type
    618     {
    619     public:
    620         typedef binomial_distribution distribution_type;
    621 
    622         explicit param_type(IntType t = 1, double p = 0.5);
    623 
    624         IntType t() const;
    625         double p() const;
    626 
    627         friend bool operator==(const param_type& x, const param_type& y);
    628         friend bool operator!=(const param_type& x, const param_type& y);
    629     };
    630 
    631     // constructors and reset functions
    632     explicit binomial_distribution(IntType t = 1, double p = 0.5);
    633     explicit binomial_distribution(const param_type& parm);
    634     void reset();
    635 
    636     // generating functions
    637     template<class URNG> result_type operator()(URNG& g);
    638     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    639 
    640     // property functions
    641     IntType t() const;
    642     double p() const;
    643 
    644     param_type param() const;
    645     void param(const param_type& parm);
    646 
    647     result_type min() const;
    648     result_type max() const;
    649 
    650     friend bool operator==(const binomial_distribution& x,
    651                            const binomial_distribution& y);
    652     friend bool operator!=(const binomial_distribution& x,
    653                            const binomial_distribution& y);
    654 
    655     template <class charT, class traits>
    656     friend
    657     basic_ostream<charT, traits>&
    658     operator<<(basic_ostream<charT, traits>& os,
    659                const binomial_distribution& x);
    660 
    661     template <class charT, class traits>
    662     friend
    663     basic_istream<charT, traits>&
    664     operator>>(basic_istream<charT, traits>& is,
    665                binomial_distribution& x);
    666 };
    667 
    668 template<class IntType = int>
    669 class geometric_distribution
    670 {
    671 public:
    672     // types
    673     typedef IntType result_type;
    674 
    675     class param_type
    676     {
    677     public:
    678         typedef geometric_distribution distribution_type;
    679 
    680         explicit param_type(double p = 0.5);
    681 
    682         double p() const;
    683 
    684         friend bool operator==(const param_type& x, const param_type& y);
    685         friend bool operator!=(const param_type& x, const param_type& y);
    686     };
    687 
    688     // constructors and reset functions
    689     explicit geometric_distribution(double p = 0.5);
    690     explicit geometric_distribution(const param_type& parm);
    691     void reset();
    692 
    693     // generating functions
    694     template<class URNG> result_type operator()(URNG& g);
    695     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    696 
    697     // property functions
    698     double p() const;
    699 
    700     param_type param() const;
    701     void param(const param_type& parm);
    702 
    703     result_type min() const;
    704     result_type max() const;
    705 
    706     friend bool operator==(const geometric_distribution& x,
    707                            const geometric_distribution& y);
    708     friend bool operator!=(const geometric_distribution& x,
    709                            const geometric_distribution& y);
    710 
    711     template <class charT, class traits>
    712     friend
    713     basic_ostream<charT, traits>&
    714     operator<<(basic_ostream<charT, traits>& os,
    715                const geometric_distribution& x);
    716 
    717     template <class charT, class traits>
    718     friend
    719     basic_istream<charT, traits>&
    720     operator>>(basic_istream<charT, traits>& is,
    721                geometric_distribution& x);
    722 };
    723 
    724 template<class IntType = int>
    725 class negative_binomial_distribution
    726 {
    727 public:
    728     // types
    729     typedef IntType result_type;
    730 
    731     class param_type
    732     {
    733     public:
    734         typedef negative_binomial_distribution distribution_type;
    735 
    736         explicit param_type(result_type k = 1, double p = 0.5);
    737 
    738         result_type k() const;
    739         double p() const;
    740 
    741         friend bool operator==(const param_type& x, const param_type& y);
    742         friend bool operator!=(const param_type& x, const param_type& y);
    743     };
    744 
    745     // constructor and reset functions
    746     explicit negative_binomial_distribution(result_type k = 1, double p = 0.5);
    747     explicit negative_binomial_distribution(const param_type& parm);
    748     void reset();
    749 
    750     // generating functions
    751     template<class URNG> result_type operator()(URNG& g);
    752     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    753 
    754     // property functions
    755     result_type k() const;
    756     double p() const;
    757 
    758     param_type param() const;
    759     void param(const param_type& parm);
    760 
    761     result_type min() const;
    762     result_type max() const;
    763 
    764     friend bool operator==(const negative_binomial_distribution& x,
    765                            const negative_binomial_distribution& y);
    766     friend bool operator!=(const negative_binomial_distribution& x,
    767                            const negative_binomial_distribution& y);
    768 
    769     template <class charT, class traits>
    770     friend
    771     basic_ostream<charT, traits>&
    772     operator<<(basic_ostream<charT, traits>& os,
    773                const negative_binomial_distribution& x);
    774 
    775     template <class charT, class traits>
    776     friend
    777     basic_istream<charT, traits>&
    778     operator>>(basic_istream<charT, traits>& is,
    779                negative_binomial_distribution& x);
    780 };
    781 
    782 template<class IntType = int>
    783 class poisson_distribution
    784 {
    785 public:
    786     // types
    787     typedef IntType result_type;
    788 
    789     class param_type
    790     {
    791     public:
    792         typedef poisson_distribution distribution_type;
    793 
    794         explicit param_type(double mean = 1.0);
    795 
    796         double mean() const;
    797 
    798         friend bool operator==(const param_type& x, const param_type& y);
    799         friend bool operator!=(const param_type& x, const param_type& y);
    800     };
    801 
    802     // constructors and reset functions
    803     explicit poisson_distribution(double mean = 1.0);
    804     explicit poisson_distribution(const param_type& parm);
    805     void reset();
    806 
    807     // generating functions
    808     template<class URNG> result_type operator()(URNG& g);
    809     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    810 
    811     // property functions
    812     double mean() const;
    813 
    814     param_type param() const;
    815     void param(const param_type& parm);
    816 
    817     result_type min() const;
    818     result_type max() const;
    819 
    820     friend bool operator==(const poisson_distribution& x,
    821                            const poisson_distribution& y);
    822     friend bool operator!=(const poisson_distribution& x,
    823                            const poisson_distribution& y);
    824 
    825     template <class charT, class traits>
    826     friend
    827     basic_ostream<charT, traits>&
    828     operator<<(basic_ostream<charT, traits>& os,
    829                const poisson_distribution& x);
    830 
    831     template <class charT, class traits>
    832     friend
    833     basic_istream<charT, traits>&
    834     operator>>(basic_istream<charT, traits>& is,
    835                poisson_distribution& x);
    836 };
    837 
    838 template<class RealType = double>
    839 class exponential_distribution
    840 {
    841 public:
    842     // types
    843     typedef RealType result_type;
    844 
    845     class param_type
    846     {
    847     public:
    848         typedef exponential_distribution distribution_type;
    849 
    850         explicit param_type(result_type lambda = 1.0);
    851 
    852         result_type lambda() const;
    853 
    854         friend bool operator==(const param_type& x, const param_type& y);
    855         friend bool operator!=(const param_type& x, const param_type& y);
    856     };
    857 
    858     // constructors and reset functions
    859     explicit exponential_distribution(result_type lambda = 1.0);
    860     explicit exponential_distribution(const param_type& parm);
    861     void reset();
    862 
    863     // generating functions
    864     template<class URNG> result_type operator()(URNG& g);
    865     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    866 
    867     // property functions
    868     result_type lambda() const;
    869 
    870     param_type param() const;
    871     void param(const param_type& parm);
    872 
    873     result_type min() const;
    874     result_type max() const;
    875 
    876     friend bool operator==(const exponential_distribution& x,
    877                            const exponential_distribution& y);
    878     friend bool operator!=(const exponential_distribution& x,
    879                            const exponential_distribution& y);
    880 
    881     template <class charT, class traits>
    882     friend
    883     basic_ostream<charT, traits>&
    884     operator<<(basic_ostream<charT, traits>& os,
    885                const exponential_distribution& x);
    886 
    887     template <class charT, class traits>
    888     friend
    889     basic_istream<charT, traits>&
    890     operator>>(basic_istream<charT, traits>& is,
    891                exponential_distribution& x);
    892 };
    893 
    894 template<class RealType = double>
    895 class gamma_distribution
    896 {
    897 public:
    898     // types
    899     typedef RealType result_type;
    900 
    901     class param_type
    902     {
    903     public:
    904         typedef gamma_distribution distribution_type;
    905 
    906         explicit param_type(result_type alpha = 1, result_type beta = 1);
    907 
    908         result_type alpha() const;
    909         result_type beta() const;
    910 
    911         friend bool operator==(const param_type& x, const param_type& y);
    912         friend bool operator!=(const param_type& x, const param_type& y);
    913     };
    914 
    915     // constructors and reset functions
    916     explicit gamma_distribution(result_type alpha = 1, result_type beta = 1);
    917     explicit gamma_distribution(const param_type& parm);
    918     void reset();
    919 
    920     // generating functions
    921     template<class URNG> result_type operator()(URNG& g);
    922     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    923 
    924     // property functions
    925     result_type alpha() const;
    926     result_type beta() const;
    927 
    928     param_type param() const;
    929     void param(const param_type& parm);
    930 
    931     result_type min() const;
    932     result_type max() const;
    933 
    934     friend bool operator==(const gamma_distribution& x,
    935                            const gamma_distribution& y);
    936     friend bool operator!=(const gamma_distribution& x,
    937                            const gamma_distribution& y);
    938 
    939     template <class charT, class traits>
    940     friend
    941     basic_ostream<charT, traits>&
    942     operator<<(basic_ostream<charT, traits>& os,
    943                const gamma_distribution& x);
    944 
    945     template <class charT, class traits>
    946     friend
    947     basic_istream<charT, traits>&
    948     operator>>(basic_istream<charT, traits>& is,
    949                gamma_distribution& x);
    950 };
    951 
    952 template<class RealType = double>
    953 class weibull_distribution
    954 {
    955 public:
    956     // types
    957     typedef RealType result_type;
    958 
    959     class param_type
    960     {
    961     public:
    962         typedef weibull_distribution distribution_type;
    963 
    964         explicit param_type(result_type alpha = 1, result_type beta = 1);
    965 
    966         result_type a() const;
    967         result_type b() const;
    968 
    969         friend bool operator==(const param_type& x, const param_type& y);
    970         friend bool operator!=(const param_type& x, const param_type& y);
    971     };
    972 
    973     // constructor and reset functions
    974     explicit weibull_distribution(result_type a = 1, result_type b = 1);
    975     explicit weibull_distribution(const param_type& parm);
    976     void reset();
    977 
    978     // generating functions
    979     template<class URNG> result_type operator()(URNG& g);
    980     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
    981 
    982     // property functions
    983     result_type a() const;
    984     result_type b() const;
    985 
    986     param_type param() const;
    987     void param(const param_type& parm);
    988 
    989     result_type min() const;
    990     result_type max() const;
    991 
    992     friend bool operator==(const weibull_distribution& x,
    993                            const weibull_distribution& y);
    994     friend bool operator!=(const weibull_distribution& x,
    995                            const weibull_distribution& y);
    996 
    997     template <class charT, class traits>
    998     friend
    999     basic_ostream<charT, traits>&
   1000     operator<<(basic_ostream<charT, traits>& os,
   1001                const weibull_distribution& x);
   1002 
   1003     template <class charT, class traits>
   1004     friend
   1005     basic_istream<charT, traits>&
   1006     operator>>(basic_istream<charT, traits>& is,
   1007                weibull_distribution& x);
   1008 };
   1009 
   1010 template<class RealType = double>
   1011 class extreme_value_distribution
   1012 {
   1013 public:
   1014     // types
   1015     typedef RealType result_type;
   1016 
   1017     class param_type
   1018     {
   1019     public:
   1020         typedef extreme_value_distribution distribution_type;
   1021 
   1022         explicit param_type(result_type a = 0, result_type b = 1);
   1023 
   1024         result_type a() const;
   1025         result_type b() const;
   1026 
   1027         friend bool operator==(const param_type& x, const param_type& y);
   1028         friend bool operator!=(const param_type& x, const param_type& y);
   1029     };
   1030 
   1031     // constructor and reset functions
   1032     explicit extreme_value_distribution(result_type a = 0, result_type b = 1);
   1033     explicit extreme_value_distribution(const param_type& parm);
   1034     void reset();
   1035 
   1036     // generating functions
   1037     template<class URNG> result_type operator()(URNG& g);
   1038     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1039 
   1040     // property functions
   1041     result_type a() const;
   1042     result_type b() const;
   1043 
   1044     param_type param() const;
   1045     void param(const param_type& parm);
   1046 
   1047     result_type min() const;
   1048     result_type max() const;
   1049 
   1050     friend bool operator==(const extreme_value_distribution& x,
   1051                            const extreme_value_distribution& y);
   1052     friend bool operator!=(const extreme_value_distribution& x,
   1053                            const extreme_value_distribution& y);
   1054 
   1055     template <class charT, class traits>
   1056     friend
   1057     basic_ostream<charT, traits>&
   1058     operator<<(basic_ostream<charT, traits>& os,
   1059                const extreme_value_distribution& x);
   1060 
   1061     template <class charT, class traits>
   1062     friend
   1063     basic_istream<charT, traits>&
   1064     operator>>(basic_istream<charT, traits>& is,
   1065                extreme_value_distribution& x);
   1066 };
   1067 
   1068 template<class RealType = double>
   1069 class normal_distribution
   1070 {
   1071 public:
   1072     // types
   1073     typedef RealType result_type;
   1074 
   1075     class param_type
   1076     {
   1077     public:
   1078         typedef normal_distribution distribution_type;
   1079 
   1080         explicit param_type(result_type mean = 0, result_type stddev = 1);
   1081 
   1082         result_type mean() const;
   1083         result_type stddev() const;
   1084 
   1085         friend bool operator==(const param_type& x, const param_type& y);
   1086         friend bool operator!=(const param_type& x, const param_type& y);
   1087     };
   1088 
   1089     // constructors and reset functions
   1090     explicit normal_distribution(result_type mean = 0, result_type stddev = 1);
   1091     explicit normal_distribution(const param_type& parm);
   1092     void reset();
   1093 
   1094     // generating functions
   1095     template<class URNG> result_type operator()(URNG& g);
   1096     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1097 
   1098     // property functions
   1099     result_type mean() const;
   1100     result_type stddev() const;
   1101 
   1102     param_type param() const;
   1103     void param(const param_type& parm);
   1104 
   1105     result_type min() const;
   1106     result_type max() const;
   1107 
   1108     friend bool operator==(const normal_distribution& x,
   1109                            const normal_distribution& y);
   1110     friend bool operator!=(const normal_distribution& x,
   1111                            const normal_distribution& y);
   1112 
   1113     template <class charT, class traits>
   1114     friend
   1115     basic_ostream<charT, traits>&
   1116     operator<<(basic_ostream<charT, traits>& os,
   1117                const normal_distribution& x);
   1118 
   1119     template <class charT, class traits>
   1120     friend
   1121     basic_istream<charT, traits>&
   1122     operator>>(basic_istream<charT, traits>& is,
   1123                normal_distribution& x);
   1124 };
   1125 
   1126 template<class RealType = double>
   1127 class lognormal_distribution
   1128 {
   1129 public:
   1130     // types
   1131     typedef RealType result_type;
   1132 
   1133     class param_type
   1134     {
   1135     public:
   1136         typedef lognormal_distribution distribution_type;
   1137 
   1138         explicit param_type(result_type m = 0, result_type s = 1);
   1139 
   1140         result_type m() const;
   1141         result_type s() const;
   1142 
   1143         friend bool operator==(const param_type& x, const param_type& y);
   1144         friend bool operator!=(const param_type& x, const param_type& y);
   1145     };
   1146 
   1147     // constructor and reset functions
   1148     explicit lognormal_distribution(result_type m = 0, result_type s = 1);
   1149     explicit lognormal_distribution(const param_type& parm);
   1150     void reset();
   1151 
   1152     // generating functions
   1153     template<class URNG> result_type operator()(URNG& g);
   1154     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1155 
   1156     // property functions
   1157     result_type m() const;
   1158     result_type s() const;
   1159 
   1160     param_type param() const;
   1161     void param(const param_type& parm);
   1162 
   1163     result_type min() const;
   1164     result_type max() const;
   1165 
   1166     friend bool operator==(const lognormal_distribution& x,
   1167                            const lognormal_distribution& y);
   1168     friend bool operator!=(const lognormal_distribution& x,
   1169                            const lognormal_distribution& y);
   1170 
   1171     template <class charT, class traits>
   1172     friend
   1173     basic_ostream<charT, traits>&
   1174     operator<<(basic_ostream<charT, traits>& os,
   1175                const lognormal_distribution& x);
   1176 
   1177     template <class charT, class traits>
   1178     friend
   1179     basic_istream<charT, traits>&
   1180     operator>>(basic_istream<charT, traits>& is,
   1181                lognormal_distribution& x);
   1182 };
   1183 
   1184 template<class RealType = double>
   1185 class chi_squared_distribution
   1186 {
   1187 public:
   1188     // types
   1189     typedef RealType result_type;
   1190 
   1191     class param_type
   1192     {
   1193     public:
   1194         typedef chi_squared_distribution distribution_type;
   1195 
   1196         explicit param_type(result_type n = 1);
   1197 
   1198         result_type n() const;
   1199 
   1200         friend bool operator==(const param_type& x, const param_type& y);
   1201         friend bool operator!=(const param_type& x, const param_type& y);
   1202     };
   1203 
   1204     // constructor and reset functions
   1205     explicit chi_squared_distribution(result_type n = 1);
   1206     explicit chi_squared_distribution(const param_type& parm);
   1207     void reset();
   1208 
   1209     // generating functions
   1210     template<class URNG> result_type operator()(URNG& g);
   1211     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1212 
   1213     // property functions
   1214     result_type n() const;
   1215 
   1216     param_type param() const;
   1217     void param(const param_type& parm);
   1218 
   1219     result_type min() const;
   1220     result_type max() const;
   1221 
   1222     friend bool operator==(const chi_squared_distribution& x,
   1223                            const chi_squared_distribution& y);
   1224     friend bool operator!=(const chi_squared_distribution& x,
   1225                            const chi_squared_distribution& y);
   1226 
   1227     template <class charT, class traits>
   1228     friend
   1229     basic_ostream<charT, traits>&
   1230     operator<<(basic_ostream<charT, traits>& os,
   1231                const chi_squared_distribution& x);
   1232 
   1233     template <class charT, class traits>
   1234     friend
   1235     basic_istream<charT, traits>&
   1236     operator>>(basic_istream<charT, traits>& is,
   1237                chi_squared_distribution& x);
   1238 };
   1239 
   1240 template<class RealType = double>
   1241 class cauchy_distribution
   1242 {
   1243 public:
   1244     // types
   1245     typedef RealType result_type;
   1246 
   1247     class param_type
   1248     {
   1249     public:
   1250         typedef cauchy_distribution distribution_type;
   1251 
   1252         explicit param_type(result_type a = 0, result_type b = 1);
   1253 
   1254         result_type a() const;
   1255         result_type b() const;
   1256 
   1257         friend bool operator==(const param_type& x, const param_type& y);
   1258         friend bool operator!=(const param_type& x, const param_type& y);
   1259     };
   1260 
   1261     // constructor and reset functions
   1262     explicit cauchy_distribution(result_type a = 0, result_type b = 1);
   1263     explicit cauchy_distribution(const param_type& parm);
   1264     void reset();
   1265 
   1266     // generating functions
   1267     template<class URNG> result_type operator()(URNG& g);
   1268     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1269 
   1270     // property functions
   1271     result_type a() const;
   1272     result_type b() const;
   1273 
   1274     param_type param() const;
   1275     void param(const param_type& parm);
   1276 
   1277     result_type min() const;
   1278     result_type max() const;
   1279 
   1280     friend bool operator==(const cauchy_distribution& x,
   1281                            const cauchy_distribution& y);
   1282     friend bool operator!=(const cauchy_distribution& x,
   1283                            const cauchy_distribution& y);
   1284 
   1285     template <class charT, class traits>
   1286     friend
   1287     basic_ostream<charT, traits>&
   1288     operator<<(basic_ostream<charT, traits>& os,
   1289                const cauchy_distribution& x);
   1290 
   1291     template <class charT, class traits>
   1292     friend
   1293     basic_istream<charT, traits>&
   1294     operator>>(basic_istream<charT, traits>& is,
   1295                cauchy_distribution& x);
   1296 };
   1297 
   1298 template<class RealType = double>
   1299 class fisher_f_distribution
   1300 {
   1301 public:
   1302     // types
   1303     typedef RealType result_type;
   1304 
   1305     class param_type
   1306     {
   1307     public:
   1308         typedef fisher_f_distribution distribution_type;
   1309 
   1310         explicit param_type(result_type m = 1, result_type n = 1);
   1311 
   1312         result_type m() const;
   1313         result_type n() const;
   1314 
   1315         friend bool operator==(const param_type& x, const param_type& y);
   1316         friend bool operator!=(const param_type& x, const param_type& y);
   1317     };
   1318 
   1319     // constructor and reset functions
   1320     explicit fisher_f_distribution(result_type m = 1, result_type n = 1);
   1321     explicit fisher_f_distribution(const param_type& parm);
   1322     void reset();
   1323 
   1324     // generating functions
   1325     template<class URNG> result_type operator()(URNG& g);
   1326     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1327 
   1328     // property functions
   1329     result_type m() const;
   1330     result_type n() const;
   1331 
   1332     param_type param() const;
   1333     void param(const param_type& parm);
   1334 
   1335     result_type min() const;
   1336     result_type max() const;
   1337 
   1338     friend bool operator==(const fisher_f_distribution& x,
   1339                            const fisher_f_distribution& y);
   1340     friend bool operator!=(const fisher_f_distribution& x,
   1341                            const fisher_f_distribution& y);
   1342 
   1343     template <class charT, class traits>
   1344     friend
   1345     basic_ostream<charT, traits>&
   1346     operator<<(basic_ostream<charT, traits>& os,
   1347                const fisher_f_distribution& x);
   1348 
   1349     template <class charT, class traits>
   1350     friend
   1351     basic_istream<charT, traits>&
   1352     operator>>(basic_istream<charT, traits>& is,
   1353                fisher_f_distribution& x);
   1354 };
   1355 
   1356 template<class RealType = double>
   1357 class student_t_distribution
   1358 {
   1359 public:
   1360     // types
   1361     typedef RealType result_type;
   1362 
   1363     class param_type
   1364     {
   1365     public:
   1366         typedef student_t_distribution distribution_type;
   1367 
   1368         explicit param_type(result_type n = 1);
   1369 
   1370         result_type n() const;
   1371 
   1372         friend bool operator==(const param_type& x, const param_type& y);
   1373         friend bool operator!=(const param_type& x, const param_type& y);
   1374     };
   1375 
   1376     // constructor and reset functions
   1377     explicit student_t_distribution(result_type n = 1);
   1378     explicit student_t_distribution(const param_type& parm);
   1379     void reset();
   1380 
   1381     // generating functions
   1382     template<class URNG> result_type operator()(URNG& g);
   1383     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1384 
   1385     // property functions
   1386     result_type n() const;
   1387 
   1388     param_type param() const;
   1389     void param(const param_type& parm);
   1390 
   1391     result_type min() const;
   1392     result_type max() const;
   1393 
   1394     friend bool operator==(const student_t_distribution& x,
   1395                            const student_t_distribution& y);
   1396     friend bool operator!=(const student_t_distribution& x,
   1397                            const student_t_distribution& y);
   1398 
   1399     template <class charT, class traits>
   1400     friend
   1401     basic_ostream<charT, traits>&
   1402     operator<<(basic_ostream<charT, traits>& os,
   1403                const student_t_distribution& x);
   1404 
   1405     template <class charT, class traits>
   1406     friend
   1407     basic_istream<charT, traits>&
   1408     operator>>(basic_istream<charT, traits>& is,
   1409                student_t_distribution& x);
   1410 };
   1411 
   1412 template<class IntType = int>
   1413 class discrete_distribution
   1414 {
   1415 public:
   1416     // types
   1417     typedef IntType result_type;
   1418 
   1419     class param_type
   1420     {
   1421     public:
   1422         typedef discrete_distribution distribution_type;
   1423 
   1424         param_type();
   1425         template<class InputIterator>
   1426             param_type(InputIterator firstW, InputIterator lastW);
   1427         param_type(initializer_list<double> wl);
   1428         template<class UnaryOperation>
   1429             param_type(size_t nw, double xmin, double xmax, UnaryOperation fw);
   1430 
   1431         vector<double> probabilities() const;
   1432 
   1433         friend bool operator==(const param_type& x, const param_type& y);
   1434         friend bool operator!=(const param_type& x, const param_type& y);
   1435     };
   1436 
   1437     // constructor and reset functions
   1438     discrete_distribution();
   1439     template<class InputIterator>
   1440         discrete_distribution(InputIterator firstW, InputIterator lastW);
   1441     discrete_distribution(initializer_list<double> wl);
   1442     template<class UnaryOperation>
   1443         discrete_distribution(size_t nw, double xmin, double xmax,
   1444                               UnaryOperation fw);
   1445     explicit discrete_distribution(const param_type& parm);
   1446     void reset();
   1447 
   1448     // generating functions
   1449     template<class URNG> result_type operator()(URNG& g);
   1450     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1451 
   1452     // property functions
   1453     vector<double> probabilities() const;
   1454 
   1455     param_type param() const;
   1456     void param(const param_type& parm);
   1457 
   1458     result_type min() const;
   1459     result_type max() const;
   1460 
   1461     friend bool operator==(const discrete_distribution& x,
   1462                            const discrete_distribution& y);
   1463     friend bool operator!=(const discrete_distribution& x,
   1464                            const discrete_distribution& y);
   1465 
   1466     template <class charT, class traits>
   1467     friend
   1468     basic_ostream<charT, traits>&
   1469     operator<<(basic_ostream<charT, traits>& os,
   1470                const discrete_distribution& x);
   1471 
   1472     template <class charT, class traits>
   1473     friend
   1474     basic_istream<charT, traits>&
   1475     operator>>(basic_istream<charT, traits>& is,
   1476                discrete_distribution& x);
   1477 };
   1478 
   1479 template<class RealType = double>
   1480 class piecewise_constant_distribution
   1481 {
   1482     // types
   1483     typedef RealType result_type;
   1484 
   1485     class param_type
   1486     {
   1487     public:
   1488         typedef piecewise_constant_distribution distribution_type;
   1489 
   1490         param_type();
   1491         template<class InputIteratorB, class InputIteratorW>
   1492             param_type(InputIteratorB firstB, InputIteratorB lastB,
   1493                        InputIteratorW firstW);
   1494         template<class UnaryOperation>
   1495             param_type(initializer_list<result_type> bl, UnaryOperation fw);
   1496         template<class UnaryOperation>
   1497             param_type(size_t nw, result_type xmin, result_type xmax,
   1498                        UnaryOperation fw);
   1499 
   1500         vector<result_type> intervals() const;
   1501         vector<result_type> densities() const;
   1502 
   1503         friend bool operator==(const param_type& x, const param_type& y);
   1504         friend bool operator!=(const param_type& x, const param_type& y);
   1505     };
   1506 
   1507     // constructor and reset functions
   1508     piecewise_constant_distribution();
   1509     template<class InputIteratorB, class InputIteratorW>
   1510         piecewise_constant_distribution(InputIteratorB firstB,
   1511                                         InputIteratorB lastB,
   1512                                         InputIteratorW firstW);
   1513     template<class UnaryOperation>
   1514         piecewise_constant_distribution(initializer_list<result_type> bl,
   1515                                         UnaryOperation fw);
   1516     template<class UnaryOperation>
   1517         piecewise_constant_distribution(size_t nw, result_type xmin,
   1518                                         result_type xmax, UnaryOperation fw);
   1519     explicit piecewise_constant_distribution(const param_type& parm);
   1520     void reset();
   1521 
   1522     // generating functions
   1523     template<class URNG> result_type operator()(URNG& g);
   1524     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1525 
   1526     // property functions
   1527     vector<result_type> intervals() const;
   1528     vector<result_type> densities() const;
   1529 
   1530     param_type param() const;
   1531     void param(const param_type& parm);
   1532 
   1533     result_type min() const;
   1534     result_type max() const;
   1535 
   1536     friend bool operator==(const piecewise_constant_distribution& x,
   1537                            const piecewise_constant_distribution& y);
   1538     friend bool operator!=(const piecewise_constant_distribution& x,
   1539                            const piecewise_constant_distribution& y);
   1540 
   1541     template <class charT, class traits>
   1542     friend
   1543     basic_ostream<charT, traits>&
   1544     operator<<(basic_ostream<charT, traits>& os,
   1545                const piecewise_constant_distribution& x);
   1546 
   1547     template <class charT, class traits>
   1548     friend
   1549     basic_istream<charT, traits>&
   1550     operator>>(basic_istream<charT, traits>& is,
   1551                piecewise_constant_distribution& x);
   1552 };
   1553 
   1554 template<class RealType = double>
   1555 class piecewise_linear_distribution
   1556 {
   1557     // types
   1558     typedef RealType result_type;
   1559 
   1560     class param_type
   1561     {
   1562     public:
   1563         typedef piecewise_linear_distribution distribution_type;
   1564 
   1565         param_type();
   1566         template<class InputIteratorB, class InputIteratorW>
   1567             param_type(InputIteratorB firstB, InputIteratorB lastB,
   1568                        InputIteratorW firstW);
   1569         template<class UnaryOperation>
   1570             param_type(initializer_list<result_type> bl, UnaryOperation fw);
   1571         template<class UnaryOperation>
   1572             param_type(size_t nw, result_type xmin, result_type xmax,
   1573                        UnaryOperation fw);
   1574 
   1575         vector<result_type> intervals() const;
   1576         vector<result_type> densities() const;
   1577 
   1578         friend bool operator==(const param_type& x, const param_type& y);
   1579         friend bool operator!=(const param_type& x, const param_type& y);
   1580     };
   1581 
   1582     // constructor and reset functions
   1583     piecewise_linear_distribution();
   1584     template<class InputIteratorB, class InputIteratorW>
   1585         piecewise_linear_distribution(InputIteratorB firstB,
   1586                                       InputIteratorB lastB,
   1587                                       InputIteratorW firstW);
   1588 
   1589     template<class UnaryOperation>
   1590         piecewise_linear_distribution(initializer_list<result_type> bl,
   1591                                       UnaryOperation fw);
   1592 
   1593     template<class UnaryOperation>
   1594         piecewise_linear_distribution(size_t nw, result_type xmin,
   1595                                       result_type xmax, UnaryOperation fw);
   1596 
   1597     explicit piecewise_linear_distribution(const param_type& parm);
   1598     void reset();
   1599 
   1600     // generating functions
   1601     template<class URNG> result_type operator()(URNG& g);
   1602     template<class URNG> result_type operator()(URNG& g, const param_type& parm);
   1603 
   1604     // property functions
   1605     vector<result_type> intervals() const;
   1606     vector<result_type> densities() const;
   1607 
   1608     param_type param() const;
   1609     void param(const param_type& parm);
   1610 
   1611     result_type min() const;
   1612     result_type max() const;
   1613 
   1614     friend bool operator==(const piecewise_linear_distribution& x,
   1615                            const piecewise_linear_distribution& y);
   1616     friend bool operator!=(const piecewise_linear_distribution& x,
   1617                            const piecewise_linear_distribution& y);
   1618 
   1619     template <class charT, class traits>
   1620     friend
   1621     basic_ostream<charT, traits>&
   1622     operator<<(basic_ostream<charT, traits>& os,
   1623                const piecewise_linear_distribution& x);
   1624 
   1625     template <class charT, class traits>
   1626     friend
   1627     basic_istream<charT, traits>&
   1628     operator>>(basic_istream<charT, traits>& is,
   1629                piecewise_linear_distribution& x);
   1630 };
   1631 
   1632 } // std
   1633 */
   1634 
   1635 #include <__config>
   1636 #include <cstddef>
   1637 #include <cstdint>
   1638 #include <cmath>
   1639 #include <type_traits>
   1640 #include <initializer_list>
   1641 #include <limits>
   1642 #include <algorithm>
   1643 #include <numeric>
   1644 #include <vector>
   1645 #include <string>
   1646 #include <istream>
   1647 #include <ostream>
   1648 
   1649 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
   1650 #pragma GCC system_header
   1651 #endif
   1652 
   1653 _LIBCPP_PUSH_MACROS
   1654 #include <__undef_macros>
   1655 
   1656 
   1657 _LIBCPP_BEGIN_NAMESPACE_STD
   1658 
   1659 // __is_seed_sequence
   1660 
   1661 template <class _Sseq, class _Engine>
   1662 struct __is_seed_sequence
   1663 {
   1664     static _LIBCPP_CONSTEXPR const bool value =
   1665               !is_convertible<_Sseq, typename _Engine::result_type>::value &&
   1666               !is_same<typename remove_cv<_Sseq>::type, _Engine>::value;
   1667 };
   1668 
   1669 // linear_congruential_engine
   1670 
   1671 template <unsigned long long __a, unsigned long long __c,
   1672           unsigned long long __m, unsigned long long _Mp,
   1673           bool _MightOverflow = (__a != 0 && __m != 0 && __m-1 > (_Mp-__c)/__a)>
   1674 struct __lce_ta;
   1675 
   1676 // 64
   1677 
   1678 template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
   1679 struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), true>
   1680 {
   1681     typedef unsigned long long result_type;
   1682     _LIBCPP_INLINE_VISIBILITY
   1683     static result_type next(result_type __x)
   1684     {
   1685         // Schrage's algorithm
   1686         const result_type __q = __m / __a;
   1687         const result_type __r = __m % __a;
   1688         const result_type __t0 = __a * (__x % __q);
   1689         const result_type __t1 = __r * (__x / __q);
   1690         __x = __t0 + (__t0 < __t1) * __m - __t1;
   1691         __x += __c - (__x >= __m - __c) * __m;
   1692         return __x;
   1693     }
   1694 };
   1695 
   1696 template <unsigned long long __a, unsigned long long __m>
   1697 struct __lce_ta<__a, 0, __m, (unsigned long long)(~0), true>
   1698 {
   1699     typedef unsigned long long result_type;
   1700     _LIBCPP_INLINE_VISIBILITY
   1701     static result_type next(result_type __x)
   1702     {
   1703         // Schrage's algorithm
   1704         const result_type __q = __m / __a;
   1705         const result_type __r = __m % __a;
   1706         const result_type __t0 = __a * (__x % __q);
   1707         const result_type __t1 = __r * (__x / __q);
   1708         __x = __t0 + (__t0 < __t1) * __m - __t1;
   1709         return __x;
   1710     }
   1711 };
   1712 
   1713 template <unsigned long long __a, unsigned long long __c, unsigned long long __m>
   1714 struct __lce_ta<__a, __c, __m, (unsigned long long)(~0), false>
   1715 {
   1716     typedef unsigned long long result_type;
   1717     _LIBCPP_INLINE_VISIBILITY
   1718     static result_type next(result_type __x)
   1719     {
   1720         return (__a * __x + __c) % __m;
   1721     }
   1722 };
   1723 
   1724 template <unsigned long long __a, unsigned long long __c>
   1725 struct __lce_ta<__a, __c, 0, (unsigned long long)(~0), false>
   1726 {
   1727     typedef unsigned long long result_type;
   1728     _LIBCPP_INLINE_VISIBILITY
   1729     static result_type next(result_type __x)
   1730     {
   1731         return __a * __x + __c;
   1732     }
   1733 };
   1734 
   1735 // 32
   1736 
   1737 template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
   1738 struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), true>
   1739 {
   1740     typedef unsigned result_type;
   1741     _LIBCPP_INLINE_VISIBILITY
   1742     static result_type next(result_type __x)
   1743     {
   1744         const result_type __a = static_cast<result_type>(_Ap);
   1745         const result_type __c = static_cast<result_type>(_Cp);
   1746         const result_type __m = static_cast<result_type>(_Mp);
   1747         // Schrage's algorithm
   1748         const result_type __q = __m / __a;
   1749         const result_type __r = __m % __a;
   1750         const result_type __t0 = __a * (__x % __q);
   1751         const result_type __t1 = __r * (__x / __q);
   1752         __x = __t0 + (__t0 < __t1) * __m - __t1;
   1753         __x += __c - (__x >= __m - __c) * __m;
   1754         return __x;
   1755     }
   1756 };
   1757 
   1758 template <unsigned long long _Ap, unsigned long long _Mp>
   1759 struct __lce_ta<_Ap, 0, _Mp, unsigned(~0), true>
   1760 {
   1761     typedef unsigned result_type;
   1762     _LIBCPP_INLINE_VISIBILITY
   1763     static result_type next(result_type __x)
   1764     {
   1765         const result_type __a = static_cast<result_type>(_Ap);
   1766         const result_type __m = static_cast<result_type>(_Mp);
   1767         // Schrage's algorithm
   1768         const result_type __q = __m / __a;
   1769         const result_type __r = __m % __a;
   1770         const result_type __t0 = __a * (__x % __q);
   1771         const result_type __t1 = __r * (__x / __q);
   1772         __x = __t0 + (__t0 < __t1) * __m - __t1;
   1773         return __x;
   1774     }
   1775 };
   1776 
   1777 template <unsigned long long _Ap, unsigned long long _Cp, unsigned long long _Mp>
   1778 struct __lce_ta<_Ap, _Cp, _Mp, unsigned(~0), false>
   1779 {
   1780     typedef unsigned result_type;
   1781     _LIBCPP_INLINE_VISIBILITY
   1782     static result_type next(result_type __x)
   1783     {
   1784         const result_type __a = static_cast<result_type>(_Ap);
   1785         const result_type __c = static_cast<result_type>(_Cp);
   1786         const result_type __m = static_cast<result_type>(_Mp);
   1787         return (__a * __x + __c) % __m;
   1788     }
   1789 };
   1790 
   1791 template <unsigned long long _Ap, unsigned long long _Cp>
   1792 struct __lce_ta<_Ap, _Cp, 0, unsigned(~0), false>
   1793 {
   1794     typedef unsigned result_type;
   1795     _LIBCPP_INLINE_VISIBILITY
   1796     static result_type next(result_type __x)
   1797     {
   1798         const result_type __a = static_cast<result_type>(_Ap);
   1799         const result_type __c = static_cast<result_type>(_Cp);
   1800         return __a * __x + __c;
   1801     }
   1802 };
   1803 
   1804 // 16
   1805 
   1806 template <unsigned long long __a, unsigned long long __c, unsigned long long __m, bool __b>
   1807 struct __lce_ta<__a, __c, __m, (unsigned short)(~0), __b>
   1808 {
   1809     typedef unsigned short result_type;
   1810     _LIBCPP_INLINE_VISIBILITY
   1811     static result_type next(result_type __x)
   1812     {
   1813         return static_cast<result_type>(__lce_ta<__a, __c, __m, unsigned(~0)>::next(__x));
   1814     }
   1815 };
   1816 
   1817 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1818 class _LIBCPP_TEMPLATE_VIS linear_congruential_engine;
   1819 
   1820 template <class _CharT, class _Traits,
   1821           class _Up, _Up _Ap, _Up _Cp, _Up _Np>
   1822 _LIBCPP_INLINE_VISIBILITY
   1823 basic_ostream<_CharT, _Traits>&
   1824 operator<<(basic_ostream<_CharT, _Traits>& __os,
   1825            const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
   1826 
   1827 template <class _CharT, class _Traits,
   1828           class _Up, _Up _Ap, _Up _Cp, _Up _Np>
   1829 basic_istream<_CharT, _Traits>&
   1830 operator>>(basic_istream<_CharT, _Traits>& __is,
   1831            linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
   1832 
   1833 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1834 class _LIBCPP_TEMPLATE_VIS linear_congruential_engine
   1835 {
   1836 public:
   1837     // types
   1838     typedef _UIntType result_type;
   1839 
   1840 private:
   1841     result_type __x_;
   1842 
   1843     static _LIBCPP_CONSTEXPR const result_type _Mp = result_type(~0);
   1844 
   1845     static_assert(__m == 0 || __a < __m, "linear_congruential_engine invalid parameters");
   1846     static_assert(__m == 0 || __c < __m, "linear_congruential_engine invalid parameters");
   1847 public:
   1848     static _LIBCPP_CONSTEXPR const result_type _Min = __c == 0u ? 1u: 0u;
   1849     static _LIBCPP_CONSTEXPR const result_type _Max = __m - 1u;
   1850     static_assert(_Min < _Max,           "linear_congruential_engine invalid parameters");
   1851 
   1852     // engine characteristics
   1853     static _LIBCPP_CONSTEXPR const result_type multiplier = __a;
   1854     static _LIBCPP_CONSTEXPR const result_type increment = __c;
   1855     static _LIBCPP_CONSTEXPR const result_type modulus = __m;
   1856     _LIBCPP_INLINE_VISIBILITY
   1857     static _LIBCPP_CONSTEXPR result_type min() {return _Min;}
   1858     _LIBCPP_INLINE_VISIBILITY
   1859     static _LIBCPP_CONSTEXPR result_type max() {return _Max;}
   1860     static _LIBCPP_CONSTEXPR const result_type default_seed = 1u;
   1861 
   1862     // constructors and seeding functions
   1863     _LIBCPP_INLINE_VISIBILITY
   1864     explicit linear_congruential_engine(result_type __s = default_seed)
   1865         {seed(__s);}
   1866     template<class _Sseq>
   1867         _LIBCPP_INLINE_VISIBILITY
   1868         explicit linear_congruential_engine(_Sseq& __q,
   1869         typename enable_if<__is_seed_sequence<_Sseq, linear_congruential_engine>::value>::type* = 0)
   1870         {seed(__q);}
   1871     _LIBCPP_INLINE_VISIBILITY
   1872     void seed(result_type __s = default_seed)
   1873         {seed(integral_constant<bool, __m == 0>(),
   1874               integral_constant<bool, __c == 0>(), __s);}
   1875     template<class _Sseq>
   1876         _LIBCPP_INLINE_VISIBILITY
   1877         typename enable_if
   1878         <
   1879             __is_seed_sequence<_Sseq, linear_congruential_engine>::value,
   1880             void
   1881         >::type
   1882         seed(_Sseq& __q)
   1883             {__seed(__q, integral_constant<unsigned,
   1884                 1 + (__m == 0 ? (sizeof(result_type) * __CHAR_BIT__ - 1)/32
   1885                              :  (__m > 0x100000000ull))>());}
   1886 
   1887     // generating functions
   1888     _LIBCPP_INLINE_VISIBILITY
   1889     result_type operator()()
   1890         {return __x_ = static_cast<result_type>(__lce_ta<__a, __c, __m, _Mp>::next(__x_));}
   1891     _LIBCPP_INLINE_VISIBILITY
   1892     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
   1893 
   1894     friend _LIBCPP_INLINE_VISIBILITY
   1895     bool operator==(const linear_congruential_engine& __x,
   1896                     const linear_congruential_engine& __y)
   1897         {return __x.__x_ == __y.__x_;}
   1898     friend _LIBCPP_INLINE_VISIBILITY
   1899     bool operator!=(const linear_congruential_engine& __x,
   1900                     const linear_congruential_engine& __y)
   1901         {return !(__x == __y);}
   1902 
   1903 private:
   1904 
   1905     _LIBCPP_INLINE_VISIBILITY
   1906     void seed(true_type, true_type, result_type __s) {__x_ = __s == 0 ? 1 : __s;}
   1907     _LIBCPP_INLINE_VISIBILITY
   1908     void seed(true_type, false_type, result_type __s) {__x_ = __s;}
   1909     _LIBCPP_INLINE_VISIBILITY
   1910     void seed(false_type, true_type, result_type __s) {__x_ = __s % __m == 0 ?
   1911                                                                  1 : __s % __m;}
   1912     _LIBCPP_INLINE_VISIBILITY
   1913     void seed(false_type, false_type, result_type __s) {__x_ = __s % __m;}
   1914 
   1915     template<class _Sseq>
   1916         void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
   1917     template<class _Sseq>
   1918         void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
   1919 
   1920     template <class _CharT, class _Traits,
   1921               class _Up, _Up _Ap, _Up _Cp, _Up _Np>
   1922     friend
   1923     basic_ostream<_CharT, _Traits>&
   1924     operator<<(basic_ostream<_CharT, _Traits>& __os,
   1925                const linear_congruential_engine<_Up, _Ap, _Cp, _Np>&);
   1926 
   1927     template <class _CharT, class _Traits,
   1928               class _Up, _Up _Ap, _Up _Cp, _Up _Np>
   1929     friend
   1930     basic_istream<_CharT, _Traits>&
   1931     operator>>(basic_istream<_CharT, _Traits>& __is,
   1932                linear_congruential_engine<_Up, _Ap, _Cp, _Np>& __x);
   1933 };
   1934 
   1935 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1936     _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
   1937     linear_congruential_engine<_UIntType, __a, __c, __m>::multiplier;
   1938 
   1939 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1940     _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
   1941     linear_congruential_engine<_UIntType, __a, __c, __m>::increment;
   1942 
   1943 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1944     _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
   1945     linear_congruential_engine<_UIntType, __a, __c, __m>::modulus;
   1946 
   1947 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1948     _LIBCPP_CONSTEXPR const typename linear_congruential_engine<_UIntType, __a, __c, __m>::result_type
   1949     linear_congruential_engine<_UIntType, __a, __c, __m>::default_seed;
   1950 
   1951 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1952 template<class _Sseq>
   1953 void
   1954 linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
   1955                                                  integral_constant<unsigned, 1>)
   1956 {
   1957     const unsigned __k = 1;
   1958     uint32_t __ar[__k+3];
   1959     __q.generate(__ar, __ar + __k + 3);
   1960     result_type __s = static_cast<result_type>(__ar[3] % __m);
   1961     __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
   1962 }
   1963 
   1964 template <class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1965 template<class _Sseq>
   1966 void
   1967 linear_congruential_engine<_UIntType, __a, __c, __m>::__seed(_Sseq& __q,
   1968                                                  integral_constant<unsigned, 2>)
   1969 {
   1970     const unsigned __k = 2;
   1971     uint32_t __ar[__k+3];
   1972     __q.generate(__ar, __ar + __k + 3);
   1973     result_type __s = static_cast<result_type>((__ar[3] +
   1974                                               ((uint64_t)__ar[4] << 32)) % __m);
   1975     __x_ = __c == 0 && __s == 0 ? result_type(1) : __s;
   1976 }
   1977 
   1978 template <class _CharT, class _Traits,
   1979           class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1980 inline _LIBCPP_INLINE_VISIBILITY
   1981 basic_ostream<_CharT, _Traits>&
   1982 operator<<(basic_ostream<_CharT, _Traits>& __os,
   1983            const linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
   1984 {
   1985     __save_flags<_CharT, _Traits> __lx(__os);
   1986     __os.flags(ios_base::dec | ios_base::left);
   1987     __os.fill(__os.widen(' '));
   1988     return __os << __x.__x_;
   1989 }
   1990 
   1991 template <class _CharT, class _Traits,
   1992           class _UIntType, _UIntType __a, _UIntType __c, _UIntType __m>
   1993 basic_istream<_CharT, _Traits>&
   1994 operator>>(basic_istream<_CharT, _Traits>& __is,
   1995            linear_congruential_engine<_UIntType, __a, __c, __m>& __x)
   1996 {
   1997     __save_flags<_CharT, _Traits> __lx(__is);
   1998     __is.flags(ios_base::dec | ios_base::skipws);
   1999     _UIntType __t;
   2000     __is >> __t;
   2001     if (!__is.fail())
   2002         __x.__x_ = __t;
   2003     return __is;
   2004 }
   2005 
   2006 typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647>
   2007                                                                    minstd_rand0;
   2008 typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647>
   2009                                                                     minstd_rand;
   2010 typedef minstd_rand                                       default_random_engine;
   2011 // mersenne_twister_engine
   2012 
   2013 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2014           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2015           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2016 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
   2017 
   2018 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2019           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2020           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2021 bool
   2022 operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2023                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
   2024            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2025                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
   2026 
   2027 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2028           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2029           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2030 _LIBCPP_INLINE_VISIBILITY
   2031 bool
   2032 operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2033                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
   2034            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2035                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
   2036 
   2037 template <class _CharT, class _Traits,
   2038           class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2039           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2040           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2041 basic_ostream<_CharT, _Traits>&
   2042 operator<<(basic_ostream<_CharT, _Traits>& __os,
   2043            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2044                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
   2045 
   2046 template <class _CharT, class _Traits,
   2047           class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2048           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2049           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2050 basic_istream<_CharT, _Traits>&
   2051 operator>>(basic_istream<_CharT, _Traits>& __is,
   2052            mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2053                                    _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
   2054 
   2055 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2056           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2057           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2058 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine
   2059 {
   2060 public:
   2061     // types
   2062     typedef _UIntType result_type;
   2063 
   2064 private:
   2065     result_type __x_[__n];
   2066     size_t      __i_;
   2067 
   2068     static_assert(  0 <  __m, "mersenne_twister_engine invalid parameters");
   2069     static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
   2070     static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
   2071     static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
   2072     static_assert(  2 <= __w, "mersenne_twister_engine invalid parameters");
   2073     static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
   2074     static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
   2075     static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
   2076     static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
   2077     static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
   2078 public:
   2079     static _LIBCPP_CONSTEXPR const result_type _Min = 0;
   2080     static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
   2081                                                       (result_type(1) << __w) - result_type(1);
   2082     static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
   2083     static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
   2084     static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
   2085     static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
   2086     static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
   2087     static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
   2088 
   2089     // engine characteristics
   2090     static _LIBCPP_CONSTEXPR const size_t word_size = __w;
   2091     static _LIBCPP_CONSTEXPR const size_t state_size = __n;
   2092     static _LIBCPP_CONSTEXPR const size_t shift_size = __m;
   2093     static _LIBCPP_CONSTEXPR const size_t mask_bits = __r;
   2094     static _LIBCPP_CONSTEXPR const result_type xor_mask = __a;
   2095     static _LIBCPP_CONSTEXPR const size_t tempering_u = __u;
   2096     static _LIBCPP_CONSTEXPR const result_type tempering_d = __d;
   2097     static _LIBCPP_CONSTEXPR const size_t tempering_s = __s;
   2098     static _LIBCPP_CONSTEXPR const result_type tempering_b = __b;
   2099     static _LIBCPP_CONSTEXPR const size_t tempering_t = __t;
   2100     static _LIBCPP_CONSTEXPR const result_type tempering_c = __c;
   2101     static _LIBCPP_CONSTEXPR const size_t tempering_l = __l;
   2102     static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
   2103     _LIBCPP_INLINE_VISIBILITY
   2104     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
   2105     _LIBCPP_INLINE_VISIBILITY
   2106     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
   2107     static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
   2108 
   2109     // constructors and seeding functions
   2110     _LIBCPP_INLINE_VISIBILITY
   2111     explicit mersenne_twister_engine(result_type __sd = default_seed)
   2112         {seed(__sd);}
   2113     template<class _Sseq>
   2114         _LIBCPP_INLINE_VISIBILITY
   2115         explicit mersenne_twister_engine(_Sseq& __q,
   2116         typename enable_if<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value>::type* = 0)
   2117         {seed(__q);}
   2118     void seed(result_type __sd = default_seed);
   2119     template<class _Sseq>
   2120         _LIBCPP_INLINE_VISIBILITY
   2121         typename enable_if
   2122         <
   2123             __is_seed_sequence<_Sseq, mersenne_twister_engine>::value,
   2124             void
   2125         >::type
   2126         seed(_Sseq& __q)
   2127             {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
   2128 
   2129     // generating functions
   2130     result_type operator()();
   2131     _LIBCPP_INLINE_VISIBILITY
   2132     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
   2133 
   2134     template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2135               _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2136               _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2137     friend
   2138     bool
   2139     operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2140                                              _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
   2141                const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2142                                              _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
   2143 
   2144     template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2145               _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2146               _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2147     friend
   2148     bool
   2149     operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2150                                              _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
   2151                const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2152                                              _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
   2153 
   2154     template <class _CharT, class _Traits,
   2155               class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2156               _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2157               _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2158     friend
   2159     basic_ostream<_CharT, _Traits>&
   2160     operator<<(basic_ostream<_CharT, _Traits>& __os,
   2161                const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2162                                              _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
   2163 
   2164     template <class _CharT, class _Traits,
   2165               class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2166               _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2167               _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2168     friend
   2169     basic_istream<_CharT, _Traits>&
   2170     operator>>(basic_istream<_CharT, _Traits>& __is,
   2171                mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2172                                        _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
   2173 private:
   2174 
   2175     template<class _Sseq>
   2176         void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
   2177     template<class _Sseq>
   2178         void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
   2179 
   2180     template <size_t __count>
   2181         _LIBCPP_INLINE_VISIBILITY
   2182         static
   2183         typename enable_if
   2184         <
   2185             __count < __w,
   2186             result_type
   2187         >::type
   2188         __lshift(result_type __x) {return (__x << __count) & _Max;}
   2189 
   2190     template <size_t __count>
   2191         _LIBCPP_INLINE_VISIBILITY
   2192         static
   2193         typename enable_if
   2194         <
   2195             (__count >= __w),
   2196             result_type
   2197         >::type
   2198         __lshift(result_type) {return result_type(0);}
   2199 
   2200     template <size_t __count>
   2201         _LIBCPP_INLINE_VISIBILITY
   2202         static
   2203         typename enable_if
   2204         <
   2205             __count < _Dt,
   2206             result_type
   2207         >::type
   2208         __rshift(result_type __x) {return __x >> __count;}
   2209 
   2210     template <size_t __count>
   2211         _LIBCPP_INLINE_VISIBILITY
   2212         static
   2213         typename enable_if
   2214         <
   2215             (__count >= _Dt),
   2216             result_type
   2217         >::type
   2218         __rshift(result_type) {return result_type(0);}
   2219 };
   2220 
   2221 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2222           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2223           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2224     _LIBCPP_CONSTEXPR const size_t
   2225     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
   2226 
   2227 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2228           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2229           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2230     _LIBCPP_CONSTEXPR const size_t 
   2231     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
   2232 
   2233 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2234           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2235           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2236     _LIBCPP_CONSTEXPR const size_t 
   2237     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
   2238 
   2239 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2240           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2241           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2242     _LIBCPP_CONSTEXPR const size_t 
   2243     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
   2244 
   2245 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2246           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2247           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2248     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
   2249     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
   2250 
   2251 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2252           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2253           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2254     _LIBCPP_CONSTEXPR const size_t 
   2255     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
   2256 
   2257 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2258           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2259           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2260     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
   2261     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
   2262 
   2263 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2264           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2265           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2266     _LIBCPP_CONSTEXPR const size_t 
   2267     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
   2268 
   2269 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2270           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2271           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2272     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
   2273     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
   2274 
   2275 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2276           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2277           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2278     _LIBCPP_CONSTEXPR const size_t 
   2279     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
   2280 
   2281 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2282           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2283           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2284     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
   2285     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
   2286 
   2287 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2288           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2289           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2290     _LIBCPP_CONSTEXPR const size_t 
   2291     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
   2292 
   2293 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2294           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2295           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2296     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
   2297     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::initialization_multiplier;
   2298 
   2299 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2300           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2301           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2302     _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::result_type
   2303     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;
   2304 
   2305 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2306           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2307           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2308 void
   2309 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
   2310     __t, __c, __l, __f>::seed(result_type __sd)
   2311     _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
   2312 {   // __w >= 2
   2313     __x_[0] = __sd & _Max;
   2314     for (size_t __i = 1; __i < __n; ++__i)
   2315         __x_[__i] = (__f * (__x_[__i-1] ^ __rshift<__w - 2>(__x_[__i-1])) + __i) & _Max;
   2316     __i_ = 0;
   2317 }
   2318 
   2319 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2320           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2321           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2322 template<class _Sseq>
   2323 void
   2324 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
   2325     __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 1>)
   2326 {
   2327     const unsigned __k = 1;
   2328     uint32_t __ar[__n * __k];
   2329     __q.generate(__ar, __ar + __n * __k);
   2330     for (size_t __i = 0; __i < __n; ++__i)
   2331         __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
   2332     const result_type __mask = __r == _Dt ? result_type(~0) :
   2333                                        (result_type(1) << __r) - result_type(1);
   2334     __i_ = 0;
   2335     if ((__x_[0] & ~__mask) == 0)
   2336     {
   2337         for (size_t __i = 1; __i < __n; ++__i)
   2338             if (__x_[__i] != 0)
   2339                 return;
   2340         __x_[0] = _Max;
   2341     }
   2342 }
   2343 
   2344 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2345           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2346           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2347 template<class _Sseq>
   2348 void
   2349 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
   2350     __t, __c, __l, __f>::__seed(_Sseq& __q, integral_constant<unsigned, 2>)
   2351 {
   2352     const unsigned __k = 2;
   2353     uint32_t __ar[__n * __k];
   2354     __q.generate(__ar, __ar + __n * __k);
   2355     for (size_t __i = 0; __i < __n; ++__i)
   2356         __x_[__i] = static_cast<result_type>(
   2357             (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
   2358     const result_type __mask = __r == _Dt ? result_type(~0) :
   2359                                        (result_type(1) << __r) - result_type(1);
   2360     __i_ = 0;
   2361     if ((__x_[0] & ~__mask) == 0)
   2362     {
   2363         for (size_t __i = 1; __i < __n; ++__i)
   2364             if (__x_[__i] != 0)
   2365                 return;
   2366         __x_[0] = _Max;
   2367     }
   2368 }
   2369 
   2370 template <class _UIntType, size_t __w, size_t __n, size_t __m, size_t __r,
   2371           _UIntType __a, size_t __u, _UIntType __d, size_t __s,
   2372           _UIntType __b, size_t __t, _UIntType __c, size_t __l, _UIntType __f>
   2373 _UIntType
   2374 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b,
   2375     __t, __c, __l, __f>::operator()()
   2376 {
   2377     const size_t __j = (__i_ + 1) % __n;
   2378     const result_type __mask = __r == _Dt ? result_type(~0) :
   2379                                        (result_type(1) << __r) - result_type(1);
   2380     const result_type _Yp = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
   2381     const size_t __k = (__i_ + __m) % __n;
   2382     __x_[__i_] = __x_[__k] ^ __rshift<1>(_Yp) ^ (__a * (_Yp & 1));
   2383     result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
   2384     __i_ = __j;
   2385     __z ^= __lshift<__s>(__z) & __b;
   2386     __z ^= __lshift<__t>(__z) & __c;
   2387     return __z ^ __rshift<__l>(__z);
   2388 }
   2389 
   2390 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2391           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2392           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2393 bool
   2394 operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2395                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
   2396            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2397                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
   2398 {
   2399     if (__x.__i_ == __y.__i_)
   2400         return _VSTD::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
   2401     if (__x.__i_ == 0 || __y.__i_ == 0)
   2402     {
   2403         size_t __j = _VSTD::min(_Np - __x.__i_, _Np - __y.__i_);
   2404         if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
   2405                          __y.__x_ + __y.__i_))
   2406             return false;
   2407         if (__x.__i_ == 0)
   2408             return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
   2409         return _VSTD::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
   2410     }
   2411     if (__x.__i_ < __y.__i_)
   2412     {
   2413         size_t __j = _Np - __y.__i_;
   2414         if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
   2415                          __y.__x_ + __y.__i_))
   2416             return false;
   2417         if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np,
   2418                          __y.__x_))
   2419             return false;
   2420         return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
   2421                            __y.__x_ + (_Np - (__x.__i_ + __j)));
   2422     }
   2423     size_t __j = _Np - __x.__i_;
   2424     if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
   2425                      __x.__x_ + __x.__i_))
   2426         return false;
   2427     if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np,
   2428                      __x.__x_))
   2429         return false;
   2430     return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
   2431                        __x.__x_ + (_Np - (__y.__i_ + __j)));
   2432 }
   2433 
   2434 template <class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2435           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2436           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2437 inline _LIBCPP_INLINE_VISIBILITY
   2438 bool
   2439 operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2440                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
   2441            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2442                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __y)
   2443 {
   2444     return !(__x == __y);
   2445 }
   2446 
   2447 template <class _CharT, class _Traits,
   2448           class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2449           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2450           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2451 basic_ostream<_CharT, _Traits>&
   2452 operator<<(basic_ostream<_CharT, _Traits>& __os,
   2453            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2454                                          _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
   2455 {
   2456     __save_flags<_CharT, _Traits> __lx(__os);
   2457     __os.flags(ios_base::dec | ios_base::left);
   2458     _CharT __sp = __os.widen(' ');
   2459     __os.fill(__sp);
   2460     __os << __x.__x_[__x.__i_];
   2461     for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
   2462         __os << __sp << __x.__x_[__j];
   2463     for (size_t __j = 0; __j < __x.__i_; ++__j)
   2464         __os << __sp << __x.__x_[__j];
   2465     return __os;
   2466 }
   2467 
   2468 template <class _CharT, class _Traits,
   2469           class _UInt, size_t _Wp, size_t _Np, size_t _Mp, size_t _Rp,
   2470           _UInt _Ap, size_t _Up, _UInt _Dp, size_t _Sp,
   2471           _UInt _Bp, size_t _Tp, _UInt _Cp, size_t _Lp, _UInt _Fp>
   2472 basic_istream<_CharT, _Traits>&
   2473 operator>>(basic_istream<_CharT, _Traits>& __is,
   2474            mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp,
   2475                                    _Bp, _Tp, _Cp, _Lp, _Fp>& __x)
   2476 {
   2477     __save_flags<_CharT, _Traits> __lx(__is);
   2478     __is.flags(ios_base::dec | ios_base::skipws);
   2479     _UInt __t[_Np];
   2480     for (size_t __i = 0; __i < _Np; ++__i)
   2481         __is >> __t[__i];
   2482     if (!__is.fail())
   2483     {
   2484         for (size_t __i = 0; __i < _Np; ++__i)
   2485             __x.__x_[__i] = __t[__i];
   2486         __x.__i_ = 0;
   2487     }
   2488     return __is;
   2489 }
   2490 
   2491 typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31,
   2492                                 0x9908b0df, 11, 0xffffffff,
   2493                                 7,  0x9d2c5680,
   2494                                 15, 0xefc60000,
   2495                                 18, 1812433253>                         mt19937;
   2496 typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31,
   2497                                 0xb5026f5aa96619e9ULL, 29, 0x5555555555555555ULL,
   2498                                 17, 0x71d67fffeda60000ULL,
   2499                                 37, 0xfff7eee000000000ULL,
   2500                                 43, 6364136223846793005ULL>          mt19937_64;
   2501 
   2502 // subtract_with_carry_engine
   2503 
   2504 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2505 class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine;
   2506 
   2507 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2508 bool
   2509 operator==(
   2510     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
   2511     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
   2512 
   2513 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2514 _LIBCPP_INLINE_VISIBILITY
   2515 bool
   2516 operator!=(
   2517     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
   2518     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
   2519 
   2520 template <class _CharT, class _Traits,
   2521           class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2522 basic_ostream<_CharT, _Traits>&
   2523 operator<<(basic_ostream<_CharT, _Traits>& __os,
   2524            const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
   2525 
   2526 template <class _CharT, class _Traits,
   2527           class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2528 basic_istream<_CharT, _Traits>&
   2529 operator>>(basic_istream<_CharT, _Traits>& __is,
   2530            subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
   2531 
   2532 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2533 class _LIBCPP_TEMPLATE_VIS subtract_with_carry_engine
   2534 {
   2535 public:
   2536     // types
   2537     typedef _UIntType result_type;
   2538 
   2539 private:
   2540     result_type __x_[__r];
   2541     result_type  __c_;
   2542     size_t      __i_;
   2543 
   2544     static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
   2545     static_assert(  0 <  __w, "subtract_with_carry_engine invalid parameters");
   2546     static_assert(__w <= _Dt, "subtract_with_carry_engine invalid parameters");
   2547     static_assert(  0 <  __s, "subtract_with_carry_engine invalid parameters");
   2548     static_assert(__s <  __r, "subtract_with_carry_engine invalid parameters");
   2549 public:
   2550     static _LIBCPP_CONSTEXPR const result_type _Min = 0;
   2551     static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
   2552                                                       (result_type(1) << __w) - result_type(1);
   2553     static_assert(_Min < _Max, "subtract_with_carry_engine invalid parameters");
   2554 
   2555     // engine characteristics
   2556     static _LIBCPP_CONSTEXPR const size_t word_size = __w;
   2557     static _LIBCPP_CONSTEXPR const size_t short_lag = __s;
   2558     static _LIBCPP_CONSTEXPR const size_t long_lag = __r;
   2559     _LIBCPP_INLINE_VISIBILITY
   2560     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
   2561     _LIBCPP_INLINE_VISIBILITY
   2562     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
   2563     static _LIBCPP_CONSTEXPR const result_type default_seed = 19780503u;
   2564 
   2565     // constructors and seeding functions
   2566     _LIBCPP_INLINE_VISIBILITY
   2567     explicit subtract_with_carry_engine(result_type __sd = default_seed)
   2568         {seed(__sd);}
   2569     template<class _Sseq>
   2570         _LIBCPP_INLINE_VISIBILITY
   2571         explicit subtract_with_carry_engine(_Sseq& __q,
   2572         typename enable_if<__is_seed_sequence<_Sseq, subtract_with_carry_engine>::value>::type* = 0)
   2573         {seed(__q);}
   2574     _LIBCPP_INLINE_VISIBILITY
   2575     void seed(result_type __sd = default_seed)
   2576         {seed(__sd, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
   2577     template<class _Sseq>
   2578         _LIBCPP_INLINE_VISIBILITY
   2579         typename enable_if
   2580         <
   2581             __is_seed_sequence<_Sseq, subtract_with_carry_engine>::value,
   2582             void
   2583         >::type
   2584         seed(_Sseq& __q)
   2585             {__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());}
   2586 
   2587     // generating functions
   2588     result_type operator()();
   2589     _LIBCPP_INLINE_VISIBILITY
   2590     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
   2591 
   2592     template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2593     friend
   2594     bool
   2595     operator==(
   2596         const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
   2597         const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
   2598 
   2599     template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2600     friend
   2601     bool
   2602     operator!=(
   2603         const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
   2604         const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y);
   2605 
   2606     template <class _CharT, class _Traits,
   2607               class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2608     friend
   2609     basic_ostream<_CharT, _Traits>&
   2610     operator<<(basic_ostream<_CharT, _Traits>& __os,
   2611                const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
   2612 
   2613     template <class _CharT, class _Traits,
   2614               class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2615     friend
   2616     basic_istream<_CharT, _Traits>&
   2617     operator>>(basic_istream<_CharT, _Traits>& __is,
   2618                subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x);
   2619 
   2620 private:
   2621 
   2622     void seed(result_type __sd, integral_constant<unsigned, 1>);
   2623     void seed(result_type __sd, integral_constant<unsigned, 2>);
   2624     template<class _Sseq>
   2625         void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
   2626     template<class _Sseq>
   2627         void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
   2628 };
   2629 
   2630 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2631     _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::word_size;
   2632 
   2633 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2634     _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::short_lag;
   2635 
   2636 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2637     _LIBCPP_CONSTEXPR const size_t subtract_with_carry_engine<_UIntType, __w, __s, __r>::long_lag;
   2638 
   2639 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2640     _LIBCPP_CONSTEXPR const typename subtract_with_carry_engine<_UIntType, __w, __s, __r>::result_type
   2641     subtract_with_carry_engine<_UIntType, __w, __s, __r>::default_seed;
   2642 
   2643 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2644 void
   2645 subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
   2646         integral_constant<unsigned, 1>)
   2647 {
   2648     linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
   2649         __e(__sd == 0u ? default_seed : __sd);
   2650     for (size_t __i = 0; __i < __r; ++__i)
   2651         __x_[__i] = static_cast<result_type>(__e() & _Max);
   2652     __c_ = __x_[__r-1] == 0;
   2653     __i_ = 0;
   2654 }
   2655 
   2656 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2657 void
   2658 subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
   2659         integral_constant<unsigned, 2>)
   2660 {
   2661     linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
   2662         __e(__sd == 0u ? default_seed : __sd);
   2663     for (size_t __i = 0; __i < __r; ++__i)
   2664     {
   2665         result_type __e0 = __e();
   2666         __x_[__i] = static_cast<result_type>(
   2667                                     (__e0 + ((uint64_t)__e() << 32)) & _Max);
   2668     }
   2669     __c_ = __x_[__r-1] == 0;
   2670     __i_ = 0;
   2671 }
   2672 
   2673 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2674 template<class _Sseq>
   2675 void
   2676 subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
   2677         integral_constant<unsigned, 1>)
   2678 {
   2679     const unsigned __k = 1;
   2680     uint32_t __ar[__r * __k];
   2681     __q.generate(__ar, __ar + __r * __k);
   2682     for (size_t __i = 0; __i < __r; ++__i)
   2683         __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
   2684     __c_ = __x_[__r-1] == 0;
   2685     __i_ = 0;
   2686 }
   2687 
   2688 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2689 template<class _Sseq>
   2690 void
   2691 subtract_with_carry_engine<_UIntType, __w, __s, __r>::__seed(_Sseq& __q,
   2692         integral_constant<unsigned, 2>)
   2693 {
   2694     const unsigned __k = 2;
   2695     uint32_t __ar[__r * __k];
   2696     __q.generate(__ar, __ar + __r * __k);
   2697     for (size_t __i = 0; __i < __r; ++__i)
   2698         __x_[__i] = static_cast<result_type>(
   2699                   (__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
   2700     __c_ = __x_[__r-1] == 0;
   2701     __i_ = 0;
   2702 }
   2703 
   2704 template<class _UIntType, size_t __w, size_t __s, size_t __r>
   2705 _UIntType
   2706 subtract_with_carry_engine<_UIntType, __w, __s, __r>::operator()()
   2707 {
   2708     const result_type& __xs = __x_[(__i_ + (__r - __s)) % __r];
   2709     result_type& __xr = __x_[__i_];
   2710     result_type __new_c = __c_ == 0 ? __xs < __xr : __xs != 0 ? __xs <= __xr : 1;
   2711     __xr = (__xs - __xr - __c_) & _Max;
   2712     __c_ = __new_c;
   2713     __i_ = (__i_ + 1) % __r;
   2714     return __xr;
   2715 }
   2716 
   2717 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2718 bool
   2719 operator==(
   2720     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
   2721     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
   2722 {
   2723     if (__x.__c_ != __y.__c_)
   2724         return false;
   2725     if (__x.__i_ == __y.__i_)
   2726         return _VSTD::equal(__x.__x_, __x.__x_ + _Rp, __y.__x_);
   2727     if (__x.__i_ == 0 || __y.__i_ == 0)
   2728     {
   2729         size_t __j = _VSTD::min(_Rp - __x.__i_, _Rp - __y.__i_);
   2730         if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
   2731                          __y.__x_ + __y.__i_))
   2732             return false;
   2733         if (__x.__i_ == 0)
   2734             return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _Rp, __y.__x_);
   2735         return _VSTD::equal(__x.__x_, __x.__x_ + (_Rp - __j), __y.__x_ + __j);
   2736     }
   2737     if (__x.__i_ < __y.__i_)
   2738     {
   2739         size_t __j = _Rp - __y.__i_;
   2740         if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
   2741                          __y.__x_ + __y.__i_))
   2742             return false;
   2743         if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Rp,
   2744                          __y.__x_))
   2745             return false;
   2746         return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
   2747                            __y.__x_ + (_Rp - (__x.__i_ + __j)));
   2748     }
   2749     size_t __j = _Rp - __x.__i_;
   2750     if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
   2751                      __x.__x_ + __x.__i_))
   2752         return false;
   2753     if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Rp,
   2754                      __x.__x_))
   2755         return false;
   2756     return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
   2757                        __x.__x_ + (_Rp - (__y.__i_ + __j)));
   2758 }
   2759 
   2760 template<class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2761 inline _LIBCPP_INLINE_VISIBILITY
   2762 bool
   2763 operator!=(
   2764     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x,
   2765     const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __y)
   2766 {
   2767     return !(__x == __y);
   2768 }
   2769 
   2770 template <class _CharT, class _Traits,
   2771           class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2772 basic_ostream<_CharT, _Traits>&
   2773 operator<<(basic_ostream<_CharT, _Traits>& __os,
   2774            const subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
   2775 {
   2776     __save_flags<_CharT, _Traits> __lx(__os);
   2777     __os.flags(ios_base::dec | ios_base::left);
   2778     _CharT __sp = __os.widen(' ');
   2779     __os.fill(__sp);
   2780     __os << __x.__x_[__x.__i_];
   2781     for (size_t __j = __x.__i_ + 1; __j < _Rp; ++__j)
   2782         __os << __sp << __x.__x_[__j];
   2783     for (size_t __j = 0; __j < __x.__i_; ++__j)
   2784         __os << __sp << __x.__x_[__j];
   2785     __os << __sp << __x.__c_;
   2786     return __os;
   2787 }
   2788 
   2789 template <class _CharT, class _Traits,
   2790           class _UInt, size_t _Wp, size_t _Sp, size_t _Rp>
   2791 basic_istream<_CharT, _Traits>&
   2792 operator>>(basic_istream<_CharT, _Traits>& __is,
   2793            subtract_with_carry_engine<_UInt, _Wp, _Sp, _Rp>& __x)
   2794 {
   2795     __save_flags<_CharT, _Traits> __lx(__is);
   2796     __is.flags(ios_base::dec | ios_base::skipws);
   2797     _UInt __t[_Rp+1];
   2798     for (size_t __i = 0; __i < _Rp+1; ++__i)
   2799         __is >> __t[__i];
   2800     if (!__is.fail())
   2801     {
   2802         for (size_t __i = 0; __i < _Rp; ++__i)
   2803             __x.__x_[__i] = __t[__i];
   2804         __x.__c_ = __t[_Rp];
   2805         __x.__i_ = 0;
   2806     }
   2807     return __is;
   2808 }
   2809 
   2810 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24>     ranlux24_base;
   2811 typedef subtract_with_carry_engine<uint_fast64_t, 48,  5, 12>     ranlux48_base;
   2812 
   2813 // discard_block_engine
   2814 
   2815 template<class _Engine, size_t __p, size_t __r>
   2816 class _LIBCPP_TEMPLATE_VIS discard_block_engine
   2817 {
   2818     _Engine __e_;
   2819     int     __n_;
   2820 
   2821     static_assert(  0 <  __r, "discard_block_engine invalid parameters");
   2822     static_assert(__r <= __p, "discard_block_engine invalid parameters");
   2823     static_assert(__r <= INT_MAX, "discard_block_engine invalid parameters");
   2824 public:
   2825     // types
   2826     typedef typename _Engine::result_type result_type;
   2827 
   2828     // engine characteristics
   2829     static _LIBCPP_CONSTEXPR const size_t block_size = __p;
   2830     static _LIBCPP_CONSTEXPR const size_t used_block = __r;
   2831 
   2832 #ifdef _LIBCPP_CXX03_LANG
   2833     static const result_type _Min = _Engine::_Min;
   2834     static const result_type _Max = _Engine::_Max;
   2835 #else
   2836     static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
   2837     static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
   2838 #endif
   2839 
   2840     _LIBCPP_INLINE_VISIBILITY
   2841     static _LIBCPP_CONSTEXPR result_type min() { return _Engine::min(); }
   2842     _LIBCPP_INLINE_VISIBILITY
   2843     static _LIBCPP_CONSTEXPR result_type max() { return _Engine::max(); }
   2844 
   2845     // constructors and seeding functions
   2846     _LIBCPP_INLINE_VISIBILITY
   2847     discard_block_engine() : __n_(0) {}
   2848     _LIBCPP_INLINE_VISIBILITY
   2849     explicit discard_block_engine(const _Engine& __e)
   2850         : __e_(__e), __n_(0) {}
   2851 #ifndef _LIBCPP_CXX03_LANG
   2852     _LIBCPP_INLINE_VISIBILITY
   2853     explicit discard_block_engine(_Engine&& __e)
   2854         : __e_(_VSTD::move(__e)), __n_(0) {}
   2855 #endif  // _LIBCPP_CXX03_LANG
   2856     _LIBCPP_INLINE_VISIBILITY
   2857     explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
   2858     template<class _Sseq>
   2859         _LIBCPP_INLINE_VISIBILITY
   2860         explicit discard_block_engine(_Sseq& __q,
   2861         typename enable_if<__is_seed_sequence<_Sseq, discard_block_engine>::value &&
   2862                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
   2863         : __e_(__q), __n_(0) {}
   2864     _LIBCPP_INLINE_VISIBILITY
   2865     void seed() {__e_.seed(); __n_ = 0;}
   2866     _LIBCPP_INLINE_VISIBILITY
   2867     void seed(result_type __sd) {__e_.seed(__sd); __n_ = 0;}
   2868     template<class _Sseq>
   2869         _LIBCPP_INLINE_VISIBILITY
   2870         typename enable_if
   2871         <
   2872             __is_seed_sequence<_Sseq, discard_block_engine>::value,
   2873             void
   2874         >::type
   2875         seed(_Sseq& __q) {__e_.seed(__q); __n_ = 0;}
   2876 
   2877     // generating functions
   2878     result_type operator()();
   2879     _LIBCPP_INLINE_VISIBILITY
   2880     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
   2881 
   2882     // property functions
   2883     _LIBCPP_INLINE_VISIBILITY
   2884     const _Engine& base() const _NOEXCEPT {return __e_;}
   2885 
   2886     template<class _Eng, size_t _Pp, size_t _Rp>
   2887     friend
   2888     bool
   2889     operator==(
   2890         const discard_block_engine<_Eng, _Pp, _Rp>& __x,
   2891         const discard_block_engine<_Eng, _Pp, _Rp>& __y);
   2892 
   2893     template<class _Eng, size_t _Pp, size_t _Rp>
   2894     friend
   2895     bool
   2896     operator!=(
   2897         const discard_block_engine<_Eng, _Pp, _Rp>& __x,
   2898         const discard_block_engine<_Eng, _Pp, _Rp>& __y);
   2899 
   2900     template <class _CharT, class _Traits,
   2901               class _Eng, size_t _Pp, size_t _Rp>
   2902     friend
   2903     basic_ostream<_CharT, _Traits>&
   2904     operator<<(basic_ostream<_CharT, _Traits>& __os,
   2905                const discard_block_engine<_Eng, _Pp, _Rp>& __x);
   2906 
   2907     template <class _CharT, class _Traits,
   2908               class _Eng, size_t _Pp, size_t _Rp>
   2909     friend
   2910     basic_istream<_CharT, _Traits>&
   2911     operator>>(basic_istream<_CharT, _Traits>& __is,
   2912                discard_block_engine<_Eng, _Pp, _Rp>& __x);
   2913 };
   2914 
   2915 template<class _Engine, size_t __p, size_t __r>
   2916     _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::block_size;
   2917 
   2918 template<class _Engine, size_t __p, size_t __r>
   2919     _LIBCPP_CONSTEXPR const size_t discard_block_engine<_Engine, __p, __r>::used_block;
   2920 
   2921 template<class _Engine, size_t __p, size_t __r>
   2922 typename discard_block_engine<_Engine, __p, __r>::result_type
   2923 discard_block_engine<_Engine, __p, __r>::operator()()
   2924 {
   2925     if (__n_ >= static_cast<int>(__r))
   2926     {
   2927         __e_.discard(__p - __r);
   2928         __n_ = 0;
   2929     }
   2930     ++__n_;
   2931     return __e_();
   2932 }
   2933 
   2934 template<class _Eng, size_t _Pp, size_t _Rp>
   2935 inline _LIBCPP_INLINE_VISIBILITY
   2936 bool
   2937 operator==(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
   2938            const discard_block_engine<_Eng, _Pp, _Rp>& __y)
   2939 {
   2940     return __x.__n_ == __y.__n_ && __x.__e_ == __y.__e_;
   2941 }
   2942 
   2943 template<class _Eng, size_t _Pp, size_t _Rp>
   2944 inline _LIBCPP_INLINE_VISIBILITY
   2945 bool
   2946 operator!=(const discard_block_engine<_Eng, _Pp, _Rp>& __x,
   2947            const discard_block_engine<_Eng, _Pp, _Rp>& __y)
   2948 {
   2949     return !(__x == __y);
   2950 }
   2951 
   2952 template <class _CharT, class _Traits,
   2953           class _Eng, size_t _Pp, size_t _Rp>
   2954 basic_ostream<_CharT, _Traits>&
   2955 operator<<(basic_ostream<_CharT, _Traits>& __os,
   2956            const discard_block_engine<_Eng, _Pp, _Rp>& __x)
   2957 {
   2958     __save_flags<_CharT, _Traits> __lx(__os);
   2959     __os.flags(ios_base::dec | ios_base::left);
   2960     _CharT __sp = __os.widen(' ');
   2961     __os.fill(__sp);
   2962     return __os << __x.__e_ << __sp << __x.__n_;
   2963 }
   2964 
   2965 template <class _CharT, class _Traits,
   2966           class _Eng, size_t _Pp, size_t _Rp>
   2967 basic_istream<_CharT, _Traits>&
   2968 operator>>(basic_istream<_CharT, _Traits>& __is,
   2969            discard_block_engine<_Eng, _Pp, _Rp>& __x)
   2970 {
   2971     __save_flags<_CharT, _Traits> __lx(__is);
   2972     __is.flags(ios_base::dec | ios_base::skipws);
   2973     _Eng __e;
   2974     int __n;
   2975     __is >> __e >> __n;
   2976     if (!__is.fail())
   2977     {
   2978         __x.__e_ = __e;
   2979         __x.__n_ = __n;
   2980     }
   2981     return __is;
   2982 }
   2983 
   2984 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24;
   2985 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48;
   2986 
   2987 // independent_bits_engine
   2988 
   2989 template<class _Engine, size_t __w, class _UIntType>
   2990 class _LIBCPP_TEMPLATE_VIS independent_bits_engine
   2991 {
   2992     template <class _UInt, _UInt _R0, size_t _Wp, size_t _Mp>
   2993     class __get_n
   2994     {
   2995         static _LIBCPP_CONSTEXPR const size_t _Dt = numeric_limits<_UInt>::digits;
   2996         static _LIBCPP_CONSTEXPR const size_t _Np = _Wp / _Mp + (_Wp % _Mp != 0);
   2997         static _LIBCPP_CONSTEXPR const size_t _W0 = _Wp / _Np;
   2998         static _LIBCPP_CONSTEXPR const _UInt _Y0 = _W0 >= _Dt ? 0 : (_R0 >> _W0) << _W0;
   2999     public:
   3000         static _LIBCPP_CONSTEXPR const size_t value = _R0 - _Y0 > _Y0 / _Np ? _Np + 1 : _Np;
   3001     };
   3002 public:
   3003     // types
   3004     typedef _UIntType result_type;
   3005 
   3006 private:
   3007     _Engine __e_;
   3008 
   3009     static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
   3010     static_assert(  0 <  __w, "independent_bits_engine invalid parameters");
   3011     static_assert(__w <= _Dt, "independent_bits_engine invalid parameters");
   3012 
   3013     typedef typename _Engine::result_type _Engine_result_type;
   3014     typedef typename conditional
   3015         <
   3016             sizeof(_Engine_result_type) <= sizeof(result_type),
   3017                 result_type,
   3018                 _Engine_result_type
   3019         >::type _Working_result_type;
   3020 #ifdef _LIBCPP_CXX03_LANG
   3021     static const _Working_result_type _Rp = _Engine::_Max - _Engine::_Min
   3022                                           + _Working_result_type(1);
   3023 #else
   3024     static _LIBCPP_CONSTEXPR const _Working_result_type _Rp = _Engine::max() - _Engine::min()
   3025                                                             + _Working_result_type(1);
   3026 #endif
   3027     static _LIBCPP_CONSTEXPR const size_t __m = __log2<_Working_result_type, _Rp>::value;
   3028     static _LIBCPP_CONSTEXPR const size_t __n = __get_n<_Working_result_type, _Rp, __w, __m>::value;
   3029     static _LIBCPP_CONSTEXPR const size_t __w0 = __w / __n;
   3030     static _LIBCPP_CONSTEXPR const size_t __n0 = __n - __w % __n;
   3031     static _LIBCPP_CONSTEXPR const size_t _WDt = numeric_limits<_Working_result_type>::digits;
   3032     static _LIBCPP_CONSTEXPR const size_t _EDt = numeric_limits<_Engine_result_type>::digits;
   3033     static _LIBCPP_CONSTEXPR const _Working_result_type __y0 = __w0 >= _WDt ? 0 :
   3034                                                                (_Rp >> __w0) << __w0;
   3035     static _LIBCPP_CONSTEXPR const _Working_result_type __y1 = __w0 >= _WDt - 1 ? 0 :
   3036                                                                (_Rp >> (__w0+1)) << (__w0+1);
   3037     static _LIBCPP_CONSTEXPR const _Engine_result_type __mask0 = __w0 > 0 ?
   3038                                 _Engine_result_type(~0) >> (_EDt - __w0) :
   3039                                 _Engine_result_type(0);
   3040     static _LIBCPP_CONSTEXPR const _Engine_result_type __mask1 = __w0 < _EDt - 1 ?
   3041                                 _Engine_result_type(~0) >> (_EDt - (__w0 + 1)) :
   3042                                 _Engine_result_type(~0);
   3043 public:
   3044     static _LIBCPP_CONSTEXPR const result_type _Min = 0;
   3045     static _LIBCPP_CONSTEXPR const result_type _Max = __w == _Dt ? result_type(~0) :
   3046                                                       (result_type(1) << __w) - result_type(1);
   3047     static_assert(_Min < _Max, "independent_bits_engine invalid parameters");
   3048 
   3049     // engine characteristics
   3050     _LIBCPP_INLINE_VISIBILITY
   3051     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
   3052     _LIBCPP_INLINE_VISIBILITY
   3053     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
   3054 
   3055     // constructors and seeding functions
   3056     _LIBCPP_INLINE_VISIBILITY
   3057     independent_bits_engine() {}
   3058     _LIBCPP_INLINE_VISIBILITY
   3059     explicit independent_bits_engine(const _Engine& __e)
   3060         : __e_(__e) {}
   3061 #ifndef _LIBCPP_CXX03_LANG
   3062     _LIBCPP_INLINE_VISIBILITY
   3063     explicit independent_bits_engine(_Engine&& __e)
   3064         : __e_(_VSTD::move(__e)) {}
   3065 #endif  // _LIBCPP_CXX03_LANG
   3066     _LIBCPP_INLINE_VISIBILITY
   3067     explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
   3068     template<class _Sseq>
   3069         _LIBCPP_INLINE_VISIBILITY
   3070         explicit independent_bits_engine(_Sseq& __q,
   3071         typename enable_if<__is_seed_sequence<_Sseq, independent_bits_engine>::value &&
   3072                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
   3073          : __e_(__q) {}
   3074     _LIBCPP_INLINE_VISIBILITY
   3075     void seed() {__e_.seed();}
   3076     _LIBCPP_INLINE_VISIBILITY
   3077     void seed(result_type __sd) {__e_.seed(__sd);}
   3078     template<class _Sseq>
   3079         _LIBCPP_INLINE_VISIBILITY
   3080         typename enable_if
   3081         <
   3082             __is_seed_sequence<_Sseq, independent_bits_engine>::value,
   3083             void
   3084         >::type
   3085         seed(_Sseq& __q) {__e_.seed(__q);}
   3086 
   3087     // generating functions
   3088     _LIBCPP_INLINE_VISIBILITY
   3089     result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
   3090     _LIBCPP_INLINE_VISIBILITY
   3091     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
   3092 
   3093     // property functions
   3094     _LIBCPP_INLINE_VISIBILITY
   3095     const _Engine& base() const _NOEXCEPT {return __e_;}
   3096 
   3097     template<class _Eng, size_t _Wp, class _UInt>
   3098     friend
   3099     bool
   3100     operator==(
   3101         const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
   3102         const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
   3103 
   3104     template<class _Eng, size_t _Wp, class _UInt>
   3105     friend
   3106     bool
   3107     operator!=(
   3108         const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
   3109         const independent_bits_engine<_Eng, _Wp, _UInt>& __y);
   3110 
   3111     template <class _CharT, class _Traits,
   3112               class _Eng, size_t _Wp, class _UInt>
   3113     friend
   3114     basic_ostream<_CharT, _Traits>&
   3115     operator<<(basic_ostream<_CharT, _Traits>& __os,
   3116                const independent_bits_engine<_Eng, _Wp, _UInt>& __x);
   3117 
   3118     template <class _CharT, class _Traits,
   3119               class _Eng, size_t _Wp, class _UInt>
   3120     friend
   3121     basic_istream<_CharT, _Traits>&
   3122     operator>>(basic_istream<_CharT, _Traits>& __is,
   3123                independent_bits_engine<_Eng, _Wp, _UInt>& __x);
   3124 
   3125 private:
   3126     _LIBCPP_INLINE_VISIBILITY
   3127     result_type __eval(false_type);
   3128     result_type __eval(true_type);
   3129 
   3130     template <size_t __count>
   3131         _LIBCPP_INLINE_VISIBILITY
   3132         static
   3133         typename enable_if
   3134         <
   3135             __count < _Dt,
   3136             result_type
   3137         >::type
   3138         __lshift(result_type __x) {return __x << __count;}
   3139 
   3140     template <size_t __count>
   3141         _LIBCPP_INLINE_VISIBILITY
   3142         static
   3143         typename enable_if
   3144         <
   3145             (__count >= _Dt),
   3146             result_type
   3147         >::type
   3148         __lshift(result_type) {return result_type(0);}
   3149 };
   3150 
   3151 template<class _Engine, size_t __w, class _UIntType>
   3152 inline
   3153 _UIntType
   3154 independent_bits_engine<_Engine, __w, _UIntType>::__eval(false_type)
   3155 {
   3156     return static_cast<result_type>(__e_() & __mask0);
   3157 }
   3158 
   3159 template<class _Engine, size_t __w, class _UIntType>
   3160 _UIntType
   3161 independent_bits_engine<_Engine, __w, _UIntType>::__eval(true_type)
   3162 {
   3163     result_type _Sp = 0;
   3164     for (size_t __k = 0; __k < __n0; ++__k)
   3165     {
   3166         _Engine_result_type __u;
   3167         do
   3168         {
   3169             __u = __e_() - _Engine::min();
   3170         } while (__u >= __y0);
   3171         _Sp = static_cast<result_type>(__lshift<__w0>(_Sp) + (__u & __mask0));
   3172     }
   3173     for (size_t __k = __n0; __k < __n; ++__k)
   3174     {
   3175         _Engine_result_type __u;
   3176         do
   3177         {
   3178             __u = __e_() - _Engine::min();
   3179         } while (__u >= __y1);
   3180         _Sp = static_cast<result_type>(__lshift<__w0+1>(_Sp) + (__u & __mask1));
   3181     }
   3182     return _Sp;
   3183 }
   3184 
   3185 template<class _Eng, size_t _Wp, class _UInt>
   3186 inline _LIBCPP_INLINE_VISIBILITY
   3187 bool
   3188 operator==(
   3189     const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
   3190     const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
   3191 {
   3192     return __x.base() == __y.base();
   3193 }
   3194 
   3195 template<class _Eng, size_t _Wp, class _UInt>
   3196 inline _LIBCPP_INLINE_VISIBILITY
   3197 bool
   3198 operator!=(
   3199     const independent_bits_engine<_Eng, _Wp, _UInt>& __x,
   3200     const independent_bits_engine<_Eng, _Wp, _UInt>& __y)
   3201 {
   3202     return !(__x == __y);
   3203 }
   3204 
   3205 template <class _CharT, class _Traits,
   3206           class _Eng, size_t _Wp, class _UInt>
   3207 basic_ostream<_CharT, _Traits>&
   3208 operator<<(basic_ostream<_CharT, _Traits>& __os,
   3209            const independent_bits_engine<_Eng, _Wp, _UInt>& __x)
   3210 {
   3211     return __os << __x.base();
   3212 }
   3213 
   3214 template <class _CharT, class _Traits,
   3215           class _Eng, size_t _Wp, class _UInt>
   3216 basic_istream<_CharT, _Traits>&
   3217 operator>>(basic_istream<_CharT, _Traits>& __is,
   3218            independent_bits_engine<_Eng, _Wp, _UInt>& __x)
   3219 {
   3220     _Eng __e;
   3221     __is >> __e;
   3222     if (!__is.fail())
   3223         __x.__e_ = __e;
   3224     return __is;
   3225 }
   3226 
   3227 // shuffle_order_engine
   3228 
   3229 template <uint64_t _Xp, uint64_t _Yp>
   3230 struct __ugcd
   3231 {
   3232     static _LIBCPP_CONSTEXPR const uint64_t value = __ugcd<_Yp, _Xp % _Yp>::value;
   3233 };
   3234 
   3235 template <uint64_t _Xp>
   3236 struct __ugcd<_Xp, 0>
   3237 {
   3238     static _LIBCPP_CONSTEXPR const uint64_t value = _Xp;
   3239 };
   3240 
   3241 template <uint64_t _Np, uint64_t _Dp>
   3242 class __uratio
   3243 {
   3244     static_assert(_Dp != 0, "__uratio divide by 0");
   3245     static _LIBCPP_CONSTEXPR const uint64_t __gcd = __ugcd<_Np, _Dp>::value;
   3246 public:
   3247     static _LIBCPP_CONSTEXPR const uint64_t num = _Np / __gcd;
   3248     static _LIBCPP_CONSTEXPR const uint64_t den = _Dp / __gcd;
   3249 
   3250     typedef __uratio<num, den> type;
   3251 };
   3252 
   3253 template<class _Engine, size_t __k>
   3254 class _LIBCPP_TEMPLATE_VIS shuffle_order_engine
   3255 {
   3256     static_assert(0 < __k, "shuffle_order_engine invalid parameters");
   3257 public:
   3258     // types
   3259     typedef typename _Engine::result_type result_type;
   3260 
   3261 private:
   3262     _Engine __e_;
   3263     result_type _V_[__k];
   3264     result_type _Y_;
   3265 
   3266 public:
   3267     // engine characteristics
   3268     static _LIBCPP_CONSTEXPR const size_t table_size = __k;
   3269 
   3270 #ifdef _LIBCPP_CXX03_LANG
   3271     static const result_type _Min = _Engine::_Min;
   3272     static const result_type _Max = _Engine::_Max;
   3273 #else
   3274     static _LIBCPP_CONSTEXPR const result_type _Min = _Engine::min();
   3275     static _LIBCPP_CONSTEXPR const result_type _Max = _Engine::max();
   3276 #endif
   3277     static_assert(_Min < _Max, "shuffle_order_engine invalid parameters");
   3278     _LIBCPP_INLINE_VISIBILITY
   3279     static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
   3280     _LIBCPP_INLINE_VISIBILITY
   3281     static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
   3282 
   3283     static _LIBCPP_CONSTEXPR const unsigned long long _Rp = _Max - _Min + 1ull;
   3284 
   3285     // constructors and seeding functions
   3286     _LIBCPP_INLINE_VISIBILITY
   3287     shuffle_order_engine() {__init();}
   3288     _LIBCPP_INLINE_VISIBILITY
   3289     explicit shuffle_order_engine(const _Engine& __e)
   3290         : __e_(__e) {__init();}
   3291 #ifndef _LIBCPP_CXX03_LANG
   3292     _LIBCPP_INLINE_VISIBILITY
   3293     explicit shuffle_order_engine(_Engine&& __e)
   3294         : __e_(_VSTD::move(__e)) {__init();}
   3295 #endif  // _LIBCPP_CXX03_LANG
   3296     _LIBCPP_INLINE_VISIBILITY
   3297     explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
   3298     template<class _Sseq>
   3299         _LIBCPP_INLINE_VISIBILITY
   3300         explicit shuffle_order_engine(_Sseq& __q,
   3301         typename enable_if<__is_seed_sequence<_Sseq, shuffle_order_engine>::value &&
   3302                            !is_convertible<_Sseq, _Engine>::value>::type* = 0)
   3303          : __e_(__q) {__init();}
   3304     _LIBCPP_INLINE_VISIBILITY
   3305     void seed() {__e_.seed(); __init();}
   3306     _LIBCPP_INLINE_VISIBILITY
   3307     void seed(result_type __sd) {__e_.seed(__sd); __init();}
   3308     template<class _Sseq>
   3309         _LIBCPP_INLINE_VISIBILITY
   3310         typename enable_if
   3311         <
   3312             __is_seed_sequence<_Sseq, shuffle_order_engine>::value,
   3313             void
   3314         >::type
   3315         seed(_Sseq& __q) {__e_.seed(__q); __init();}
   3316 
   3317     // generating functions
   3318     _LIBCPP_INLINE_VISIBILITY
   3319     result_type operator()() {return __eval(integral_constant<bool, _Rp != 0>());}
   3320     _LIBCPP_INLINE_VISIBILITY
   3321     void discard(unsigned long long __z) {for (; __z; --__z) operator()();}
   3322 
   3323     // property functions
   3324     _LIBCPP_INLINE_VISIBILITY
   3325     const _Engine& base() const _NOEXCEPT {return __e_;}
   3326 
   3327 private:
   3328     template<class _Eng, size_t _Kp>
   3329     friend
   3330     bool
   3331     operator==(
   3332         const shuffle_order_engine<_Eng, _Kp>& __x,
   3333         const shuffle_order_engine<_Eng, _Kp>& __y);
   3334 
   3335     template<class _Eng, size_t _Kp>
   3336     friend
   3337     bool
   3338     operator!=(
   3339         const shuffle_order_engine<_Eng, _Kp>& __x,
   3340         const shuffle_order_engine<_Eng, _Kp>& __y);
   3341 
   3342     template <class _CharT, class _Traits,
   3343               class _Eng, size_t _Kp>
   3344     friend
   3345     basic_ostream<_CharT, _Traits>&
   3346     operator<<(basic_ostream<_CharT, _Traits>& __os,
   3347                const shuffle_order_engine<_Eng, _Kp>& __x);
   3348 
   3349     template <class _CharT, class _Traits,
   3350               class _Eng, size_t _Kp>
   3351     friend
   3352     basic_istream<_CharT, _Traits>&
   3353     operator>>(basic_istream<_CharT, _Traits>& __is,
   3354                shuffle_order_engine<_Eng, _Kp>& __x);
   3355 
   3356     _LIBCPP_INLINE_VISIBILITY
   3357     void __init()
   3358     {
   3359         for (size_t __i = 0; __i < __k; ++__i)
   3360             _V_[__i] = __e_();
   3361         _Y_ = __e_();
   3362     }
   3363 
   3364     _LIBCPP_INLINE_VISIBILITY
   3365     result_type __eval(false_type) {return __eval2(integral_constant<bool, __k & 1>());}
   3366     _LIBCPP_INLINE_VISIBILITY
   3367     result_type __eval(true_type) {return __eval(__uratio<__k, _Rp>());}
   3368 
   3369     _LIBCPP_INLINE_VISIBILITY
   3370     result_type __eval2(false_type) {return __eval(__uratio<__k/2, 0x8000000000000000ull>());}
   3371     _LIBCPP_INLINE_VISIBILITY
   3372     result_type __eval2(true_type) {return __evalf<__k, 0>();}
   3373 
   3374     template <uint64_t _Np, uint64_t _Dp>
   3375         _LIBCPP_INLINE_VISIBILITY
   3376         typename enable_if
   3377         <
   3378             (__uratio<_Np, _Dp>::num > 0xFFFFFFFFFFFFFFFFull / (_Max - _Min)),
   3379             result_type
   3380         >::type
   3381         __eval(__uratio<_Np, _Dp>)
   3382             {return __evalf<__uratio<_Np, _Dp>::num, __uratio<_Np, _Dp>::den>();}
   3383 
   3384     template <uint64_t _Np, uint64_t _Dp>
   3385         _LIBCPP_INLINE_VISIBILITY
   3386         typename enable_if
   3387         <
   3388             __uratio<_Np, _Dp>::num <= 0xFFFFFFFFFFFFFFFFull / (_Max - _Min),
   3389             result_type
   3390         >::type
   3391         __eval(__uratio<_Np, _Dp>)
   3392         {
   3393             const size_t __j = static_cast<size_t>(__uratio<_Np, _Dp>::num * (_Y_ - _Min)
   3394                                                    / __uratio<_Np, _Dp>::den);
   3395             _Y_ = _V_[__j];
   3396             _V_[__j] = __e_();
   3397             return _Y_;
   3398         }
   3399 
   3400     template <uint64_t __n, uint64_t __d>
   3401         _LIBCPP_INLINE_VISIBILITY
   3402         result_type __evalf()
   3403         {
   3404             const double _Fp = __d == 0 ?
   3405                 __n / (2. * 0x8000000000000000ull) :
   3406                 __n / (double)__d;
   3407             const size_t __j = static_cast<size_t>(_Fp * (_Y_ - _Min));
   3408             _Y_ = _V_[__j];
   3409             _V_[__j] = __e_();
   3410             return _Y_;
   3411         }
   3412 };
   3413 
   3414 template<class _Engine, size_t __k>
   3415     _LIBCPP_CONSTEXPR const size_t shuffle_order_engine<_Engine, __k>::table_size;
   3416 
   3417 template<class _Eng, size_t _Kp>
   3418 bool
   3419 operator==(
   3420     const shuffle_order_engine<_Eng, _Kp>& __x,
   3421     const shuffle_order_engine<_Eng, _Kp>& __y)
   3422 {
   3423     return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _Kp, __y._V_) &&
   3424            __x.__e_ == __y.__e_;
   3425 }
   3426 
   3427 template<class _Eng, size_t _Kp>
   3428 inline _LIBCPP_INLINE_VISIBILITY
   3429 bool
   3430 operator!=(
   3431     const shuffle_order_engine<_Eng, _Kp>& __x,
   3432     const shuffle_order_engine<_Eng, _Kp>& __y)
   3433 {
   3434     return !(__x == __y);
   3435 }
   3436 
   3437 template <class _CharT, class _Traits,
   3438           class _Eng, size_t _Kp>
   3439 basic_ostream<_CharT, _Traits>&
   3440 operator<<(basic_ostream<_CharT, _Traits>& __os,
   3441            const shuffle_order_engine<_Eng, _Kp>& __x)
   3442 {
   3443     __save_flags<_CharT, _Traits> __lx(__os);
   3444     __os.flags(ios_base::dec | ios_base::left);
   3445     _CharT __sp = __os.widen(' ');
   3446     __os.fill(__sp);
   3447     __os << __x.__e_ << __sp << __x._V_[0];
   3448     for (size_t __i = 1; __i < _Kp; ++__i)
   3449         __os << __sp << __x._V_[__i];
   3450     return __os << __sp << __x._Y_;
   3451 }
   3452 
   3453 template <class _CharT, class _Traits,
   3454           class _Eng, size_t _Kp>
   3455 basic_istream<_CharT, _Traits>&
   3456 operator>>(basic_istream<_CharT, _Traits>& __is,
   3457            shuffle_order_engine<_Eng, _Kp>& __x)
   3458 {
   3459     typedef typename shuffle_order_engine<_Eng, _Kp>::result_type result_type;
   3460     __save_flags<_CharT, _Traits> __lx(__is);
   3461     __is.flags(ios_base::dec | ios_base::skipws);
   3462     _Eng __e;
   3463     result_type _Vp[_Kp+1];
   3464     __is >> __e;
   3465     for (size_t __i = 0; __i < _Kp+1; ++__i)
   3466         __is >> _Vp[__i];
   3467     if (!__is.fail())
   3468     {
   3469         __x.__e_ = __e;
   3470         for (size_t __i = 0; __i < _Kp; ++__i)
   3471             __x._V_[__i] = _Vp[__i];
   3472         __x._Y_ = _Vp[_Kp];
   3473     }
   3474     return __is;
   3475 }
   3476 
   3477 typedef shuffle_order_engine<minstd_rand0, 256>                         knuth_b;
   3478 
   3479 // random_device
   3480 
   3481 class _LIBCPP_TYPE_VIS random_device
   3482 {
   3483 #ifdef _LIBCPP_USING_DEV_RANDOM
   3484     int __f_;
   3485 #endif // defined(_LIBCPP_USING_DEV_RANDOM)
   3486 public:
   3487     // types
   3488     typedef unsigned result_type;
   3489 
   3490     // generator characteristics
   3491     static _LIBCPP_CONSTEXPR const result_type _Min = 0;
   3492     static _LIBCPP_CONSTEXPR const result_type _Max = 0xFFFFFFFFu;
   3493 
   3494     _LIBCPP_INLINE_VISIBILITY
   3495     static _LIBCPP_CONSTEXPR result_type min() { return _Min;}
   3496     _LIBCPP_INLINE_VISIBILITY
   3497     static _LIBCPP_CONSTEXPR result_type max() { return _Max;}
   3498 
   3499     // constructors
   3500     explicit random_device(const string& __token = "/dev/urandom");
   3501     ~random_device();
   3502 
   3503     // generating functions
   3504     result_type operator()();
   3505 
   3506     // property functions
   3507     double entropy() const _NOEXCEPT;
   3508 
   3509 private:
   3510     // no copy functions
   3511     random_device(const random_device&); // = delete;
   3512     random_device& operator=(const random_device&); // = delete;
   3513 };
   3514 
   3515 // seed_seq
   3516 
   3517 class _LIBCPP_TEMPLATE_VIS seed_seq
   3518 {
   3519 public:
   3520     // types
   3521     typedef uint32_t result_type;
   3522 
   3523 private:
   3524     vector<result_type> __v_;
   3525 
   3526     template<class _InputIterator>
   3527         void init(_InputIterator __first, _InputIterator __last);
   3528 public:
   3529     // constructors
   3530     _LIBCPP_INLINE_VISIBILITY
   3531     seed_seq() _NOEXCEPT {}
   3532 #ifndef _LIBCPP_CXX03_LANG
   3533     template<class _Tp>
   3534         _LIBCPP_INLINE_VISIBILITY
   3535         seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());}
   3536 #endif  // _LIBCPP_CXX03_LANG
   3537 
   3538     template<class _InputIterator>
   3539         _LIBCPP_INLINE_VISIBILITY
   3540         seed_seq(_InputIterator __first, _InputIterator __last)
   3541              {init(__first, __last);}
   3542 
   3543     // generating functions
   3544     template<class _RandomAccessIterator>
   3545         void generate(_RandomAccessIterator __first, _RandomAccessIterator __last);
   3546 
   3547     // property functions
   3548     _LIBCPP_INLINE_VISIBILITY
   3549     size_t size() const _NOEXCEPT {return __v_.size();}
   3550     template<class _OutputIterator>
   3551         _LIBCPP_INLINE_VISIBILITY
   3552         void param(_OutputIterator __dest) const
   3553             {_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
   3554 
   3555 private:
   3556     // no copy functions
   3557     seed_seq(const seed_seq&); // = delete;
   3558     void operator=(const seed_seq&); // = delete;
   3559 
   3560     _LIBCPP_INLINE_VISIBILITY
   3561     static result_type _Tp(result_type __x) {return __x ^ (__x >> 27);}
   3562 };
   3563 
   3564 template<class _InputIterator>
   3565 void
   3566 seed_seq::init(_InputIterator __first, _InputIterator __last)
   3567 {
   3568     for (_InputIterator __s = __first; __s != __last; ++__s)
   3569         __v_.push_back(*__s & 0xFFFFFFFF);
   3570 }
   3571 
   3572 template<class _RandomAccessIterator>
   3573 void
   3574 seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
   3575 {
   3576     if (__first != __last)
   3577     {
   3578         _VSTD::fill(__first, __last, 0x8b8b8b8b);
   3579         const size_t __n = static_cast<size_t>(__last - __first);
   3580         const size_t __s = __v_.size();
   3581         const size_t __t = (__n >= 623) ? 11
   3582                          : (__n >= 68) ? 7
   3583                          : (__n >= 39) ? 5
   3584                          : (__n >= 7)  ? 3
   3585                          : (__n - 1) / 2;
   3586         const size_t __p = (__n - __t) / 2;
   3587         const size_t __q = __p + __t;
   3588         const size_t __m = _VSTD::max(__s + 1, __n);
   3589         // __k = 0;
   3590         {
   3591             result_type __r = 1664525 * _Tp(__first[0] ^ __first[__p]
   3592                                                       ^  __first[__n - 1]);
   3593             __first[__p] += __r;
   3594             __r += __s;
   3595             __first[__q] += __r;
   3596             __first[0] = __r;
   3597         }
   3598         for (size_t __k = 1; __k <= __s; ++__k)
   3599         {
   3600             const size_t __kmodn = __k % __n;
   3601             const size_t __kpmodn = (__k + __p) % __n;
   3602             result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
   3603                                            ^ __first[(__k - 1) % __n]);
   3604             __first[__kpmodn] += __r;
   3605             __r +=  __kmodn + __v_[__k-1];
   3606             __first[(__k + __q) % __n] += __r;
   3607             __first[__kmodn] = __r;
   3608         }
   3609         for (size_t __k = __s + 1; __k < __m; ++__k)
   3610         {
   3611             const size_t __kmodn = __k % __n;
   3612             const size_t __kpmodn = (__k + __p) % __n;
   3613             result_type __r = 1664525 * _Tp(__first[__kmodn] ^ __first[__kpmodn]
   3614                                            ^ __first[(__k - 1) % __n]);
   3615             __first[__kpmodn] += __r;
   3616             __r +=  __kmodn;
   3617             __first[(__k + __q) % __n] += __r;
   3618             __first[__kmodn] = __r;
   3619         }
   3620         for (size_t __k = __m; __k < __m + __n; ++__k)
   3621         {
   3622             const size_t __kmodn = __k % __n;
   3623             const size_t __kpmodn = (__k + __p) % __n;
   3624             result_type __r = 1566083941 * _Tp(__first[__kmodn] +
   3625                                               __first[__kpmodn] +
   3626                                               __first[(__k - 1) % __n]);
   3627             __first[__kpmodn] ^= __r;
   3628             __r -= __kmodn;
   3629             __first[(__k + __q) % __n] ^= __r;
   3630             __first[__kmodn] = __r;
   3631         }
   3632     }
   3633 }
   3634 
   3635 // generate_canonical
   3636 
   3637 template<class _RealType, size_t __bits, class _URNG>
   3638 _RealType
   3639 generate_canonical(_URNG& __g)
   3640 {
   3641     const size_t _Dt = numeric_limits<_RealType>::digits;
   3642     const size_t __b = _Dt < __bits ? _Dt : __bits;
   3643 #ifdef _LIBCPP_CXX03_LANG
   3644     const size_t __logR = __log2<uint64_t, _URNG::_Max - _URNG::_Min + uint64_t(1)>::value;
   3645 #else
   3646     const size_t __logR = __log2<uint64_t, _URNG::max() - _URNG::min() + uint64_t(1)>::value;
   3647 #endif
   3648     const size_t __k = __b / __logR + (__b % __logR != 0) + (__b == 0);
   3649     const _RealType _Rp = _URNG::max() - _URNG::min() + _RealType(1);
   3650     _RealType __base = _Rp;
   3651     _RealType _Sp = __g() - _URNG::min();
   3652     for (size_t __i = 1; __i < __k; ++__i, __base *= _Rp)
   3653         _Sp += (__g() - _URNG::min()) * __base;
   3654     return _Sp / __base;
   3655 }
   3656 
   3657 // uniform_int_distribution
   3658 
   3659 // in <algorithm>
   3660 
   3661 template <class _CharT, class _Traits, class _IT>
   3662 basic_ostream<_CharT, _Traits>&
   3663 operator<<(basic_ostream<_CharT, _Traits>& __os,
   3664            const uniform_int_distribution<_IT>& __x)
   3665 {
   3666     __save_flags<_CharT, _Traits> __lx(__os);
   3667     __os.flags(ios_base::dec | ios_base::left);
   3668     _CharT __sp = __os.widen(' ');
   3669     __os.fill(__sp);
   3670     return __os << __x.a() << __sp << __x.b();
   3671 }
   3672 
   3673 template <class _CharT, class _Traits, class _IT>
   3674 basic_istream<_CharT, _Traits>&
   3675 operator>>(basic_istream<_CharT, _Traits>& __is,
   3676            uniform_int_distribution<_IT>& __x)
   3677 {
   3678     typedef uniform_int_distribution<_IT> _Eng;
   3679     typedef typename _Eng::result_type result_type;
   3680     typedef typename _Eng::param_type param_type;
   3681     __save_flags<_CharT, _Traits> __lx(__is);
   3682     __is.flags(ios_base::dec | ios_base::skipws);
   3683     result_type __a;
   3684     result_type __b;
   3685     __is >> __a >> __b;
   3686     if (!__is.fail())
   3687         __x.param(param_type(__a, __b));
   3688     return __is;
   3689 }
   3690 
   3691 // uniform_real_distribution
   3692 
   3693 template<class _RealType = double>
   3694 class _LIBCPP_TEMPLATE_VIS uniform_real_distribution
   3695 {
   3696 public:
   3697     // types
   3698     typedef _RealType result_type;
   3699 
   3700     class _LIBCPP_TEMPLATE_VIS param_type
   3701     {
   3702         result_type __a_;
   3703         result_type __b_;
   3704     public:
   3705         typedef uniform_real_distribution distribution_type;
   3706 
   3707         _LIBCPP_INLINE_VISIBILITY
   3708         explicit param_type(result_type __a = 0,
   3709                             result_type __b = 1)
   3710             : __a_(__a), __b_(__b) {}
   3711 
   3712         _LIBCPP_INLINE_VISIBILITY
   3713         result_type a() const {return __a_;}
   3714         _LIBCPP_INLINE_VISIBILITY
   3715         result_type b() const {return __b_;}
   3716 
   3717         friend _LIBCPP_INLINE_VISIBILITY
   3718         bool operator==(const param_type& __x, const param_type& __y)
   3719             {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
   3720         friend _LIBCPP_INLINE_VISIBILITY
   3721         bool operator!=(const param_type& __x, const param_type& __y)
   3722             {return !(__x == __y);}
   3723     };
   3724 
   3725 private:
   3726     param_type __p_;
   3727 
   3728 public:
   3729     // constructors and reset functions
   3730     _LIBCPP_INLINE_VISIBILITY
   3731     explicit uniform_real_distribution(result_type __a = 0, result_type __b = 1)
   3732         : __p_(param_type(__a, __b)) {}
   3733     _LIBCPP_INLINE_VISIBILITY
   3734     explicit uniform_real_distribution(const param_type& __p) : __p_(__p) {}
   3735     _LIBCPP_INLINE_VISIBILITY
   3736     void reset() {}
   3737 
   3738     // generating functions
   3739     template<class _URNG>
   3740         _LIBCPP_INLINE_VISIBILITY
   3741         result_type operator()(_URNG& __g)
   3742         {return (*this)(__g, __p_);}
   3743     template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
   3744 
   3745     // property functions
   3746     _LIBCPP_INLINE_VISIBILITY
   3747     result_type a() const {return __p_.a();}
   3748     _LIBCPP_INLINE_VISIBILITY
   3749     result_type b() const {return __p_.b();}
   3750 
   3751     _LIBCPP_INLINE_VISIBILITY
   3752     param_type param() const {return __p_;}
   3753     _LIBCPP_INLINE_VISIBILITY
   3754     void param(const param_type& __p) {__p_ = __p;}
   3755 
   3756     _LIBCPP_INLINE_VISIBILITY
   3757     result_type min() const {return a();}
   3758     _LIBCPP_INLINE_VISIBILITY
   3759     result_type max() const {return b();}
   3760 
   3761     friend _LIBCPP_INLINE_VISIBILITY
   3762         bool operator==(const uniform_real_distribution& __x,
   3763                         const uniform_real_distribution& __y)
   3764         {return __x.__p_ == __y.__p_;}
   3765     friend _LIBCPP_INLINE_VISIBILITY
   3766         bool operator!=(const uniform_real_distribution& __x,
   3767                         const uniform_real_distribution& __y)
   3768         {return !(__x == __y);}
   3769 };
   3770 
   3771 template<class _RealType>
   3772 template<class _URNG>
   3773 inline
   3774 typename uniform_real_distribution<_RealType>::result_type
   3775 uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   3776 {
   3777     return (__p.b() - __p.a())
   3778         * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
   3779         + __p.a();
   3780 }
   3781 
   3782 template <class _CharT, class _Traits, class _RT>
   3783 basic_ostream<_CharT, _Traits>&
   3784 operator<<(basic_ostream<_CharT, _Traits>& __os,
   3785            const uniform_real_distribution<_RT>& __x)
   3786 {
   3787     __save_flags<_CharT, _Traits> __lx(__os);
   3788     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   3789                ios_base::scientific);
   3790     _CharT __sp = __os.widen(' ');
   3791     __os.fill(__sp);
   3792     return __os << __x.a() << __sp << __x.b();
   3793 }
   3794 
   3795 template <class _CharT, class _Traits, class _RT>
   3796 basic_istream<_CharT, _Traits>&
   3797 operator>>(basic_istream<_CharT, _Traits>& __is,
   3798            uniform_real_distribution<_RT>& __x)
   3799 {
   3800     typedef uniform_real_distribution<_RT> _Eng;
   3801     typedef typename _Eng::result_type result_type;
   3802     typedef typename _Eng::param_type param_type;
   3803     __save_flags<_CharT, _Traits> __lx(__is);
   3804     __is.flags(ios_base::dec | ios_base::skipws);
   3805     result_type __a;
   3806     result_type __b;
   3807     __is >> __a >> __b;
   3808     if (!__is.fail())
   3809         __x.param(param_type(__a, __b));
   3810     return __is;
   3811 }
   3812 
   3813 // bernoulli_distribution
   3814 
   3815 class _LIBCPP_TEMPLATE_VIS bernoulli_distribution
   3816 {
   3817 public:
   3818     // types
   3819     typedef bool result_type;
   3820 
   3821     class _LIBCPP_TEMPLATE_VIS param_type
   3822     {
   3823         double __p_;
   3824     public:
   3825         typedef bernoulli_distribution distribution_type;
   3826 
   3827         _LIBCPP_INLINE_VISIBILITY
   3828         explicit param_type(double __p = 0.5) : __p_(__p) {}
   3829 
   3830         _LIBCPP_INLINE_VISIBILITY
   3831         double p() const {return __p_;}
   3832 
   3833         friend _LIBCPP_INLINE_VISIBILITY
   3834             bool operator==(const param_type& __x, const param_type& __y)
   3835             {return __x.__p_ == __y.__p_;}
   3836         friend _LIBCPP_INLINE_VISIBILITY
   3837             bool operator!=(const param_type& __x, const param_type& __y)
   3838             {return !(__x == __y);}
   3839     };
   3840 
   3841 private:
   3842     param_type __p_;
   3843 
   3844 public:
   3845     // constructors and reset functions
   3846     _LIBCPP_INLINE_VISIBILITY
   3847     explicit bernoulli_distribution(double __p = 0.5)
   3848         : __p_(param_type(__p)) {}
   3849     _LIBCPP_INLINE_VISIBILITY
   3850     explicit bernoulli_distribution(const param_type& __p) : __p_(__p) {}
   3851     _LIBCPP_INLINE_VISIBILITY
   3852     void reset() {}
   3853 
   3854     // generating functions
   3855     template<class _URNG>
   3856         _LIBCPP_INLINE_VISIBILITY
   3857         result_type operator()(_URNG& __g)
   3858         {return (*this)(__g, __p_);}
   3859     template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
   3860 
   3861     // property functions
   3862     _LIBCPP_INLINE_VISIBILITY
   3863     double p() const {return __p_.p();}
   3864 
   3865     _LIBCPP_INLINE_VISIBILITY
   3866     param_type param() const {return __p_;}
   3867     _LIBCPP_INLINE_VISIBILITY
   3868     void param(const param_type& __p) {__p_ = __p;}
   3869 
   3870     _LIBCPP_INLINE_VISIBILITY
   3871     result_type min() const {return false;}
   3872     _LIBCPP_INLINE_VISIBILITY
   3873     result_type max() const {return true;}
   3874 
   3875     friend _LIBCPP_INLINE_VISIBILITY
   3876         bool operator==(const bernoulli_distribution& __x,
   3877                         const bernoulli_distribution& __y)
   3878         {return __x.__p_ == __y.__p_;}
   3879     friend _LIBCPP_INLINE_VISIBILITY
   3880         bool operator!=(const bernoulli_distribution& __x,
   3881                         const bernoulli_distribution& __y)
   3882         {return !(__x == __y);}
   3883 };
   3884 
   3885 template<class _URNG>
   3886 inline
   3887 bernoulli_distribution::result_type
   3888 bernoulli_distribution::operator()(_URNG& __g, const param_type& __p)
   3889 {
   3890     uniform_real_distribution<double> __gen;
   3891     return __gen(__g) < __p.p();
   3892 }
   3893 
   3894 template <class _CharT, class _Traits>
   3895 basic_ostream<_CharT, _Traits>&
   3896 operator<<(basic_ostream<_CharT, _Traits>& __os, const bernoulli_distribution& __x)
   3897 {
   3898     __save_flags<_CharT, _Traits> __lx(__os);
   3899     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   3900                ios_base::scientific);
   3901     _CharT __sp = __os.widen(' ');
   3902     __os.fill(__sp);
   3903     return __os << __x.p();
   3904 }
   3905 
   3906 template <class _CharT, class _Traits>
   3907 basic_istream<_CharT, _Traits>&
   3908 operator>>(basic_istream<_CharT, _Traits>& __is, bernoulli_distribution& __x)
   3909 {
   3910     typedef bernoulli_distribution _Eng;
   3911     typedef typename _Eng::param_type param_type;
   3912     __save_flags<_CharT, _Traits> __lx(__is);
   3913     __is.flags(ios_base::dec | ios_base::skipws);
   3914     double __p;
   3915     __is >> __p;
   3916     if (!__is.fail())
   3917         __x.param(param_type(__p));
   3918     return __is;
   3919 }
   3920 
   3921 // binomial_distribution
   3922 
   3923 template<class _IntType = int>
   3924 class _LIBCPP_TEMPLATE_VIS binomial_distribution
   3925 {
   3926 public:
   3927     // types
   3928     typedef _IntType result_type;
   3929 
   3930     class _LIBCPP_TEMPLATE_VIS param_type
   3931     {
   3932         result_type __t_;
   3933         double __p_;
   3934         double __pr_;
   3935         double __odds_ratio_;
   3936         result_type __r0_;
   3937     public:
   3938         typedef binomial_distribution distribution_type;
   3939 
   3940         explicit param_type(result_type __t = 1, double __p = 0.5);
   3941 
   3942         _LIBCPP_INLINE_VISIBILITY
   3943         result_type t() const {return __t_;}
   3944         _LIBCPP_INLINE_VISIBILITY
   3945         double p() const {return __p_;}
   3946 
   3947         friend _LIBCPP_INLINE_VISIBILITY
   3948             bool operator==(const param_type& __x, const param_type& __y)
   3949             {return __x.__t_ == __y.__t_ && __x.__p_ == __y.__p_;}
   3950         friend _LIBCPP_INLINE_VISIBILITY
   3951             bool operator!=(const param_type& __x, const param_type& __y)
   3952             {return !(__x == __y);}
   3953 
   3954         friend class binomial_distribution;
   3955     };
   3956 
   3957 private:
   3958     param_type __p_;
   3959 
   3960 public:
   3961     // constructors and reset functions
   3962     _LIBCPP_INLINE_VISIBILITY
   3963     explicit binomial_distribution(result_type __t = 1, double __p = 0.5)
   3964         : __p_(param_type(__t, __p)) {}
   3965     _LIBCPP_INLINE_VISIBILITY
   3966     explicit binomial_distribution(const param_type& __p) : __p_(__p) {}
   3967     _LIBCPP_INLINE_VISIBILITY
   3968     void reset() {}
   3969 
   3970     // generating functions
   3971     template<class _URNG>
   3972         _LIBCPP_INLINE_VISIBILITY
   3973         result_type operator()(_URNG& __g)
   3974         {return (*this)(__g, __p_);}
   3975     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   3976 
   3977     // property functions
   3978     _LIBCPP_INLINE_VISIBILITY
   3979     result_type t() const {return __p_.t();}
   3980     _LIBCPP_INLINE_VISIBILITY
   3981     double p() const {return __p_.p();}
   3982 
   3983     _LIBCPP_INLINE_VISIBILITY
   3984     param_type param() const {return __p_;}
   3985     _LIBCPP_INLINE_VISIBILITY
   3986     void param(const param_type& __p) {__p_ = __p;}
   3987 
   3988     _LIBCPP_INLINE_VISIBILITY
   3989     result_type min() const {return 0;}
   3990     _LIBCPP_INLINE_VISIBILITY
   3991     result_type max() const {return t();}
   3992 
   3993     friend _LIBCPP_INLINE_VISIBILITY
   3994         bool operator==(const binomial_distribution& __x,
   3995                         const binomial_distribution& __y)
   3996         {return __x.__p_ == __y.__p_;}
   3997     friend _LIBCPP_INLINE_VISIBILITY
   3998         bool operator!=(const binomial_distribution& __x,
   3999                         const binomial_distribution& __y)
   4000         {return !(__x == __y);}
   4001 };
   4002 
   4003 #ifndef _LIBCPP_MSVCRT
   4004 extern "C" double lgamma_r(double, int *);
   4005 #endif
   4006 
   4007 inline _LIBCPP_INLINE_VISIBILITY double __libcpp_lgamma(double __d) {
   4008 #if defined(_LIBCPP_MSVCRT)
   4009   return lgamma(__d);
   4010 #else
   4011   int __sign;
   4012   return lgamma_r(__d, &__sign);
   4013 #endif
   4014 }
   4015 
   4016 template<class _IntType>
   4017 binomial_distribution<_IntType>::param_type::param_type(const result_type __t, const double __p)
   4018     : __t_(__t), __p_(__p)
   4019 {
   4020     if (0 < __p_ && __p_ < 1)
   4021     {
   4022         __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
   4023         __pr_ = _VSTD::exp(__libcpp_lgamma(__t_ + 1.) -
   4024                            __libcpp_lgamma(__r0_ + 1.) -
   4025                            __libcpp_lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
   4026                            (__t_ - __r0_) * _VSTD::log(1 - __p_));
   4027         __odds_ratio_ = __p_ / (1 - __p_);
   4028     }
   4029 }
   4030 
   4031 // Reference: Kemp, C.D. (1986). `A modal method for generating binomial
   4032 //           variables', Commun. Statist. - Theor. Meth. 15(3), 805-813.
   4033 template<class _IntType>
   4034 template<class _URNG>
   4035 _IntType
   4036 binomial_distribution<_IntType>::operator()(_URNG& __g, const param_type& __pr)
   4037 {
   4038     if (__pr.__t_ == 0 || __pr.__p_ == 0)
   4039         return 0;
   4040     if (__pr.__p_ == 1)
   4041         return __pr.__t_;
   4042     uniform_real_distribution<double> __gen;
   4043     double __u = __gen(__g) - __pr.__pr_;
   4044     if (__u < 0)
   4045         return __pr.__r0_;
   4046     double __pu = __pr.__pr_;
   4047     double __pd = __pu;
   4048     result_type __ru = __pr.__r0_;
   4049     result_type __rd = __ru;
   4050     while (true)
   4051     {
   4052         if (__rd >= 1)
   4053         {
   4054             __pd *= __rd / (__pr.__odds_ratio_ * (__pr.__t_ - __rd + 1));
   4055             __u -= __pd;
   4056             if (__u < 0)
   4057                 return __rd - 1;
   4058         }
   4059         if ( __rd != 0 )
   4060             --__rd;
   4061         ++__ru;
   4062         if (__ru <= __pr.__t_)
   4063         {
   4064             __pu *= (__pr.__t_ - __ru + 1) * __pr.__odds_ratio_ / __ru;
   4065             __u -= __pu;
   4066             if (__u < 0)
   4067                 return __ru;
   4068         }
   4069     }
   4070 }
   4071 
   4072 template <class _CharT, class _Traits, class _IntType>
   4073 basic_ostream<_CharT, _Traits>&
   4074 operator<<(basic_ostream<_CharT, _Traits>& __os,
   4075            const binomial_distribution<_IntType>& __x)
   4076 {
   4077     __save_flags<_CharT, _Traits> __lx(__os);
   4078     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   4079                ios_base::scientific);
   4080     _CharT __sp = __os.widen(' ');
   4081     __os.fill(__sp);
   4082     return __os << __x.t() << __sp << __x.p();
   4083 }
   4084 
   4085 template <class _CharT, class _Traits, class _IntType>
   4086 basic_istream<_CharT, _Traits>&
   4087 operator>>(basic_istream<_CharT, _Traits>& __is,
   4088            binomial_distribution<_IntType>& __x)
   4089 {
   4090     typedef binomial_distribution<_IntType> _Eng;
   4091     typedef typename _Eng::result_type result_type;
   4092     typedef typename _Eng::param_type param_type;
   4093     __save_flags<_CharT, _Traits> __lx(__is);
   4094     __is.flags(ios_base::dec | ios_base::skipws);
   4095     result_type __t;
   4096     double __p;
   4097     __is >> __t >> __p;
   4098     if (!__is.fail())
   4099         __x.param(param_type(__t, __p));
   4100     return __is;
   4101 }
   4102 
   4103 // exponential_distribution
   4104 
   4105 template<class _RealType = double>
   4106 class _LIBCPP_TEMPLATE_VIS exponential_distribution
   4107 {
   4108 public:
   4109     // types
   4110     typedef _RealType result_type;
   4111 
   4112     class _LIBCPP_TEMPLATE_VIS param_type
   4113     {
   4114         result_type __lambda_;
   4115     public:
   4116         typedef exponential_distribution distribution_type;
   4117 
   4118         _LIBCPP_INLINE_VISIBILITY
   4119         explicit param_type(result_type __lambda = 1) : __lambda_(__lambda) {}
   4120 
   4121         _LIBCPP_INLINE_VISIBILITY
   4122         result_type lambda() const {return __lambda_;}
   4123 
   4124         friend _LIBCPP_INLINE_VISIBILITY
   4125             bool operator==(const param_type& __x, const param_type& __y)
   4126             {return __x.__lambda_ == __y.__lambda_;}
   4127         friend _LIBCPP_INLINE_VISIBILITY
   4128             bool operator!=(const param_type& __x, const param_type& __y)
   4129             {return !(__x == __y);}
   4130     };
   4131 
   4132 private:
   4133     param_type __p_;
   4134 
   4135 public:
   4136     // constructors and reset functions
   4137     _LIBCPP_INLINE_VISIBILITY
   4138     explicit exponential_distribution(result_type __lambda = 1)
   4139         : __p_(param_type(__lambda)) {}
   4140     _LIBCPP_INLINE_VISIBILITY
   4141     explicit exponential_distribution(const param_type& __p) : __p_(__p) {}
   4142     _LIBCPP_INLINE_VISIBILITY
   4143     void reset() {}
   4144 
   4145     // generating functions
   4146     template<class _URNG>
   4147         _LIBCPP_INLINE_VISIBILITY
   4148         result_type operator()(_URNG& __g)
   4149         {return (*this)(__g, __p_);}
   4150     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   4151 
   4152     // property functions
   4153     _LIBCPP_INLINE_VISIBILITY
   4154     result_type lambda() const {return __p_.lambda();}
   4155 
   4156     _LIBCPP_INLINE_VISIBILITY
   4157     param_type param() const {return __p_;}
   4158     _LIBCPP_INLINE_VISIBILITY
   4159     void param(const param_type& __p) {__p_ = __p;}
   4160 
   4161     _LIBCPP_INLINE_VISIBILITY
   4162     result_type min() const {return 0;}
   4163     _LIBCPP_INLINE_VISIBILITY
   4164     result_type max() const {return numeric_limits<result_type>::infinity();}
   4165 
   4166     friend _LIBCPP_INLINE_VISIBILITY
   4167         bool operator==(const exponential_distribution& __x,
   4168                         const exponential_distribution& __y)
   4169         {return __x.__p_ == __y.__p_;}
   4170     friend _LIBCPP_INLINE_VISIBILITY
   4171         bool operator!=(const exponential_distribution& __x,
   4172                         const exponential_distribution& __y)
   4173         {return !(__x == __y);}
   4174 };
   4175 
   4176 template <class _RealType>
   4177 template<class _URNG>
   4178 _RealType
   4179 exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   4180 {
   4181     return -_VSTD::log
   4182                   (
   4183                       result_type(1) -
   4184                       _VSTD::generate_canonical<result_type,
   4185                                        numeric_limits<result_type>::digits>(__g)
   4186                   )
   4187                   / __p.lambda();
   4188 }
   4189 
   4190 template <class _CharT, class _Traits, class _RealType>
   4191 basic_ostream<_CharT, _Traits>&
   4192 operator<<(basic_ostream<_CharT, _Traits>& __os,
   4193            const exponential_distribution<_RealType>& __x)
   4194 {
   4195     __save_flags<_CharT, _Traits> __lx(__os);
   4196     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   4197                ios_base::scientific);
   4198     return __os << __x.lambda();
   4199 }
   4200 
   4201 template <class _CharT, class _Traits, class _RealType>
   4202 basic_istream<_CharT, _Traits>&
   4203 operator>>(basic_istream<_CharT, _Traits>& __is,
   4204            exponential_distribution<_RealType>& __x)
   4205 {
   4206     typedef exponential_distribution<_RealType> _Eng;
   4207     typedef typename _Eng::result_type result_type;
   4208     typedef typename _Eng::param_type param_type;
   4209     __save_flags<_CharT, _Traits> __lx(__is);
   4210     __is.flags(ios_base::dec | ios_base::skipws);
   4211     result_type __lambda;
   4212     __is >> __lambda;
   4213     if (!__is.fail())
   4214         __x.param(param_type(__lambda));
   4215     return __is;
   4216 }
   4217 
   4218 // normal_distribution
   4219 
   4220 template<class _RealType = double>
   4221 class _LIBCPP_TEMPLATE_VIS normal_distribution
   4222 {
   4223 public:
   4224     // types
   4225     typedef _RealType result_type;
   4226 
   4227     class _LIBCPP_TEMPLATE_VIS param_type
   4228     {
   4229         result_type __mean_;
   4230         result_type __stddev_;
   4231     public:
   4232         typedef normal_distribution distribution_type;
   4233 
   4234         _LIBCPP_INLINE_VISIBILITY
   4235         explicit param_type(result_type __mean = 0, result_type __stddev = 1)
   4236             : __mean_(__mean), __stddev_(__stddev) {}
   4237 
   4238         _LIBCPP_INLINE_VISIBILITY
   4239         result_type mean() const {return __mean_;}
   4240         _LIBCPP_INLINE_VISIBILITY
   4241         result_type stddev() const {return __stddev_;}
   4242 
   4243         friend _LIBCPP_INLINE_VISIBILITY
   4244             bool operator==(const param_type& __x, const param_type& __y)
   4245             {return __x.__mean_ == __y.__mean_ && __x.__stddev_ == __y.__stddev_;}
   4246         friend _LIBCPP_INLINE_VISIBILITY
   4247             bool operator!=(const param_type& __x, const param_type& __y)
   4248             {return !(__x == __y);}
   4249     };
   4250 
   4251 private:
   4252     param_type __p_;
   4253     result_type _V_;
   4254     bool _V_hot_;
   4255 
   4256 public:
   4257     // constructors and reset functions
   4258     _LIBCPP_INLINE_VISIBILITY
   4259     explicit normal_distribution(result_type __mean = 0, result_type __stddev = 1)
   4260         : __p_(param_type(__mean, __stddev)), _V_hot_(false) {}
   4261     _LIBCPP_INLINE_VISIBILITY
   4262     explicit normal_distribution(const param_type& __p)
   4263         : __p_(__p), _V_hot_(false) {}
   4264     _LIBCPP_INLINE_VISIBILITY
   4265     void reset() {_V_hot_ = false;}
   4266 
   4267     // generating functions
   4268     template<class _URNG>
   4269         _LIBCPP_INLINE_VISIBILITY
   4270         result_type operator()(_URNG& __g)
   4271         {return (*this)(__g, __p_);}
   4272     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   4273 
   4274     // property functions
   4275     _LIBCPP_INLINE_VISIBILITY
   4276     result_type mean() const {return __p_.mean();}
   4277     _LIBCPP_INLINE_VISIBILITY
   4278     result_type stddev() const {return __p_.stddev();}
   4279 
   4280     _LIBCPP_INLINE_VISIBILITY
   4281     param_type param() const {return __p_;}
   4282     _LIBCPP_INLINE_VISIBILITY
   4283     void param(const param_type& __p) {__p_ = __p;}
   4284 
   4285     _LIBCPP_INLINE_VISIBILITY
   4286     result_type min() const {return -numeric_limits<result_type>::infinity();}
   4287     _LIBCPP_INLINE_VISIBILITY
   4288     result_type max() const {return numeric_limits<result_type>::infinity();}
   4289 
   4290     friend _LIBCPP_INLINE_VISIBILITY
   4291         bool operator==(const normal_distribution& __x,
   4292                         const normal_distribution& __y)
   4293         {return __x.__p_ == __y.__p_ && __x._V_hot_ == __y._V_hot_ &&
   4294                 (!__x._V_hot_ || __x._V_ == __y._V_);}
   4295     friend _LIBCPP_INLINE_VISIBILITY
   4296         bool operator!=(const normal_distribution& __x,
   4297                         const normal_distribution& __y)
   4298         {return !(__x == __y);}
   4299 
   4300     template <class _CharT, class _Traits, class _RT>
   4301     friend
   4302     basic_ostream<_CharT, _Traits>&
   4303     operator<<(basic_ostream<_CharT, _Traits>& __os,
   4304                const normal_distribution<_RT>& __x);
   4305 
   4306     template <class _CharT, class _Traits, class _RT>
   4307     friend
   4308     basic_istream<_CharT, _Traits>&
   4309     operator>>(basic_istream<_CharT, _Traits>& __is,
   4310                normal_distribution<_RT>& __x);
   4311 };
   4312 
   4313 template <class _RealType>
   4314 template<class _URNG>
   4315 _RealType
   4316 normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   4317 {
   4318     result_type _Up;
   4319     if (_V_hot_)
   4320     {
   4321         _V_hot_ = false;
   4322         _Up = _V_;
   4323     }
   4324     else
   4325     {
   4326         uniform_real_distribution<result_type> _Uni(-1, 1);
   4327         result_type __u;
   4328         result_type __v;
   4329         result_type __s;
   4330         do
   4331         {
   4332             __u = _Uni(__g);
   4333             __v = _Uni(__g);
   4334             __s = __u * __u + __v * __v;
   4335         } while (__s > 1 || __s == 0);
   4336         result_type _Fp = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
   4337         _V_ = __v * _Fp;
   4338         _V_hot_ = true;
   4339         _Up = __u * _Fp;
   4340     }
   4341     return _Up * __p.stddev() + __p.mean();
   4342 }
   4343 
   4344 template <class _CharT, class _Traits, class _RT>
   4345 basic_ostream<_CharT, _Traits>&
   4346 operator<<(basic_ostream<_CharT, _Traits>& __os,
   4347            const normal_distribution<_RT>& __x)
   4348 {
   4349     __save_flags<_CharT, _Traits> __lx(__os);
   4350     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   4351                ios_base::scientific);
   4352     _CharT __sp = __os.widen(' ');
   4353     __os.fill(__sp);
   4354     __os << __x.mean() << __sp << __x.stddev() << __sp << __x._V_hot_;
   4355     if (__x._V_hot_)
   4356         __os << __sp << __x._V_;
   4357     return __os;
   4358 }
   4359 
   4360 template <class _CharT, class _Traits, class _RT>
   4361 basic_istream<_CharT, _Traits>&
   4362 operator>>(basic_istream<_CharT, _Traits>& __is,
   4363            normal_distribution<_RT>& __x)
   4364 {
   4365     typedef normal_distribution<_RT> _Eng;
   4366     typedef typename _Eng::result_type result_type;
   4367     typedef typename _Eng::param_type param_type;
   4368     __save_flags<_CharT, _Traits> __lx(__is);
   4369     __is.flags(ios_base::dec | ios_base::skipws);
   4370     result_type __mean;
   4371     result_type __stddev;
   4372     result_type _Vp = 0;
   4373     bool _V_hot = false;
   4374     __is >> __mean >> __stddev >> _V_hot;
   4375     if (_V_hot)
   4376         __is >> _Vp;
   4377     if (!__is.fail())
   4378     {
   4379         __x.param(param_type(__mean, __stddev));
   4380         __x._V_hot_ = _V_hot;
   4381         __x._V_ = _Vp;
   4382     }
   4383     return __is;
   4384 }
   4385 
   4386 // lognormal_distribution
   4387 
   4388 template<class _RealType = double>
   4389 class _LIBCPP_TEMPLATE_VIS lognormal_distribution
   4390 {
   4391 public:
   4392     // types
   4393     typedef _RealType result_type;
   4394 
   4395     class _LIBCPP_TEMPLATE_VIS param_type
   4396     {
   4397         normal_distribution<result_type> __nd_;
   4398     public:
   4399         typedef lognormal_distribution distribution_type;
   4400 
   4401         _LIBCPP_INLINE_VISIBILITY
   4402         explicit param_type(result_type __m = 0, result_type __s = 1)
   4403             : __nd_(__m, __s) {}
   4404 
   4405         _LIBCPP_INLINE_VISIBILITY
   4406         result_type m() const {return __nd_.mean();}
   4407         _LIBCPP_INLINE_VISIBILITY
   4408         result_type s() const {return __nd_.stddev();}
   4409 
   4410         friend _LIBCPP_INLINE_VISIBILITY
   4411             bool operator==(const param_type& __x, const param_type& __y)
   4412             {return __x.__nd_ == __y.__nd_;}
   4413         friend _LIBCPP_INLINE_VISIBILITY
   4414             bool operator!=(const param_type& __x, const param_type& __y)
   4415             {return !(__x == __y);}
   4416         friend class lognormal_distribution;
   4417 
   4418         template <class _CharT, class _Traits, class _RT>
   4419         friend
   4420         basic_ostream<_CharT, _Traits>&
   4421         operator<<(basic_ostream<_CharT, _Traits>& __os,
   4422                    const lognormal_distribution<_RT>& __x);
   4423 
   4424         template <class _CharT, class _Traits, class _RT>
   4425         friend
   4426         basic_istream<_CharT, _Traits>&
   4427         operator>>(basic_istream<_CharT, _Traits>& __is,
   4428                    lognormal_distribution<_RT>& __x);
   4429     };
   4430 
   4431 private:
   4432     param_type __p_;
   4433 
   4434 public:
   4435     // constructor and reset functions
   4436     _LIBCPP_INLINE_VISIBILITY
   4437     explicit lognormal_distribution(result_type __m = 0, result_type __s = 1)
   4438         : __p_(param_type(__m, __s)) {}
   4439     _LIBCPP_INLINE_VISIBILITY
   4440     explicit lognormal_distribution(const param_type& __p)
   4441         : __p_(__p) {}
   4442     _LIBCPP_INLINE_VISIBILITY
   4443     void reset() {__p_.__nd_.reset();}
   4444 
   4445     // generating functions
   4446     template<class _URNG>
   4447         _LIBCPP_INLINE_VISIBILITY
   4448         result_type operator()(_URNG& __g)
   4449         {return (*this)(__g, __p_);}
   4450     template<class _URNG>
   4451         _LIBCPP_INLINE_VISIBILITY
   4452         result_type operator()(_URNG& __g, const param_type& __p)
   4453         {return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
   4454 
   4455     // property functions
   4456     _LIBCPP_INLINE_VISIBILITY
   4457     result_type m() const {return __p_.m();}
   4458     _LIBCPP_INLINE_VISIBILITY
   4459     result_type s() const {return __p_.s();}
   4460 
   4461     _LIBCPP_INLINE_VISIBILITY
   4462     param_type param() const {return __p_;}
   4463     _LIBCPP_INLINE_VISIBILITY
   4464     void param(const param_type& __p) {__p_ = __p;}
   4465 
   4466     _LIBCPP_INLINE_VISIBILITY
   4467     result_type min() const {return 0;}
   4468     _LIBCPP_INLINE_VISIBILITY
   4469     result_type max() const {return numeric_limits<result_type>::infinity();}
   4470 
   4471     friend _LIBCPP_INLINE_VISIBILITY
   4472         bool operator==(const lognormal_distribution& __x,
   4473                         const lognormal_distribution& __y)
   4474         {return __x.__p_ == __y.__p_;}
   4475     friend _LIBCPP_INLINE_VISIBILITY
   4476         bool operator!=(const lognormal_distribution& __x,
   4477                         const lognormal_distribution& __y)
   4478         {return !(__x == __y);}
   4479 
   4480     template <class _CharT, class _Traits, class _RT>
   4481     friend
   4482     basic_ostream<_CharT, _Traits>&
   4483     operator<<(basic_ostream<_CharT, _Traits>& __os,
   4484                const lognormal_distribution<_RT>& __x);
   4485 
   4486     template <class _CharT, class _Traits, class _RT>
   4487     friend
   4488     basic_istream<_CharT, _Traits>&
   4489     operator>>(basic_istream<_CharT, _Traits>& __is,
   4490                lognormal_distribution<_RT>& __x);
   4491 };
   4492 
   4493 template <class _CharT, class _Traits, class _RT>
   4494 inline _LIBCPP_INLINE_VISIBILITY
   4495 basic_ostream<_CharT, _Traits>&
   4496 operator<<(basic_ostream<_CharT, _Traits>& __os,
   4497            const lognormal_distribution<_RT>& __x)
   4498 {
   4499     return __os << __x.__p_.__nd_;
   4500 }
   4501 
   4502 template <class _CharT, class _Traits, class _RT>
   4503 inline _LIBCPP_INLINE_VISIBILITY
   4504 basic_istream<_CharT, _Traits>&
   4505 operator>>(basic_istream<_CharT, _Traits>& __is,
   4506            lognormal_distribution<_RT>& __x)
   4507 {
   4508     return __is >> __x.__p_.__nd_;
   4509 }
   4510 
   4511 // poisson_distribution
   4512 
   4513 template<class _IntType = int>
   4514 class _LIBCPP_TEMPLATE_VIS poisson_distribution
   4515 {
   4516 public:
   4517     // types
   4518     typedef _IntType result_type;
   4519 
   4520     class _LIBCPP_TEMPLATE_VIS param_type
   4521     {
   4522         double __mean_;
   4523         double __s_;
   4524         double __d_;
   4525         double __l_;
   4526         double __omega_;
   4527         double __c0_;
   4528         double __c1_;
   4529         double __c2_;
   4530         double __c3_;
   4531         double __c_;
   4532 
   4533     public:
   4534         typedef poisson_distribution distribution_type;
   4535 
   4536         explicit param_type(double __mean = 1.0);
   4537 
   4538         _LIBCPP_INLINE_VISIBILITY
   4539         double mean() const {return __mean_;}
   4540 
   4541         friend _LIBCPP_INLINE_VISIBILITY
   4542             bool operator==(const param_type& __x, const param_type& __y)
   4543             {return __x.__mean_ == __y.__mean_;}
   4544         friend _LIBCPP_INLINE_VISIBILITY
   4545             bool operator!=(const param_type& __x, const param_type& __y)
   4546             {return !(__x == __y);}
   4547 
   4548         friend class poisson_distribution;
   4549     };
   4550 
   4551 private:
   4552     param_type __p_;
   4553 
   4554 public:
   4555     // constructors and reset functions
   4556     _LIBCPP_INLINE_VISIBILITY
   4557     explicit poisson_distribution(double __mean = 1.0) : __p_(__mean) {}
   4558     _LIBCPP_INLINE_VISIBILITY
   4559     explicit poisson_distribution(const param_type& __p) : __p_(__p) {}
   4560     _LIBCPP_INLINE_VISIBILITY
   4561     void reset() {}
   4562 
   4563     // generating functions
   4564     template<class _URNG>
   4565         _LIBCPP_INLINE_VISIBILITY
   4566         result_type operator()(_URNG& __g)
   4567         {return (*this)(__g, __p_);}
   4568     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   4569 
   4570     // property functions
   4571     _LIBCPP_INLINE_VISIBILITY
   4572     double mean() const {return __p_.mean();}
   4573 
   4574     _LIBCPP_INLINE_VISIBILITY
   4575     param_type param() const {return __p_;}
   4576     _LIBCPP_INLINE_VISIBILITY
   4577     void param(const param_type& __p) {__p_ = __p;}
   4578 
   4579     _LIBCPP_INLINE_VISIBILITY
   4580     result_type min() const {return 0;}
   4581     _LIBCPP_INLINE_VISIBILITY
   4582     result_type max() const {return numeric_limits<result_type>::max();}
   4583 
   4584     friend _LIBCPP_INLINE_VISIBILITY
   4585         bool operator==(const poisson_distribution& __x,
   4586                         const poisson_distribution& __y)
   4587         {return __x.__p_ == __y.__p_;}
   4588     friend _LIBCPP_INLINE_VISIBILITY
   4589         bool operator!=(const poisson_distribution& __x,
   4590                         const poisson_distribution& __y)
   4591         {return !(__x == __y);}
   4592 };
   4593 
   4594 template<class _IntType>
   4595 poisson_distribution<_IntType>::param_type::param_type(double __mean)
   4596     : __mean_(__mean)
   4597 {
   4598     if (__mean_ < 10)
   4599     {
   4600         __s_ = 0;
   4601         __d_ = 0;
   4602         __l_ = _VSTD::exp(-__mean_);
   4603         __omega_ = 0;
   4604         __c3_ = 0;
   4605         __c2_ = 0;
   4606         __c1_ = 0;
   4607         __c0_ = 0;
   4608         __c_ = 0;
   4609     }
   4610     else
   4611     {
   4612         __s_ = _VSTD::sqrt(__mean_);
   4613         __d_ = 6 * __mean_ * __mean_;
   4614         __l_ = static_cast<result_type>(__mean_ - 1.1484);
   4615         __omega_ = .3989423 / __s_;
   4616         double __b1_ = .4166667E-1 / __mean_;
   4617         double __b2_ = .3 * __b1_ * __b1_;
   4618         __c3_ = .1428571 * __b1_ * __b2_;
   4619         __c2_ = __b2_ - 15. * __c3_;
   4620         __c1_ = __b1_ - 6. * __b2_ + 45. * __c3_;
   4621         __c0_ = 1. - __b1_ + 3. * __b2_ - 15. * __c3_;
   4622         __c_ = .1069 / __mean_;
   4623     }
   4624 }
   4625 
   4626 template <class _IntType>
   4627 template<class _URNG>
   4628 _IntType
   4629 poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
   4630 {
   4631     result_type __x;
   4632     uniform_real_distribution<double> __urd;
   4633     if (__pr.__mean_ < 10)
   4634     {
   4635          __x = 0;
   4636         for (double __p = __urd(__urng); __p > __pr.__l_; ++__x)
   4637             __p *= __urd(__urng);
   4638     }
   4639     else
   4640     {
   4641         double __difmuk;
   4642         double __g = __pr.__mean_ + __pr.__s_ * normal_distribution<double>()(__urng);
   4643         double __u;
   4644         if (__g > 0)
   4645         {
   4646             __x = static_cast<result_type>(__g);
   4647             if (__x >= __pr.__l_)
   4648                 return __x;
   4649             __difmuk = __pr.__mean_ - __x;
   4650             __u = __urd(__urng);
   4651             if (__pr.__d_ * __u >= __difmuk * __difmuk * __difmuk)
   4652                 return __x;
   4653         }
   4654         exponential_distribution<double> __edist;
   4655         for (bool __using_exp_dist = false; true; __using_exp_dist = true)
   4656         {
   4657             double __e;
   4658             if (__using_exp_dist || __g < 0)
   4659             {
   4660                 double __t;
   4661                 do
   4662                 {
   4663                     __e = __edist(__urng);
   4664                     __u = __urd(__urng);
   4665                     __u += __u - 1;
   4666                     __t = 1.8 + (__u < 0 ? -__e : __e);
   4667                 } while (__t <= -.6744);
   4668                 __x = __pr.__mean_ + __pr.__s_ * __t;
   4669                 __difmuk = __pr.__mean_ - __x;
   4670                 __using_exp_dist = true;
   4671             }
   4672             double __px;
   4673             double __py;
   4674             if (__x < 10)
   4675             {
   4676                 const result_type __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
   4677                                              40320, 362880};
   4678                 __px = -__pr.__mean_;
   4679                 __py = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x];
   4680             }
   4681             else
   4682             {
   4683                 double __del = .8333333E-1 / __x;
   4684                 __del -= 4.8 * __del * __del * __del;
   4685                 double __v = __difmuk / __x;
   4686                 if (_VSTD::abs(__v) > 0.25)
   4687                     __px = __x * _VSTD::log(1 + __v) - __difmuk - __del;
   4688                 else
   4689                     __px = __x * __v * __v * (((((((.1250060 * __v + -.1384794) *
   4690                            __v + .1421878) * __v + -.1661269) * __v + .2000118) *
   4691                            __v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
   4692                 __py = .3989423 / _VSTD::sqrt(__x);
   4693             }
   4694             double __r = (0.5 - __difmuk) / __pr.__s_;
   4695             double __r2 = __r * __r;
   4696             double __fx = -0.5 * __r2;
   4697             double __fy = __pr.__omega_ * (((__pr.__c3_ * __r2 + __pr.__c2_) *
   4698                                         __r2 + __pr.__c1_) * __r2 + __pr.__c0_);
   4699             if (__using_exp_dist)
   4700             {
   4701                 if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
   4702                                                    __fy * _VSTD::exp(__fx + __e))
   4703                     break;
   4704             }
   4705             else
   4706             {
   4707                 if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
   4708                     break;
   4709             }
   4710         }
   4711     }
   4712     return __x;
   4713 }
   4714 
   4715 template <class _CharT, class _Traits, class _IntType>
   4716 basic_ostream<_CharT, _Traits>&
   4717 operator<<(basic_ostream<_CharT, _Traits>& __os,
   4718            const poisson_distribution<_IntType>& __x)
   4719 {
   4720     __save_flags<_CharT, _Traits> __lx(__os);
   4721     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   4722                ios_base::scientific);
   4723     return __os << __x.mean();
   4724 }
   4725 
   4726 template <class _CharT, class _Traits, class _IntType>
   4727 basic_istream<_CharT, _Traits>&
   4728 operator>>(basic_istream<_CharT, _Traits>& __is,
   4729            poisson_distribution<_IntType>& __x)
   4730 {
   4731     typedef poisson_distribution<_IntType> _Eng;
   4732     typedef typename _Eng::param_type param_type;
   4733     __save_flags<_CharT, _Traits> __lx(__is);
   4734     __is.flags(ios_base::dec | ios_base::skipws);
   4735     double __mean;
   4736     __is >> __mean;
   4737     if (!__is.fail())
   4738         __x.param(param_type(__mean));
   4739     return __is;
   4740 }
   4741 
   4742 // weibull_distribution
   4743 
   4744 template<class _RealType = double>
   4745 class _LIBCPP_TEMPLATE_VIS weibull_distribution
   4746 {
   4747 public:
   4748     // types
   4749     typedef _RealType result_type;
   4750 
   4751     class _LIBCPP_TEMPLATE_VIS param_type
   4752     {
   4753         result_type __a_;
   4754         result_type __b_;
   4755     public:
   4756         typedef weibull_distribution distribution_type;
   4757 
   4758         _LIBCPP_INLINE_VISIBILITY
   4759         explicit param_type(result_type __a = 1, result_type __b = 1)
   4760             : __a_(__a), __b_(__b) {}
   4761 
   4762         _LIBCPP_INLINE_VISIBILITY
   4763         result_type a() const {return __a_;}
   4764         _LIBCPP_INLINE_VISIBILITY
   4765         result_type b() const {return __b_;}
   4766 
   4767         friend _LIBCPP_INLINE_VISIBILITY
   4768             bool operator==(const param_type& __x, const param_type& __y)
   4769             {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
   4770         friend _LIBCPP_INLINE_VISIBILITY
   4771             bool operator!=(const param_type& __x, const param_type& __y)
   4772             {return !(__x == __y);}
   4773     };
   4774 
   4775 private:
   4776     param_type __p_;
   4777 
   4778 public:
   4779     // constructor and reset functions
   4780     _LIBCPP_INLINE_VISIBILITY
   4781     explicit weibull_distribution(result_type __a = 1, result_type __b = 1)
   4782         : __p_(param_type(__a, __b)) {}
   4783     _LIBCPP_INLINE_VISIBILITY
   4784     explicit weibull_distribution(const param_type& __p)
   4785         : __p_(__p) {}
   4786     _LIBCPP_INLINE_VISIBILITY
   4787     void reset() {}
   4788 
   4789     // generating functions
   4790     template<class _URNG>
   4791         _LIBCPP_INLINE_VISIBILITY
   4792         result_type operator()(_URNG& __g)
   4793         {return (*this)(__g, __p_);}
   4794     template<class _URNG>
   4795         _LIBCPP_INLINE_VISIBILITY
   4796         result_type operator()(_URNG& __g, const param_type& __p)
   4797         {return __p.b() *
   4798             _VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
   4799 
   4800     // property functions
   4801     _LIBCPP_INLINE_VISIBILITY
   4802     result_type a() const {return __p_.a();}
   4803     _LIBCPP_INLINE_VISIBILITY
   4804     result_type b() const {return __p_.b();}
   4805 
   4806     _LIBCPP_INLINE_VISIBILITY
   4807     param_type param() const {return __p_;}
   4808     _LIBCPP_INLINE_VISIBILITY
   4809     void param(const param_type& __p) {__p_ = __p;}
   4810 
   4811     _LIBCPP_INLINE_VISIBILITY
   4812     result_type min() const {return 0;}
   4813     _LIBCPP_INLINE_VISIBILITY
   4814     result_type max() const {return numeric_limits<result_type>::infinity();}
   4815 
   4816     friend _LIBCPP_INLINE_VISIBILITY
   4817         bool operator==(const weibull_distribution& __x,
   4818                         const weibull_distribution& __y)
   4819         {return __x.__p_ == __y.__p_;}
   4820     friend _LIBCPP_INLINE_VISIBILITY
   4821         bool operator!=(const weibull_distribution& __x,
   4822                         const weibull_distribution& __y)
   4823         {return !(__x == __y);}
   4824 };
   4825 
   4826 template <class _CharT, class _Traits, class _RT>
   4827 basic_ostream<_CharT, _Traits>&
   4828 operator<<(basic_ostream<_CharT, _Traits>& __os,
   4829            const weibull_distribution<_RT>& __x)
   4830 {
   4831     __save_flags<_CharT, _Traits> __lx(__os);
   4832     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   4833                ios_base::scientific);
   4834     _CharT __sp = __os.widen(' ');
   4835     __os.fill(__sp);
   4836     __os << __x.a() << __sp << __x.b();
   4837     return __os;
   4838 }
   4839 
   4840 template <class _CharT, class _Traits, class _RT>
   4841 basic_istream<_CharT, _Traits>&
   4842 operator>>(basic_istream<_CharT, _Traits>& __is,
   4843            weibull_distribution<_RT>& __x)
   4844 {
   4845     typedef weibull_distribution<_RT> _Eng;
   4846     typedef typename _Eng::result_type result_type;
   4847     typedef typename _Eng::param_type param_type;
   4848     __save_flags<_CharT, _Traits> __lx(__is);
   4849     __is.flags(ios_base::dec | ios_base::skipws);
   4850     result_type __a;
   4851     result_type __b;
   4852     __is >> __a >> __b;
   4853     if (!__is.fail())
   4854         __x.param(param_type(__a, __b));
   4855     return __is;
   4856 }
   4857 
   4858 template<class _RealType = double>
   4859 class _LIBCPP_TEMPLATE_VIS extreme_value_distribution
   4860 {
   4861 public:
   4862     // types
   4863     typedef _RealType result_type;
   4864 
   4865     class _LIBCPP_TEMPLATE_VIS param_type
   4866     {
   4867         result_type __a_;
   4868         result_type __b_;
   4869     public:
   4870         typedef extreme_value_distribution distribution_type;
   4871 
   4872         _LIBCPP_INLINE_VISIBILITY
   4873         explicit param_type(result_type __a = 0, result_type __b = 1)
   4874             : __a_(__a), __b_(__b) {}
   4875 
   4876         _LIBCPP_INLINE_VISIBILITY
   4877         result_type a() const {return __a_;}
   4878         _LIBCPP_INLINE_VISIBILITY
   4879         result_type b() const {return __b_;}
   4880 
   4881         friend _LIBCPP_INLINE_VISIBILITY
   4882             bool operator==(const param_type& __x, const param_type& __y)
   4883             {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
   4884         friend _LIBCPP_INLINE_VISIBILITY
   4885             bool operator!=(const param_type& __x, const param_type& __y)
   4886             {return !(__x == __y);}
   4887     };
   4888 
   4889 private:
   4890     param_type __p_;
   4891 
   4892 public:
   4893     // constructor and reset functions
   4894     _LIBCPP_INLINE_VISIBILITY
   4895     explicit extreme_value_distribution(result_type __a = 0, result_type __b = 1)
   4896         : __p_(param_type(__a, __b)) {}
   4897     _LIBCPP_INLINE_VISIBILITY
   4898     explicit extreme_value_distribution(const param_type& __p)
   4899         : __p_(__p) {}
   4900     _LIBCPP_INLINE_VISIBILITY
   4901     void reset() {}
   4902 
   4903     // generating functions
   4904     template<class _URNG>
   4905         _LIBCPP_INLINE_VISIBILITY
   4906         result_type operator()(_URNG& __g)
   4907         {return (*this)(__g, __p_);}
   4908     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   4909 
   4910     // property functions
   4911     _LIBCPP_INLINE_VISIBILITY
   4912     result_type a() const {return __p_.a();}
   4913     _LIBCPP_INLINE_VISIBILITY
   4914     result_type b() const {return __p_.b();}
   4915 
   4916     _LIBCPP_INLINE_VISIBILITY
   4917     param_type param() const {return __p_;}
   4918     _LIBCPP_INLINE_VISIBILITY
   4919     void param(const param_type& __p) {__p_ = __p;}
   4920 
   4921     _LIBCPP_INLINE_VISIBILITY
   4922     result_type min() const {return -numeric_limits<result_type>::infinity();}
   4923     _LIBCPP_INLINE_VISIBILITY
   4924     result_type max() const {return numeric_limits<result_type>::infinity();}
   4925 
   4926     friend _LIBCPP_INLINE_VISIBILITY
   4927         bool operator==(const extreme_value_distribution& __x,
   4928                         const extreme_value_distribution& __y)
   4929         {return __x.__p_ == __y.__p_;}
   4930     friend _LIBCPP_INLINE_VISIBILITY
   4931         bool operator!=(const extreme_value_distribution& __x,
   4932                         const extreme_value_distribution& __y)
   4933         {return !(__x == __y);}
   4934 };
   4935 
   4936 template<class _RealType>
   4937 template<class _URNG>
   4938 _RealType
   4939 extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   4940 {
   4941     return __p.a() - __p.b() *
   4942          _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
   4943 }
   4944 
   4945 template <class _CharT, class _Traits, class _RT>
   4946 basic_ostream<_CharT, _Traits>&
   4947 operator<<(basic_ostream<_CharT, _Traits>& __os,
   4948            const extreme_value_distribution<_RT>& __x)
   4949 {
   4950     __save_flags<_CharT, _Traits> __lx(__os);
   4951     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   4952                ios_base::scientific);
   4953     _CharT __sp = __os.widen(' ');
   4954     __os.fill(__sp);
   4955     __os << __x.a() << __sp << __x.b();
   4956     return __os;
   4957 }
   4958 
   4959 template <class _CharT, class _Traits, class _RT>
   4960 basic_istream<_CharT, _Traits>&
   4961 operator>>(basic_istream<_CharT, _Traits>& __is,
   4962            extreme_value_distribution<_RT>& __x)
   4963 {
   4964     typedef extreme_value_distribution<_RT> _Eng;
   4965     typedef typename _Eng::result_type result_type;
   4966     typedef typename _Eng::param_type param_type;
   4967     __save_flags<_CharT, _Traits> __lx(__is);
   4968     __is.flags(ios_base::dec | ios_base::skipws);
   4969     result_type __a;
   4970     result_type __b;
   4971     __is >> __a >> __b;
   4972     if (!__is.fail())
   4973         __x.param(param_type(__a, __b));
   4974     return __is;
   4975 }
   4976 
   4977 // gamma_distribution
   4978 
   4979 template<class _RealType = double>
   4980 class _LIBCPP_TEMPLATE_VIS gamma_distribution
   4981 {
   4982 public:
   4983     // types
   4984     typedef _RealType result_type;
   4985 
   4986     class _LIBCPP_TEMPLATE_VIS param_type
   4987     {
   4988         result_type __alpha_;
   4989         result_type __beta_;
   4990     public:
   4991         typedef gamma_distribution distribution_type;
   4992 
   4993         _LIBCPP_INLINE_VISIBILITY
   4994         explicit param_type(result_type __alpha = 1, result_type __beta = 1)
   4995             : __alpha_(__alpha), __beta_(__beta) {}
   4996 
   4997         _LIBCPP_INLINE_VISIBILITY
   4998         result_type alpha() const {return __alpha_;}
   4999         _LIBCPP_INLINE_VISIBILITY
   5000         result_type beta() const {return __beta_;}
   5001 
   5002         friend _LIBCPP_INLINE_VISIBILITY
   5003             bool operator==(const param_type& __x, const param_type& __y)
   5004             {return __x.__alpha_ == __y.__alpha_ && __x.__beta_ == __y.__beta_;}
   5005         friend _LIBCPP_INLINE_VISIBILITY
   5006             bool operator!=(const param_type& __x, const param_type& __y)
   5007             {return !(__x == __y);}
   5008     };
   5009 
   5010 private:
   5011     param_type __p_;
   5012 
   5013 public:
   5014     // constructors and reset functions
   5015     _LIBCPP_INLINE_VISIBILITY
   5016     explicit gamma_distribution(result_type __alpha = 1, result_type __beta = 1)
   5017         : __p_(param_type(__alpha, __beta)) {}
   5018     _LIBCPP_INLINE_VISIBILITY
   5019     explicit gamma_distribution(const param_type& __p)
   5020         : __p_(__p) {}
   5021     _LIBCPP_INLINE_VISIBILITY
   5022     void reset() {}
   5023 
   5024     // generating functions
   5025     template<class _URNG>
   5026         _LIBCPP_INLINE_VISIBILITY
   5027         result_type operator()(_URNG& __g)
   5028         {return (*this)(__g, __p_);}
   5029     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   5030 
   5031     // property functions
   5032     _LIBCPP_INLINE_VISIBILITY
   5033     result_type alpha() const {return __p_.alpha();}
   5034     _LIBCPP_INLINE_VISIBILITY
   5035     result_type beta() const {return __p_.beta();}
   5036 
   5037     _LIBCPP_INLINE_VISIBILITY
   5038     param_type param() const {return __p_;}
   5039     _LIBCPP_INLINE_VISIBILITY
   5040     void param(const param_type& __p) {__p_ = __p;}
   5041 
   5042     _LIBCPP_INLINE_VISIBILITY
   5043     result_type min() const {return 0;}
   5044     _LIBCPP_INLINE_VISIBILITY
   5045     result_type max() const {return numeric_limits<result_type>::infinity();}
   5046 
   5047     friend _LIBCPP_INLINE_VISIBILITY
   5048         bool operator==(const gamma_distribution& __x,
   5049                         const gamma_distribution& __y)
   5050         {return __x.__p_ == __y.__p_;}
   5051     friend _LIBCPP_INLINE_VISIBILITY
   5052         bool operator!=(const gamma_distribution& __x,
   5053                         const gamma_distribution& __y)
   5054         {return !(__x == __y);}
   5055 };
   5056 
   5057 template <class _RealType>
   5058 template<class _URNG>
   5059 _RealType
   5060 gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   5061 {
   5062     result_type __a = __p.alpha();
   5063     uniform_real_distribution<result_type> __gen(0, 1);
   5064     exponential_distribution<result_type> __egen;
   5065     result_type __x;
   5066     if (__a == 1)
   5067         __x = __egen(__g);
   5068     else if (__a > 1)
   5069     {
   5070         const result_type __b = __a - 1;
   5071         const result_type __c = 3 * __a - result_type(0.75);
   5072         while (true)
   5073         {
   5074             const result_type __u = __gen(__g);
   5075             const result_type __v = __gen(__g);
   5076             const result_type __w = __u * (1 - __u);
   5077             if (__w != 0)
   5078             {
   5079                 const result_type __y = _VSTD::sqrt(__c / __w) *
   5080                                         (__u - result_type(0.5));
   5081                 __x = __b + __y;
   5082                 if (__x >= 0)
   5083                 {
   5084                     const result_type __z = 64 * __w * __w * __w * __v * __v;
   5085                     if (__z <= 1 - 2 * __y * __y / __x)
   5086                         break;
   5087                     if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
   5088                         break;
   5089                 }
   5090             }
   5091         }
   5092     }
   5093     else  // __a < 1
   5094     {
   5095         while (true)
   5096         {
   5097             const result_type __u = __gen(__g);
   5098             const result_type __es = __egen(__g);
   5099             if (__u <= 1 - __a)
   5100             {
   5101                 __x = _VSTD::pow(__u, 1 / __a);
   5102                 if (__x <= __es)
   5103                     break;
   5104             }
   5105             else
   5106             {
   5107                 const result_type __e = -_VSTD::log((1-__u)/__a);
   5108                 __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
   5109                 if (__x <= __e + __es)
   5110                     break;
   5111             }
   5112         }
   5113     }
   5114     return __x * __p.beta();
   5115 }
   5116 
   5117 template <class _CharT, class _Traits, class _RT>
   5118 basic_ostream<_CharT, _Traits>&
   5119 operator<<(basic_ostream<_CharT, _Traits>& __os,
   5120            const gamma_distribution<_RT>& __x)
   5121 {
   5122     __save_flags<_CharT, _Traits> __lx(__os);
   5123     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   5124                ios_base::scientific);
   5125     _CharT __sp = __os.widen(' ');
   5126     __os.fill(__sp);
   5127     __os << __x.alpha() << __sp << __x.beta();
   5128     return __os;
   5129 }
   5130 
   5131 template <class _CharT, class _Traits, class _RT>
   5132 basic_istream<_CharT, _Traits>&
   5133 operator>>(basic_istream<_CharT, _Traits>& __is,
   5134            gamma_distribution<_RT>& __x)
   5135 {
   5136     typedef gamma_distribution<_RT> _Eng;
   5137     typedef typename _Eng::result_type result_type;
   5138     typedef typename _Eng::param_type param_type;
   5139     __save_flags<_CharT, _Traits> __lx(__is);
   5140     __is.flags(ios_base::dec | ios_base::skipws);
   5141     result_type __alpha;
   5142     result_type __beta;
   5143     __is >> __alpha >> __beta;
   5144     if (!__is.fail())
   5145         __x.param(param_type(__alpha, __beta));
   5146     return __is;
   5147 }
   5148 
   5149 // negative_binomial_distribution
   5150 
   5151 template<class _IntType = int>
   5152 class _LIBCPP_TEMPLATE_VIS negative_binomial_distribution
   5153 {
   5154 public:
   5155     // types
   5156     typedef _IntType result_type;
   5157 
   5158     class _LIBCPP_TEMPLATE_VIS param_type
   5159     {
   5160         result_type __k_;
   5161         double __p_;
   5162     public:
   5163         typedef negative_binomial_distribution distribution_type;
   5164 
   5165         _LIBCPP_INLINE_VISIBILITY
   5166         explicit param_type(result_type __k = 1, double __p = 0.5)
   5167             : __k_(__k), __p_(__p) {}
   5168 
   5169         _LIBCPP_INLINE_VISIBILITY
   5170         result_type k() const {return __k_;}
   5171         _LIBCPP_INLINE_VISIBILITY
   5172         double p() const {return __p_;}
   5173 
   5174         friend _LIBCPP_INLINE_VISIBILITY
   5175             bool operator==(const param_type& __x, const param_type& __y)
   5176             {return __x.__k_ == __y.__k_ && __x.__p_ == __y.__p_;}
   5177         friend _LIBCPP_INLINE_VISIBILITY
   5178             bool operator!=(const param_type& __x, const param_type& __y)
   5179             {return !(__x == __y);}
   5180     };
   5181 
   5182 private:
   5183     param_type __p_;
   5184 
   5185 public:
   5186     // constructor and reset functions
   5187     _LIBCPP_INLINE_VISIBILITY
   5188     explicit negative_binomial_distribution(result_type __k = 1, double __p = 0.5)
   5189         : __p_(__k, __p) {}
   5190     _LIBCPP_INLINE_VISIBILITY
   5191     explicit negative_binomial_distribution(const param_type& __p) : __p_(__p) {}
   5192     _LIBCPP_INLINE_VISIBILITY
   5193     void reset() {}
   5194 
   5195     // generating functions
   5196     template<class _URNG>
   5197         _LIBCPP_INLINE_VISIBILITY
   5198         result_type operator()(_URNG& __g)
   5199         {return (*this)(__g, __p_);}
   5200     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   5201 
   5202     // property functions
   5203     _LIBCPP_INLINE_VISIBILITY
   5204     result_type k() const {return __p_.k();}
   5205     _LIBCPP_INLINE_VISIBILITY
   5206     double p() const {return __p_.p();}
   5207 
   5208     _LIBCPP_INLINE_VISIBILITY
   5209     param_type param() const {return __p_;}
   5210     _LIBCPP_INLINE_VISIBILITY
   5211     void param(const param_type& __p) {__p_ = __p;}
   5212 
   5213     _LIBCPP_INLINE_VISIBILITY
   5214     result_type min() const {return 0;}
   5215     _LIBCPP_INLINE_VISIBILITY
   5216     result_type max() const {return numeric_limits<result_type>::max();}
   5217 
   5218     friend _LIBCPP_INLINE_VISIBILITY
   5219         bool operator==(const negative_binomial_distribution& __x,
   5220                         const negative_binomial_distribution& __y)
   5221         {return __x.__p_ == __y.__p_;}
   5222     friend _LIBCPP_INLINE_VISIBILITY
   5223         bool operator!=(const negative_binomial_distribution& __x,
   5224                         const negative_binomial_distribution& __y)
   5225         {return !(__x == __y);}
   5226 };
   5227 
   5228 template <class _IntType>
   5229 template<class _URNG>
   5230 _IntType
   5231 negative_binomial_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr)
   5232 {
   5233     result_type __k = __pr.k();
   5234     double __p = __pr.p();
   5235     if (__k <= 21 * __p)
   5236     {
   5237         bernoulli_distribution __gen(__p);
   5238         result_type __f = 0;
   5239         result_type __s = 0;
   5240         while (__s < __k)
   5241         {
   5242             if (__gen(__urng))
   5243                 ++__s;
   5244             else
   5245                 ++__f;
   5246         }
   5247         return __f;
   5248     }
   5249     return poisson_distribution<result_type>(gamma_distribution<double>
   5250                                             (__k, (1-__p)/__p)(__urng))(__urng);
   5251 }
   5252 
   5253 template <class _CharT, class _Traits, class _IntType>
   5254 basic_ostream<_CharT, _Traits>&
   5255 operator<<(basic_ostream<_CharT, _Traits>& __os,
   5256            const negative_binomial_distribution<_IntType>& __x)
   5257 {
   5258     __save_flags<_CharT, _Traits> __lx(__os);
   5259     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   5260                ios_base::scientific);
   5261     _CharT __sp = __os.widen(' ');
   5262     __os.fill(__sp);
   5263     return __os << __x.k() << __sp << __x.p();
   5264 }
   5265 
   5266 template <class _CharT, class _Traits, class _IntType>
   5267 basic_istream<_CharT, _Traits>&
   5268 operator>>(basic_istream<_CharT, _Traits>& __is,
   5269            negative_binomial_distribution<_IntType>& __x)
   5270 {
   5271     typedef negative_binomial_distribution<_IntType> _Eng;
   5272     typedef typename _Eng::result_type result_type;
   5273     typedef typename _Eng::param_type param_type;
   5274     __save_flags<_CharT, _Traits> __lx(__is);
   5275     __is.flags(ios_base::dec | ios_base::skipws);
   5276     result_type __k;
   5277     double __p;
   5278     __is >> __k >> __p;
   5279     if (!__is.fail())
   5280         __x.param(param_type(__k, __p));
   5281     return __is;
   5282 }
   5283 
   5284 // geometric_distribution
   5285 
   5286 template<class _IntType = int>
   5287 class _LIBCPP_TEMPLATE_VIS geometric_distribution
   5288 {
   5289 public:
   5290     // types
   5291     typedef _IntType result_type;
   5292 
   5293     class _LIBCPP_TEMPLATE_VIS param_type
   5294     {
   5295         double __p_;
   5296     public:
   5297         typedef geometric_distribution distribution_type;
   5298 
   5299         _LIBCPP_INLINE_VISIBILITY
   5300         explicit param_type(double __p = 0.5) : __p_(__p) {}
   5301 
   5302         _LIBCPP_INLINE_VISIBILITY
   5303         double p() const {return __p_;}
   5304 
   5305         friend _LIBCPP_INLINE_VISIBILITY
   5306             bool operator==(const param_type& __x, const param_type& __y)
   5307             {return __x.__p_ == __y.__p_;}
   5308         friend _LIBCPP_INLINE_VISIBILITY
   5309             bool operator!=(const param_type& __x, const param_type& __y)
   5310             {return !(__x == __y);}
   5311     };
   5312 
   5313 private:
   5314     param_type __p_;
   5315 
   5316 public:
   5317     // constructors and reset functions
   5318     _LIBCPP_INLINE_VISIBILITY
   5319     explicit geometric_distribution(double __p = 0.5) : __p_(__p) {}
   5320     _LIBCPP_INLINE_VISIBILITY
   5321     explicit geometric_distribution(const param_type& __p) : __p_(__p) {}
   5322     _LIBCPP_INLINE_VISIBILITY
   5323     void reset() {}
   5324 
   5325     // generating functions
   5326     template<class _URNG>
   5327         _LIBCPP_INLINE_VISIBILITY
   5328         result_type operator()(_URNG& __g)
   5329         {return (*this)(__g, __p_);}
   5330     template<class _URNG>
   5331         _LIBCPP_INLINE_VISIBILITY
   5332         result_type operator()(_URNG& __g, const param_type& __p)
   5333         {return negative_binomial_distribution<result_type>(1, __p.p())(__g);}
   5334 
   5335     // property functions
   5336     _LIBCPP_INLINE_VISIBILITY
   5337     double p() const {return __p_.p();}
   5338 
   5339     _LIBCPP_INLINE_VISIBILITY
   5340     param_type param() const {return __p_;}
   5341     _LIBCPP_INLINE_VISIBILITY
   5342     void param(const param_type& __p) {__p_ = __p;}
   5343 
   5344     _LIBCPP_INLINE_VISIBILITY
   5345     result_type min() const {return 0;}
   5346     _LIBCPP_INLINE_VISIBILITY
   5347     result_type max() const {return numeric_limits<result_type>::max();}
   5348 
   5349     friend _LIBCPP_INLINE_VISIBILITY
   5350         bool operator==(const geometric_distribution& __x,
   5351                         const geometric_distribution& __y)
   5352         {return __x.__p_ == __y.__p_;}
   5353     friend _LIBCPP_INLINE_VISIBILITY
   5354         bool operator!=(const geometric_distribution& __x,
   5355                         const geometric_distribution& __y)
   5356         {return !(__x == __y);}
   5357 };
   5358 
   5359 template <class _CharT, class _Traits, class _IntType>
   5360 basic_ostream<_CharT, _Traits>&
   5361 operator<<(basic_ostream<_CharT, _Traits>& __os,
   5362            const geometric_distribution<_IntType>& __x)
   5363 {
   5364     __save_flags<_CharT, _Traits> __lx(__os);
   5365     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   5366                ios_base::scientific);
   5367     return __os << __x.p();
   5368 }
   5369 
   5370 template <class _CharT, class _Traits, class _IntType>
   5371 basic_istream<_CharT, _Traits>&
   5372 operator>>(basic_istream<_CharT, _Traits>& __is,
   5373            geometric_distribution<_IntType>& __x)
   5374 {
   5375     typedef geometric_distribution<_IntType> _Eng;
   5376     typedef typename _Eng::param_type param_type;
   5377     __save_flags<_CharT, _Traits> __lx(__is);
   5378     __is.flags(ios_base::dec | ios_base::skipws);
   5379     double __p;
   5380     __is >> __p;
   5381     if (!__is.fail())
   5382         __x.param(param_type(__p));
   5383     return __is;
   5384 }
   5385 
   5386 // chi_squared_distribution
   5387 
   5388 template<class _RealType = double>
   5389 class _LIBCPP_TEMPLATE_VIS chi_squared_distribution
   5390 {
   5391 public:
   5392     // types
   5393     typedef _RealType result_type;
   5394 
   5395     class _LIBCPP_TEMPLATE_VIS param_type
   5396     {
   5397         result_type __n_;
   5398     public:
   5399         typedef chi_squared_distribution distribution_type;
   5400 
   5401         _LIBCPP_INLINE_VISIBILITY
   5402         explicit param_type(result_type __n = 1) : __n_(__n) {}
   5403 
   5404         _LIBCPP_INLINE_VISIBILITY
   5405         result_type n() const {return __n_;}
   5406 
   5407         friend _LIBCPP_INLINE_VISIBILITY
   5408             bool operator==(const param_type& __x, const param_type& __y)
   5409             {return __x.__n_ == __y.__n_;}
   5410         friend _LIBCPP_INLINE_VISIBILITY
   5411             bool operator!=(const param_type& __x, const param_type& __y)
   5412             {return !(__x == __y);}
   5413     };
   5414 
   5415 private:
   5416     param_type __p_;
   5417 
   5418 public:
   5419     // constructor and reset functions
   5420     _LIBCPP_INLINE_VISIBILITY
   5421     explicit chi_squared_distribution(result_type __n = 1)
   5422         : __p_(param_type(__n)) {}
   5423     _LIBCPP_INLINE_VISIBILITY
   5424     explicit chi_squared_distribution(const param_type& __p)
   5425         : __p_(__p) {}
   5426     _LIBCPP_INLINE_VISIBILITY
   5427     void reset() {}
   5428 
   5429     // generating functions
   5430     template<class _URNG>
   5431         _LIBCPP_INLINE_VISIBILITY
   5432         result_type operator()(_URNG& __g)
   5433         {return (*this)(__g, __p_);}
   5434     template<class _URNG>
   5435         _LIBCPP_INLINE_VISIBILITY
   5436         result_type operator()(_URNG& __g, const param_type& __p)
   5437         {return gamma_distribution<result_type>(__p.n() / 2, 2)(__g);}
   5438 
   5439     // property functions
   5440     _LIBCPP_INLINE_VISIBILITY
   5441     result_type n() const {return __p_.n();}
   5442 
   5443     _LIBCPP_INLINE_VISIBILITY
   5444     param_type param() const {return __p_;}
   5445     _LIBCPP_INLINE_VISIBILITY
   5446     void param(const param_type& __p) {__p_ = __p;}
   5447 
   5448     _LIBCPP_INLINE_VISIBILITY
   5449     result_type min() const {return 0;}
   5450     _LIBCPP_INLINE_VISIBILITY
   5451     result_type max() const {return numeric_limits<result_type>::infinity();}
   5452 
   5453     friend _LIBCPP_INLINE_VISIBILITY
   5454         bool operator==(const chi_squared_distribution& __x,
   5455                         const chi_squared_distribution& __y)
   5456         {return __x.__p_ == __y.__p_;}
   5457     friend _LIBCPP_INLINE_VISIBILITY
   5458         bool operator!=(const chi_squared_distribution& __x,
   5459                         const chi_squared_distribution& __y)
   5460         {return !(__x == __y);}
   5461 };
   5462 
   5463 template <class _CharT, class _Traits, class _RT>
   5464 basic_ostream<_CharT, _Traits>&
   5465 operator<<(basic_ostream<_CharT, _Traits>& __os,
   5466            const chi_squared_distribution<_RT>& __x)
   5467 {
   5468     __save_flags<_CharT, _Traits> __lx(__os);
   5469     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   5470                ios_base::scientific);
   5471     __os << __x.n();
   5472     return __os;
   5473 }
   5474 
   5475 template <class _CharT, class _Traits, class _RT>
   5476 basic_istream<_CharT, _Traits>&
   5477 operator>>(basic_istream<_CharT, _Traits>& __is,
   5478            chi_squared_distribution<_RT>& __x)
   5479 {
   5480     typedef chi_squared_distribution<_RT> _Eng;
   5481     typedef typename _Eng::result_type result_type;
   5482     typedef typename _Eng::param_type param_type;
   5483     __save_flags<_CharT, _Traits> __lx(__is);
   5484     __is.flags(ios_base::dec | ios_base::skipws);
   5485     result_type __n;
   5486     __is >> __n;
   5487     if (!__is.fail())
   5488         __x.param(param_type(__n));
   5489     return __is;
   5490 }
   5491 
   5492 // cauchy_distribution
   5493 
   5494 template<class _RealType = double>
   5495 class _LIBCPP_TEMPLATE_VIS cauchy_distribution
   5496 {
   5497 public:
   5498     // types
   5499     typedef _RealType result_type;
   5500 
   5501     class _LIBCPP_TEMPLATE_VIS param_type
   5502     {
   5503         result_type __a_;
   5504         result_type __b_;
   5505     public:
   5506         typedef cauchy_distribution distribution_type;
   5507 
   5508         _LIBCPP_INLINE_VISIBILITY
   5509         explicit param_type(result_type __a = 0, result_type __b = 1)
   5510             : __a_(__a), __b_(__b) {}
   5511 
   5512         _LIBCPP_INLINE_VISIBILITY
   5513         result_type a() const {return __a_;}
   5514         _LIBCPP_INLINE_VISIBILITY
   5515         result_type b() const {return __b_;}
   5516 
   5517         friend _LIBCPP_INLINE_VISIBILITY
   5518             bool operator==(const param_type& __x, const param_type& __y)
   5519             {return __x.__a_ == __y.__a_ && __x.__b_ == __y.__b_;}
   5520         friend _LIBCPP_INLINE_VISIBILITY
   5521             bool operator!=(const param_type& __x, const param_type& __y)
   5522             {return !(__x == __y);}
   5523     };
   5524 
   5525 private:
   5526     param_type __p_;
   5527 
   5528 public:
   5529     // constructor and reset functions
   5530     _LIBCPP_INLINE_VISIBILITY
   5531     explicit cauchy_distribution(result_type __a = 0, result_type __b = 1)
   5532         : __p_(param_type(__a, __b)) {}
   5533     _LIBCPP_INLINE_VISIBILITY
   5534     explicit cauchy_distribution(const param_type& __p)
   5535         : __p_(__p) {}
   5536     _LIBCPP_INLINE_VISIBILITY
   5537     void reset() {}
   5538 
   5539     // generating functions
   5540     template<class _URNG>
   5541         _LIBCPP_INLINE_VISIBILITY
   5542         result_type operator()(_URNG& __g)
   5543         {return (*this)(__g, __p_);}
   5544     template<class _URNG> _LIBCPP_INLINE_VISIBILITY result_type operator()(_URNG& __g, const param_type& __p);
   5545 
   5546     // property functions
   5547     _LIBCPP_INLINE_VISIBILITY
   5548     result_type a() const {return __p_.a();}
   5549     _LIBCPP_INLINE_VISIBILITY
   5550     result_type b() const {return __p_.b();}
   5551 
   5552     _LIBCPP_INLINE_VISIBILITY
   5553     param_type param() const {return __p_;}
   5554     _LIBCPP_INLINE_VISIBILITY
   5555     void param(const param_type& __p) {__p_ = __p;}
   5556 
   5557     _LIBCPP_INLINE_VISIBILITY
   5558     result_type min() const {return -numeric_limits<result_type>::infinity();}
   5559     _LIBCPP_INLINE_VISIBILITY
   5560     result_type max() const {return numeric_limits<result_type>::infinity();}
   5561 
   5562     friend _LIBCPP_INLINE_VISIBILITY
   5563         bool operator==(const cauchy_distribution& __x,
   5564                         const cauchy_distribution& __y)
   5565         {return __x.__p_ == __y.__p_;}
   5566     friend _LIBCPP_INLINE_VISIBILITY
   5567         bool operator!=(const cauchy_distribution& __x,
   5568                         const cauchy_distribution& __y)
   5569         {return !(__x == __y);}
   5570 };
   5571 
   5572 template <class _RealType>
   5573 template<class _URNG>
   5574 inline
   5575 _RealType
   5576 cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   5577 {
   5578     uniform_real_distribution<result_type> __gen;
   5579     // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
   5580     return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
   5581 }
   5582 
   5583 template <class _CharT, class _Traits, class _RT>
   5584 basic_ostream<_CharT, _Traits>&
   5585 operator<<(basic_ostream<_CharT, _Traits>& __os,
   5586            const cauchy_distribution<_RT>& __x)
   5587 {
   5588     __save_flags<_CharT, _Traits> __lx(__os);
   5589     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   5590                ios_base::scientific);
   5591     _CharT __sp = __os.widen(' ');
   5592     __os.fill(__sp);
   5593     __os << __x.a() << __sp << __x.b();
   5594     return __os;
   5595 }
   5596 
   5597 template <class _CharT, class _Traits, class _RT>
   5598 basic_istream<_CharT, _Traits>&
   5599 operator>>(basic_istream<_CharT, _Traits>& __is,
   5600            cauchy_distribution<_RT>& __x)
   5601 {
   5602     typedef cauchy_distribution<_RT> _Eng;
   5603     typedef typename _Eng::result_type result_type;
   5604     typedef typename _Eng::param_type param_type;
   5605     __save_flags<_CharT, _Traits> __lx(__is);
   5606     __is.flags(ios_base::dec | ios_base::skipws);
   5607     result_type __a;
   5608     result_type __b;
   5609     __is >> __a >> __b;
   5610     if (!__is.fail())
   5611         __x.param(param_type(__a, __b));
   5612     return __is;
   5613 }
   5614 
   5615 // fisher_f_distribution
   5616 
   5617 template<class _RealType = double>
   5618 class _LIBCPP_TEMPLATE_VIS fisher_f_distribution
   5619 {
   5620 public:
   5621     // types
   5622     typedef _RealType result_type;
   5623 
   5624     class _LIBCPP_TEMPLATE_VIS param_type
   5625     {
   5626         result_type __m_;
   5627         result_type __n_;
   5628     public:
   5629         typedef fisher_f_distribution distribution_type;
   5630 
   5631         _LIBCPP_INLINE_VISIBILITY
   5632         explicit param_type(result_type __m = 1, result_type __n = 1)
   5633             : __m_(__m), __n_(__n) {}
   5634 
   5635         _LIBCPP_INLINE_VISIBILITY
   5636         result_type m() const {return __m_;}
   5637         _LIBCPP_INLINE_VISIBILITY
   5638         result_type n() const {return __n_;}
   5639 
   5640         friend _LIBCPP_INLINE_VISIBILITY
   5641             bool operator==(const param_type& __x, const param_type& __y)
   5642             {return __x.__m_ == __y.__m_ && __x.__n_ == __y.__n_;}
   5643         friend _LIBCPP_INLINE_VISIBILITY
   5644             bool operator!=(const param_type& __x, const param_type& __y)
   5645             {return !(__x == __y);}
   5646     };
   5647 
   5648 private:
   5649     param_type __p_;
   5650 
   5651 public:
   5652     // constructor and reset functions
   5653     _LIBCPP_INLINE_VISIBILITY
   5654     explicit fisher_f_distribution(result_type __m = 1, result_type __n = 1)
   5655         : __p_(param_type(__m, __n)) {}
   5656     _LIBCPP_INLINE_VISIBILITY
   5657     explicit fisher_f_distribution(const param_type& __p)
   5658         : __p_(__p) {}
   5659     _LIBCPP_INLINE_VISIBILITY
   5660     void reset() {}
   5661 
   5662     // generating functions
   5663     template<class _URNG>
   5664         _LIBCPP_INLINE_VISIBILITY
   5665         result_type operator()(_URNG& __g)
   5666         {return (*this)(__g, __p_);}
   5667     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   5668 
   5669     // property functions
   5670     _LIBCPP_INLINE_VISIBILITY
   5671     result_type m() const {return __p_.m();}
   5672     _LIBCPP_INLINE_VISIBILITY
   5673     result_type n() const {return __p_.n();}
   5674 
   5675     _LIBCPP_INLINE_VISIBILITY
   5676     param_type param() const {return __p_;}
   5677     _LIBCPP_INLINE_VISIBILITY
   5678     void param(const param_type& __p) {__p_ = __p;}
   5679 
   5680     _LIBCPP_INLINE_VISIBILITY
   5681     result_type min() const {return 0;}
   5682     _LIBCPP_INLINE_VISIBILITY
   5683     result_type max() const {return numeric_limits<result_type>::infinity();}
   5684 
   5685     friend _LIBCPP_INLINE_VISIBILITY
   5686         bool operator==(const fisher_f_distribution& __x,
   5687                         const fisher_f_distribution& __y)
   5688         {return __x.__p_ == __y.__p_;}
   5689     friend _LIBCPP_INLINE_VISIBILITY
   5690         bool operator!=(const fisher_f_distribution& __x,
   5691                         const fisher_f_distribution& __y)
   5692         {return !(__x == __y);}
   5693 };
   5694 
   5695 template <class _RealType>
   5696 template<class _URNG>
   5697 _RealType
   5698 fisher_f_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   5699 {
   5700     gamma_distribution<result_type> __gdm(__p.m() * result_type(.5));
   5701     gamma_distribution<result_type> __gdn(__p.n() * result_type(.5));
   5702     return __p.n() * __gdm(__g) / (__p.m() * __gdn(__g));
   5703 }
   5704 
   5705 template <class _CharT, class _Traits, class _RT>
   5706 basic_ostream<_CharT, _Traits>&
   5707 operator<<(basic_ostream<_CharT, _Traits>& __os,
   5708            const fisher_f_distribution<_RT>& __x)
   5709 {
   5710     __save_flags<_CharT, _Traits> __lx(__os);
   5711     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   5712                ios_base::scientific);
   5713     _CharT __sp = __os.widen(' ');
   5714     __os.fill(__sp);
   5715     __os << __x.m() << __sp << __x.n();
   5716     return __os;
   5717 }
   5718 
   5719 template <class _CharT, class _Traits, class _RT>
   5720 basic_istream<_CharT, _Traits>&
   5721 operator>>(basic_istream<_CharT, _Traits>& __is,
   5722            fisher_f_distribution<_RT>& __x)
   5723 {
   5724     typedef fisher_f_distribution<_RT> _Eng;
   5725     typedef typename _Eng::result_type result_type;
   5726     typedef typename _Eng::param_type param_type;
   5727     __save_flags<_CharT, _Traits> __lx(__is);
   5728     __is.flags(ios_base::dec | ios_base::skipws);
   5729     result_type __m;
   5730     result_type __n;
   5731     __is >> __m >> __n;
   5732     if (!__is.fail())
   5733         __x.param(param_type(__m, __n));
   5734     return __is;
   5735 }
   5736 
   5737 // student_t_distribution
   5738 
   5739 template<class _RealType = double>
   5740 class _LIBCPP_TEMPLATE_VIS student_t_distribution
   5741 {
   5742 public:
   5743     // types
   5744     typedef _RealType result_type;
   5745 
   5746     class _LIBCPP_TEMPLATE_VIS param_type
   5747     {
   5748         result_type __n_;
   5749     public:
   5750         typedef student_t_distribution distribution_type;
   5751 
   5752         _LIBCPP_INLINE_VISIBILITY
   5753         explicit param_type(result_type __n = 1) : __n_(__n) {}
   5754 
   5755         _LIBCPP_INLINE_VISIBILITY
   5756         result_type n() const {return __n_;}
   5757 
   5758         friend _LIBCPP_INLINE_VISIBILITY
   5759             bool operator==(const param_type& __x, const param_type& __y)
   5760             {return __x.__n_ == __y.__n_;}
   5761         friend _LIBCPP_INLINE_VISIBILITY
   5762             bool operator!=(const param_type& __x, const param_type& __y)
   5763             {return !(__x == __y);}
   5764     };
   5765 
   5766 private:
   5767     param_type __p_;
   5768     normal_distribution<result_type> __nd_;
   5769 
   5770 public:
   5771     // constructor and reset functions
   5772     _LIBCPP_INLINE_VISIBILITY
   5773     explicit student_t_distribution(result_type __n = 1)
   5774         : __p_(param_type(__n)) {}
   5775     _LIBCPP_INLINE_VISIBILITY
   5776     explicit student_t_distribution(const param_type& __p)
   5777         : __p_(__p) {}
   5778     _LIBCPP_INLINE_VISIBILITY
   5779     void reset() {__nd_.reset();}
   5780 
   5781     // generating functions
   5782     template<class _URNG>
   5783         _LIBCPP_INLINE_VISIBILITY
   5784         result_type operator()(_URNG& __g)
   5785         {return (*this)(__g, __p_);}
   5786     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   5787 
   5788     // property functions
   5789     _LIBCPP_INLINE_VISIBILITY
   5790     result_type n() const {return __p_.n();}
   5791 
   5792     _LIBCPP_INLINE_VISIBILITY
   5793     param_type param() const {return __p_;}
   5794     _LIBCPP_INLINE_VISIBILITY
   5795     void param(const param_type& __p) {__p_ = __p;}
   5796 
   5797     _LIBCPP_INLINE_VISIBILITY
   5798     result_type min() const {return -numeric_limits<result_type>::infinity();}
   5799     _LIBCPP_INLINE_VISIBILITY
   5800     result_type max() const {return numeric_limits<result_type>::infinity();}
   5801 
   5802     friend _LIBCPP_INLINE_VISIBILITY
   5803         bool operator==(const student_t_distribution& __x,
   5804                         const student_t_distribution& __y)
   5805         {return __x.__p_ == __y.__p_;}
   5806     friend _LIBCPP_INLINE_VISIBILITY
   5807         bool operator!=(const student_t_distribution& __x,
   5808                         const student_t_distribution& __y)
   5809         {return !(__x == __y);}
   5810 };
   5811 
   5812 template <class _RealType>
   5813 template<class _URNG>
   5814 _RealType
   5815 student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   5816 {
   5817     gamma_distribution<result_type> __gd(__p.n() * .5, 2);
   5818     return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
   5819 }
   5820 
   5821 template <class _CharT, class _Traits, class _RT>
   5822 basic_ostream<_CharT, _Traits>&
   5823 operator<<(basic_ostream<_CharT, _Traits>& __os,
   5824            const student_t_distribution<_RT>& __x)
   5825 {
   5826     __save_flags<_CharT, _Traits> __lx(__os);
   5827     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   5828                ios_base::scientific);
   5829     __os << __x.n();
   5830     return __os;
   5831 }
   5832 
   5833 template <class _CharT, class _Traits, class _RT>
   5834 basic_istream<_CharT, _Traits>&
   5835 operator>>(basic_istream<_CharT, _Traits>& __is,
   5836            student_t_distribution<_RT>& __x)
   5837 {
   5838     typedef student_t_distribution<_RT> _Eng;
   5839     typedef typename _Eng::result_type result_type;
   5840     typedef typename _Eng::param_type param_type;
   5841     __save_flags<_CharT, _Traits> __lx(__is);
   5842     __is.flags(ios_base::dec | ios_base::skipws);
   5843     result_type __n;
   5844     __is >> __n;
   5845     if (!__is.fail())
   5846         __x.param(param_type(__n));
   5847     return __is;
   5848 }
   5849 
   5850 // discrete_distribution
   5851 
   5852 template<class _IntType = int>
   5853 class _LIBCPP_TEMPLATE_VIS discrete_distribution
   5854 {
   5855 public:
   5856     // types
   5857     typedef _IntType result_type;
   5858 
   5859     class _LIBCPP_TEMPLATE_VIS param_type
   5860     {
   5861         vector<double> __p_;
   5862     public:
   5863         typedef discrete_distribution distribution_type;
   5864 
   5865         _LIBCPP_INLINE_VISIBILITY
   5866         param_type() {}
   5867         template<class _InputIterator>
   5868             _LIBCPP_INLINE_VISIBILITY
   5869             param_type(_InputIterator __f, _InputIterator __l)
   5870             : __p_(__f, __l) {__init();}
   5871 #ifndef _LIBCPP_CXX03_LANG
   5872         _LIBCPP_INLINE_VISIBILITY
   5873         param_type(initializer_list<double> __wl)
   5874             : __p_(__wl.begin(), __wl.end()) {__init();}
   5875 #endif  // _LIBCPP_CXX03_LANG
   5876         template<class _UnaryOperation>
   5877             param_type(size_t __nw, double __xmin, double __xmax,
   5878                        _UnaryOperation __fw);
   5879 
   5880         vector<double> probabilities() const;
   5881 
   5882         friend _LIBCPP_INLINE_VISIBILITY
   5883             bool operator==(const param_type& __x, const param_type& __y)
   5884             {return __x.__p_ == __y.__p_;}
   5885         friend _LIBCPP_INLINE_VISIBILITY
   5886             bool operator!=(const param_type& __x, const param_type& __y)
   5887             {return !(__x == __y);}
   5888 
   5889     private:
   5890         void __init();
   5891 
   5892         friend class discrete_distribution;
   5893 
   5894         template <class _CharT, class _Traits, class _IT>
   5895         friend
   5896         basic_ostream<_CharT, _Traits>&
   5897         operator<<(basic_ostream<_CharT, _Traits>& __os,
   5898                    const discrete_distribution<_IT>& __x);
   5899 
   5900         template <class _CharT, class _Traits, class _IT>
   5901         friend
   5902         basic_istream<_CharT, _Traits>&
   5903         operator>>(basic_istream<_CharT, _Traits>& __is,
   5904                    discrete_distribution<_IT>& __x);
   5905     };
   5906 
   5907 private:
   5908     param_type __p_;
   5909 
   5910 public:
   5911     // constructor and reset functions
   5912     _LIBCPP_INLINE_VISIBILITY
   5913     discrete_distribution() {}
   5914     template<class _InputIterator>
   5915         _LIBCPP_INLINE_VISIBILITY
   5916         discrete_distribution(_InputIterator __f, _InputIterator __l)
   5917             : __p_(__f, __l) {}
   5918 #ifndef _LIBCPP_CXX03_LANG
   5919     _LIBCPP_INLINE_VISIBILITY
   5920     discrete_distribution(initializer_list<double> __wl)
   5921         : __p_(__wl) {}
   5922 #endif  // _LIBCPP_CXX03_LANG
   5923     template<class _UnaryOperation>
   5924         _LIBCPP_INLINE_VISIBILITY
   5925         discrete_distribution(size_t __nw, double __xmin, double __xmax,
   5926                               _UnaryOperation __fw)
   5927         : __p_(__nw, __xmin, __xmax, __fw) {}
   5928     _LIBCPP_INLINE_VISIBILITY
   5929     explicit discrete_distribution(const param_type& __p)
   5930         : __p_(__p) {}
   5931     _LIBCPP_INLINE_VISIBILITY
   5932     void reset() {}
   5933 
   5934     // generating functions
   5935     template<class _URNG>
   5936         _LIBCPP_INLINE_VISIBILITY
   5937         result_type operator()(_URNG& __g)
   5938         {return (*this)(__g, __p_);}
   5939     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   5940 
   5941     // property functions
   5942     _LIBCPP_INLINE_VISIBILITY
   5943     vector<double> probabilities() const {return __p_.probabilities();}
   5944 
   5945     _LIBCPP_INLINE_VISIBILITY
   5946     param_type param() const {return __p_;}
   5947     _LIBCPP_INLINE_VISIBILITY
   5948     void param(const param_type& __p) {__p_ = __p;}
   5949 
   5950     _LIBCPP_INLINE_VISIBILITY
   5951     result_type min() const {return 0;}
   5952     _LIBCPP_INLINE_VISIBILITY
   5953     result_type max() const {return __p_.__p_.size();}
   5954 
   5955     friend _LIBCPP_INLINE_VISIBILITY
   5956         bool operator==(const discrete_distribution& __x,
   5957                         const discrete_distribution& __y)
   5958         {return __x.__p_ == __y.__p_;}
   5959     friend _LIBCPP_INLINE_VISIBILITY
   5960         bool operator!=(const discrete_distribution& __x,
   5961                         const discrete_distribution& __y)
   5962         {return !(__x == __y);}
   5963 
   5964     template <class _CharT, class _Traits, class _IT>
   5965     friend
   5966     basic_ostream<_CharT, _Traits>&
   5967     operator<<(basic_ostream<_CharT, _Traits>& __os,
   5968                const discrete_distribution<_IT>& __x);
   5969 
   5970     template <class _CharT, class _Traits, class _IT>
   5971     friend
   5972     basic_istream<_CharT, _Traits>&
   5973     operator>>(basic_istream<_CharT, _Traits>& __is,
   5974                discrete_distribution<_IT>& __x);
   5975 };
   5976 
   5977 template<class _IntType>
   5978 template<class _UnaryOperation>
   5979 discrete_distribution<_IntType>::param_type::param_type(size_t __nw,
   5980                                                         double __xmin,
   5981                                                         double __xmax,
   5982                                                         _UnaryOperation __fw)
   5983 {
   5984     if (__nw > 1)
   5985     {
   5986         __p_.reserve(__nw - 1);
   5987         double __d = (__xmax - __xmin) / __nw;
   5988         double __d2 = __d / 2;
   5989         for (size_t __k = 0; __k < __nw; ++__k)
   5990             __p_.push_back(__fw(__xmin + __k * __d + __d2));
   5991         __init();
   5992     }
   5993 }
   5994 
   5995 template<class _IntType>
   5996 void
   5997 discrete_distribution<_IntType>::param_type::__init()
   5998 {
   5999     if (!__p_.empty())
   6000     {
   6001         if (__p_.size() > 1)
   6002         {
   6003             double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
   6004             for (_VSTD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
   6005                                                                        __i < __e; ++__i)
   6006                 *__i /= __s;
   6007             vector<double> __t(__p_.size() - 1);
   6008             _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
   6009             swap(__p_, __t);
   6010         }
   6011         else
   6012         {
   6013             __p_.clear();
   6014             __p_.shrink_to_fit();
   6015         }
   6016     }
   6017 }
   6018 
   6019 template<class _IntType>
   6020 vector<double>
   6021 discrete_distribution<_IntType>::param_type::probabilities() const
   6022 {
   6023     size_t __n = __p_.size();
   6024     _VSTD::vector<double> __p(__n+1);
   6025     _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
   6026     if (__n > 0)
   6027         __p[__n] = 1 - __p_[__n-1];
   6028     else
   6029         __p[0] = 1;
   6030     return __p;
   6031 }
   6032 
   6033 template<class _IntType>
   6034 template<class _URNG>
   6035 _IntType
   6036 discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
   6037 {
   6038     uniform_real_distribution<double> __gen;
   6039     return static_cast<_IntType>(
   6040            _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
   6041                                                               __p.__p_.begin());
   6042 }
   6043 
   6044 template <class _CharT, class _Traits, class _IT>
   6045 basic_ostream<_CharT, _Traits>&
   6046 operator<<(basic_ostream<_CharT, _Traits>& __os,
   6047            const discrete_distribution<_IT>& __x)
   6048 {
   6049     __save_flags<_CharT, _Traits> __lx(__os);
   6050     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   6051                ios_base::scientific);
   6052     _CharT __sp = __os.widen(' ');
   6053     __os.fill(__sp);
   6054     size_t __n = __x.__p_.__p_.size();
   6055     __os << __n;
   6056     for (size_t __i = 0; __i < __n; ++__i)
   6057         __os << __sp << __x.__p_.__p_[__i];
   6058     return __os;
   6059 }
   6060 
   6061 template <class _CharT, class _Traits, class _IT>
   6062 basic_istream<_CharT, _Traits>&
   6063 operator>>(basic_istream<_CharT, _Traits>& __is,
   6064            discrete_distribution<_IT>& __x)
   6065 {
   6066     __save_flags<_CharT, _Traits> __lx(__is);
   6067     __is.flags(ios_base::dec | ios_base::skipws);
   6068     size_t __n;
   6069     __is >> __n;
   6070     vector<double> __p(__n);
   6071     for (size_t __i = 0; __i < __n; ++__i)
   6072         __is >> __p[__i];
   6073     if (!__is.fail())
   6074         swap(__x.__p_.__p_, __p);
   6075     return __is;
   6076 }
   6077 
   6078 // piecewise_constant_distribution
   6079 
   6080 template<class _RealType = double>
   6081 class _LIBCPP_TEMPLATE_VIS piecewise_constant_distribution
   6082 {
   6083 public:
   6084     // types
   6085     typedef _RealType result_type;
   6086 
   6087     class _LIBCPP_TEMPLATE_VIS param_type
   6088     {
   6089         vector<result_type> __b_;
   6090         vector<result_type> __densities_;
   6091         vector<result_type> __areas_;
   6092     public:
   6093         typedef piecewise_constant_distribution distribution_type;
   6094 
   6095         param_type();
   6096         template<class _InputIteratorB, class _InputIteratorW>
   6097             param_type(_InputIteratorB __fB, _InputIteratorB __lB,
   6098                        _InputIteratorW __fW);
   6099 #ifndef _LIBCPP_CXX03_LANG
   6100         template<class _UnaryOperation>
   6101             param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
   6102 #endif  // _LIBCPP_CXX03_LANG
   6103         template<class _UnaryOperation>
   6104             param_type(size_t __nw, result_type __xmin, result_type __xmax,
   6105                        _UnaryOperation __fw);
   6106         param_type & operator=(const param_type& __rhs);
   6107 
   6108         _LIBCPP_INLINE_VISIBILITY
   6109         vector<result_type> intervals() const {return __b_;}
   6110         _LIBCPP_INLINE_VISIBILITY
   6111         vector<result_type> densities() const {return __densities_;}
   6112 
   6113         friend _LIBCPP_INLINE_VISIBILITY
   6114             bool operator==(const param_type& __x, const param_type& __y)
   6115             {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
   6116         friend _LIBCPP_INLINE_VISIBILITY
   6117             bool operator!=(const param_type& __x, const param_type& __y)
   6118             {return !(__x == __y);}
   6119 
   6120     private:
   6121         void __init();
   6122 
   6123         friend class piecewise_constant_distribution;
   6124 
   6125         template <class _CharT, class _Traits, class _RT>
   6126         friend
   6127         basic_ostream<_CharT, _Traits>&
   6128         operator<<(basic_ostream<_CharT, _Traits>& __os,
   6129                    const piecewise_constant_distribution<_RT>& __x);
   6130 
   6131         template <class _CharT, class _Traits, class _RT>
   6132         friend
   6133         basic_istream<_CharT, _Traits>&
   6134         operator>>(basic_istream<_CharT, _Traits>& __is,
   6135                    piecewise_constant_distribution<_RT>& __x);
   6136     };
   6137 
   6138 private:
   6139     param_type __p_;
   6140 
   6141 public:
   6142     // constructor and reset functions
   6143     _LIBCPP_INLINE_VISIBILITY
   6144     piecewise_constant_distribution() {}
   6145     template<class _InputIteratorB, class _InputIteratorW>
   6146         _LIBCPP_INLINE_VISIBILITY
   6147         piecewise_constant_distribution(_InputIteratorB __fB,
   6148                                         _InputIteratorB __lB,
   6149                                         _InputIteratorW __fW)
   6150         : __p_(__fB, __lB, __fW) {}
   6151 
   6152 #ifndef _LIBCPP_CXX03_LANG
   6153     template<class _UnaryOperation>
   6154         _LIBCPP_INLINE_VISIBILITY
   6155         piecewise_constant_distribution(initializer_list<result_type> __bl,
   6156                                         _UnaryOperation __fw)
   6157         : __p_(__bl, __fw) {}
   6158 #endif  // _LIBCPP_CXX03_LANG
   6159 
   6160     template<class _UnaryOperation>
   6161         _LIBCPP_INLINE_VISIBILITY
   6162         piecewise_constant_distribution(size_t __nw, result_type __xmin,
   6163                                         result_type __xmax, _UnaryOperation __fw)
   6164         : __p_(__nw, __xmin, __xmax, __fw) {}
   6165 
   6166     _LIBCPP_INLINE_VISIBILITY
   6167     explicit piecewise_constant_distribution(const param_type& __p)
   6168         : __p_(__p) {}
   6169 
   6170     _LIBCPP_INLINE_VISIBILITY
   6171     void reset() {}
   6172 
   6173     // generating functions
   6174     template<class _URNG>
   6175         _LIBCPP_INLINE_VISIBILITY
   6176         result_type operator()(_URNG& __g)
   6177         {return (*this)(__g, __p_);}
   6178     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   6179 
   6180     // property functions
   6181     _LIBCPP_INLINE_VISIBILITY
   6182     vector<result_type> intervals() const {return __p_.intervals();}
   6183     _LIBCPP_INLINE_VISIBILITY
   6184     vector<result_type> densities() const {return __p_.densities();}
   6185 
   6186     _LIBCPP_INLINE_VISIBILITY
   6187     param_type param() const {return __p_;}
   6188     _LIBCPP_INLINE_VISIBILITY
   6189     void param(const param_type& __p) {__p_ = __p;}
   6190 
   6191     _LIBCPP_INLINE_VISIBILITY
   6192     result_type min() const {return __p_.__b_.front();}
   6193     _LIBCPP_INLINE_VISIBILITY
   6194     result_type max() const {return __p_.__b_.back();}
   6195 
   6196     friend _LIBCPP_INLINE_VISIBILITY
   6197         bool operator==(const piecewise_constant_distribution& __x,
   6198                         const piecewise_constant_distribution& __y)
   6199         {return __x.__p_ == __y.__p_;}
   6200     friend _LIBCPP_INLINE_VISIBILITY
   6201         bool operator!=(const piecewise_constant_distribution& __x,
   6202                            const piecewise_constant_distribution& __y)
   6203         {return !(__x == __y);}
   6204 
   6205     template <class _CharT, class _Traits, class _RT>
   6206     friend
   6207     basic_ostream<_CharT, _Traits>&
   6208     operator<<(basic_ostream<_CharT, _Traits>& __os,
   6209                const piecewise_constant_distribution<_RT>& __x);
   6210 
   6211     template <class _CharT, class _Traits, class _RT>
   6212     friend
   6213     basic_istream<_CharT, _Traits>&
   6214     operator>>(basic_istream<_CharT, _Traits>& __is,
   6215                piecewise_constant_distribution<_RT>& __x);
   6216 };
   6217 
   6218 template<class _RealType>
   6219 typename piecewise_constant_distribution<_RealType>::param_type &
   6220 piecewise_constant_distribution<_RealType>::param_type::operator=
   6221                                                        (const param_type& __rhs)
   6222 {
   6223 //  These can throw
   6224     __b_.reserve        (__rhs.__b_.size ());
   6225     __densities_.reserve(__rhs.__densities_.size());
   6226     __areas_.reserve    (__rhs.__areas_.size());
   6227 
   6228 //  These can not throw
   6229     __b_         = __rhs.__b_;
   6230     __densities_ = __rhs.__densities_;
   6231     __areas_     =  __rhs.__areas_;
   6232     return *this;
   6233 }
   6234 
   6235 template<class _RealType>
   6236 void
   6237 piecewise_constant_distribution<_RealType>::param_type::__init()
   6238 {
   6239     // __densities_ contains non-normalized areas
   6240     result_type __total_area = _VSTD::accumulate(__densities_.begin(),
   6241                                                 __densities_.end(),
   6242                                                 result_type());
   6243     for (size_t __i = 0; __i < __densities_.size(); ++__i)
   6244         __densities_[__i] /= __total_area;
   6245     // __densities_ contains normalized areas
   6246     __areas_.assign(__densities_.size(), result_type());
   6247     _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
   6248                                                           __areas_.begin() + 1);
   6249     // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
   6250     __densities_.back() = 1 - __areas_.back();  // correct round off error
   6251     for (size_t __i = 0; __i < __densities_.size(); ++__i)
   6252         __densities_[__i] /= (__b_[__i+1] - __b_[__i]);
   6253     // __densities_ now contains __densities_
   6254 }
   6255 
   6256 template<class _RealType>
   6257 piecewise_constant_distribution<_RealType>::param_type::param_type()
   6258     : __b_(2),
   6259       __densities_(1, 1.0),
   6260       __areas_(1, 0.0)
   6261 {
   6262     __b_[1] = 1;
   6263 }
   6264 
   6265 template<class _RealType>
   6266 template<class _InputIteratorB, class _InputIteratorW>
   6267 piecewise_constant_distribution<_RealType>::param_type::param_type(
   6268         _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
   6269     : __b_(__fB, __lB)
   6270 {
   6271     if (__b_.size() < 2)
   6272     {
   6273         __b_.resize(2);
   6274         __b_[0] = 0;
   6275         __b_[1] = 1;
   6276         __densities_.assign(1, 1.0);
   6277         __areas_.assign(1, 0.0);
   6278     }
   6279     else
   6280     {
   6281         __densities_.reserve(__b_.size() - 1);
   6282         for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__fW)
   6283             __densities_.push_back(*__fW);
   6284         __init();
   6285     }
   6286 }
   6287 
   6288 #ifndef _LIBCPP_CXX03_LANG
   6289 
   6290 template<class _RealType>
   6291 template<class _UnaryOperation>
   6292 piecewise_constant_distribution<_RealType>::param_type::param_type(
   6293         initializer_list<result_type> __bl, _UnaryOperation __fw)
   6294     : __b_(__bl.begin(), __bl.end())
   6295 {
   6296     if (__b_.size() < 2)
   6297     {
   6298         __b_.resize(2);
   6299         __b_[0] = 0;
   6300         __b_[1] = 1;
   6301         __densities_.assign(1, 1.0);
   6302         __areas_.assign(1, 0.0);
   6303     }
   6304     else
   6305     {
   6306         __densities_.reserve(__b_.size() - 1);
   6307         for (size_t __i = 0; __i < __b_.size() - 1; ++__i)
   6308             __densities_.push_back(__fw((__b_[__i+1] + __b_[__i])*.5));
   6309         __init();
   6310     }
   6311 }
   6312 
   6313 #endif  // _LIBCPP_CXX03_LANG
   6314 
   6315 template<class _RealType>
   6316 template<class _UnaryOperation>
   6317 piecewise_constant_distribution<_RealType>::param_type::param_type(
   6318         size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
   6319     : __b_(__nw == 0 ? 2 : __nw + 1)
   6320 {
   6321     size_t __n = __b_.size() - 1;
   6322     result_type __d = (__xmax - __xmin) / __n;
   6323     __densities_.reserve(__n);
   6324     for (size_t __i = 0; __i < __n; ++__i)
   6325     {
   6326         __b_[__i] = __xmin + __i * __d;
   6327         __densities_.push_back(__fw(__b_[__i] + __d*.5));
   6328     }
   6329     __b_[__n] = __xmax;
   6330     __init();
   6331 }
   6332 
   6333 template<class _RealType>
   6334 template<class _URNG>
   6335 _RealType
   6336 piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   6337 {
   6338     typedef uniform_real_distribution<result_type> _Gen;
   6339     result_type __u = _Gen()(__g);
   6340     ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
   6341                                       __u) - __p.__areas_.begin() - 1;
   6342     return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
   6343 }
   6344 
   6345 template <class _CharT, class _Traits, class _RT>
   6346 basic_ostream<_CharT, _Traits>&
   6347 operator<<(basic_ostream<_CharT, _Traits>& __os,
   6348            const piecewise_constant_distribution<_RT>& __x)
   6349 {
   6350     __save_flags<_CharT, _Traits> __lx(__os);
   6351     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   6352                ios_base::scientific);
   6353     _CharT __sp = __os.widen(' ');
   6354     __os.fill(__sp);
   6355     size_t __n = __x.__p_.__b_.size();
   6356     __os << __n;
   6357     for (size_t __i = 0; __i < __n; ++__i)
   6358         __os << __sp << __x.__p_.__b_[__i];
   6359     __n = __x.__p_.__densities_.size();
   6360     __os << __sp << __n;
   6361     for (size_t __i = 0; __i < __n; ++__i)
   6362         __os << __sp << __x.__p_.__densities_[__i];
   6363     __n = __x.__p_.__areas_.size();
   6364     __os << __sp << __n;
   6365     for (size_t __i = 0; __i < __n; ++__i)
   6366         __os << __sp << __x.__p_.__areas_[__i];
   6367     return __os;
   6368 }
   6369 
   6370 template <class _CharT, class _Traits, class _RT>
   6371 basic_istream<_CharT, _Traits>&
   6372 operator>>(basic_istream<_CharT, _Traits>& __is,
   6373            piecewise_constant_distribution<_RT>& __x)
   6374 {
   6375     typedef piecewise_constant_distribution<_RT> _Eng;
   6376     typedef typename _Eng::result_type result_type;
   6377     __save_flags<_CharT, _Traits> __lx(__is);
   6378     __is.flags(ios_base::dec | ios_base::skipws);
   6379     size_t __n;
   6380     __is >> __n;
   6381     vector<result_type> __b(__n);
   6382     for (size_t __i = 0; __i < __n; ++__i)
   6383         __is >> __b[__i];
   6384     __is >> __n;
   6385     vector<result_type> __densities(__n);
   6386     for (size_t __i = 0; __i < __n; ++__i)
   6387         __is >> __densities[__i];
   6388     __is >> __n;
   6389     vector<result_type> __areas(__n);
   6390     for (size_t __i = 0; __i < __n; ++__i)
   6391         __is >> __areas[__i];
   6392     if (!__is.fail())
   6393     {
   6394         swap(__x.__p_.__b_, __b);
   6395         swap(__x.__p_.__densities_, __densities);
   6396         swap(__x.__p_.__areas_, __areas);
   6397     }
   6398     return __is;
   6399 }
   6400 
   6401 // piecewise_linear_distribution
   6402 
   6403 template<class _RealType = double>
   6404 class _LIBCPP_TEMPLATE_VIS piecewise_linear_distribution
   6405 {
   6406 public:
   6407     // types
   6408     typedef _RealType result_type;
   6409 
   6410     class _LIBCPP_TEMPLATE_VIS param_type
   6411     {
   6412         vector<result_type> __b_;
   6413         vector<result_type> __densities_;
   6414         vector<result_type> __areas_;
   6415     public:
   6416         typedef piecewise_linear_distribution distribution_type;
   6417 
   6418         param_type();
   6419         template<class _InputIteratorB, class _InputIteratorW>
   6420             param_type(_InputIteratorB __fB, _InputIteratorB __lB,
   6421                        _InputIteratorW __fW);
   6422 #ifndef _LIBCPP_CXX03_LANG
   6423         template<class _UnaryOperation>
   6424             param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
   6425 #endif  // _LIBCPP_CXX03_LANG
   6426         template<class _UnaryOperation>
   6427             param_type(size_t __nw, result_type __xmin, result_type __xmax,
   6428                        _UnaryOperation __fw);
   6429         param_type & operator=(const param_type& __rhs);
   6430         
   6431         _LIBCPP_INLINE_VISIBILITY
   6432         vector<result_type> intervals() const {return __b_;}
   6433         _LIBCPP_INLINE_VISIBILITY
   6434         vector<result_type> densities() const {return __densities_;}
   6435 
   6436         friend _LIBCPP_INLINE_VISIBILITY
   6437             bool operator==(const param_type& __x, const param_type& __y)
   6438             {return __x.__densities_ == __y.__densities_ && __x.__b_ == __y.__b_;}
   6439         friend _LIBCPP_INLINE_VISIBILITY
   6440             bool operator!=(const param_type& __x, const param_type& __y)
   6441             {return !(__x == __y);}
   6442 
   6443     private:
   6444         void __init();
   6445 
   6446         friend class piecewise_linear_distribution;
   6447 
   6448         template <class _CharT, class _Traits, class _RT>
   6449         friend
   6450         basic_ostream<_CharT, _Traits>&
   6451         operator<<(basic_ostream<_CharT, _Traits>& __os,
   6452                    const piecewise_linear_distribution<_RT>& __x);
   6453 
   6454         template <class _CharT, class _Traits, class _RT>
   6455         friend
   6456         basic_istream<_CharT, _Traits>&
   6457         operator>>(basic_istream<_CharT, _Traits>& __is,
   6458                    piecewise_linear_distribution<_RT>& __x);
   6459     };
   6460 
   6461 private:
   6462     param_type __p_;
   6463 
   6464 public:
   6465     // constructor and reset functions
   6466     _LIBCPP_INLINE_VISIBILITY
   6467     piecewise_linear_distribution() {}
   6468     template<class _InputIteratorB, class _InputIteratorW>
   6469         _LIBCPP_INLINE_VISIBILITY
   6470         piecewise_linear_distribution(_InputIteratorB __fB,
   6471                                       _InputIteratorB __lB,
   6472                                       _InputIteratorW __fW)
   6473         : __p_(__fB, __lB, __fW) {}
   6474 
   6475 #ifndef _LIBCPP_CXX03_LANG
   6476     template<class _UnaryOperation>
   6477         _LIBCPP_INLINE_VISIBILITY
   6478         piecewise_linear_distribution(initializer_list<result_type> __bl,
   6479                                       _UnaryOperation __fw)
   6480         : __p_(__bl, __fw) {}
   6481 #endif  // _LIBCPP_CXX03_LANG
   6482 
   6483     template<class _UnaryOperation>
   6484         _LIBCPP_INLINE_VISIBILITY
   6485         piecewise_linear_distribution(size_t __nw, result_type __xmin,
   6486                                       result_type __xmax, _UnaryOperation __fw)
   6487         : __p_(__nw, __xmin, __xmax, __fw) {}
   6488 
   6489     _LIBCPP_INLINE_VISIBILITY
   6490     explicit piecewise_linear_distribution(const param_type& __p)
   6491         : __p_(__p) {}
   6492 
   6493     _LIBCPP_INLINE_VISIBILITY
   6494     void reset() {}
   6495 
   6496     // generating functions
   6497     template<class _URNG>
   6498         _LIBCPP_INLINE_VISIBILITY
   6499         result_type operator()(_URNG& __g)
   6500         {return (*this)(__g, __p_);}
   6501     template<class _URNG> result_type operator()(_URNG& __g, const param_type& __p);
   6502 
   6503     // property functions
   6504     _LIBCPP_INLINE_VISIBILITY
   6505     vector<result_type> intervals() const {return __p_.intervals();}
   6506     _LIBCPP_INLINE_VISIBILITY
   6507     vector<result_type> densities() const {return __p_.densities();}
   6508 
   6509     _LIBCPP_INLINE_VISIBILITY
   6510     param_type param() const {return __p_;}
   6511     _LIBCPP_INLINE_VISIBILITY
   6512     void param(const param_type& __p) {__p_ = __p;}
   6513 
   6514     _LIBCPP_INLINE_VISIBILITY
   6515     result_type min() const {return __p_.__b_.front();}
   6516     _LIBCPP_INLINE_VISIBILITY
   6517     result_type max() const {return __p_.__b_.back();}
   6518 
   6519     friend _LIBCPP_INLINE_VISIBILITY
   6520         bool operator==(const piecewise_linear_distribution& __x,
   6521                         const piecewise_linear_distribution& __y)
   6522         {return __x.__p_ == __y.__p_;}
   6523     friend _LIBCPP_INLINE_VISIBILITY
   6524         bool operator!=(const piecewise_linear_distribution& __x,
   6525                         const piecewise_linear_distribution& __y)
   6526         {return !(__x == __y);}
   6527 
   6528     template <class _CharT, class _Traits, class _RT>
   6529     friend
   6530     basic_ostream<_CharT, _Traits>&
   6531     operator<<(basic_ostream<_CharT, _Traits>& __os,
   6532                const piecewise_linear_distribution<_RT>& __x);
   6533 
   6534     template <class _CharT, class _Traits, class _RT>
   6535     friend
   6536     basic_istream<_CharT, _Traits>&
   6537     operator>>(basic_istream<_CharT, _Traits>& __is,
   6538                piecewise_linear_distribution<_RT>& __x);
   6539 };
   6540 
   6541 template<class _RealType>
   6542 typename piecewise_linear_distribution<_RealType>::param_type &
   6543 piecewise_linear_distribution<_RealType>::param_type::operator=
   6544                                                        (const param_type& __rhs)
   6545 {
   6546 //  These can throw
   6547     __b_.reserve        (__rhs.__b_.size ());
   6548     __densities_.reserve(__rhs.__densities_.size());
   6549     __areas_.reserve    (__rhs.__areas_.size());
   6550 
   6551 //  These can not throw
   6552     __b_         = __rhs.__b_;
   6553     __densities_ = __rhs.__densities_;
   6554     __areas_     =  __rhs.__areas_;
   6555     return *this;
   6556 }
   6557 
   6558 
   6559 template<class _RealType>
   6560 void
   6561 piecewise_linear_distribution<_RealType>::param_type::__init()
   6562 {
   6563     __areas_.assign(__densities_.size() - 1, result_type());
   6564     result_type _Sp = 0;
   6565     for (size_t __i = 0; __i < __areas_.size(); ++__i)
   6566     {
   6567         __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
   6568                         (__b_[__i+1] - __b_[__i]) * .5;
   6569         _Sp += __areas_[__i];
   6570     }
   6571     for (size_t __i = __areas_.size(); __i > 1;)
   6572     {
   6573         --__i;
   6574         __areas_[__i] = __areas_[__i-1] / _Sp;
   6575     }
   6576     __areas_[0] = 0;
   6577     for (size_t __i = 1; __i < __areas_.size(); ++__i)
   6578         __areas_[__i] += __areas_[__i-1];
   6579     for (size_t __i = 0; __i < __densities_.size(); ++__i)
   6580         __densities_[__i] /= _Sp;
   6581 }
   6582 
   6583 template<class _RealType>
   6584 piecewise_linear_distribution<_RealType>::param_type::param_type()
   6585     : __b_(2),
   6586       __densities_(2, 1.0),
   6587       __areas_(1, 0.0)
   6588 {
   6589     __b_[1] = 1;
   6590 }
   6591 
   6592 template<class _RealType>
   6593 template<class _InputIteratorB, class _InputIteratorW>
   6594 piecewise_linear_distribution<_RealType>::param_type::param_type(
   6595         _InputIteratorB __fB, _InputIteratorB __lB, _InputIteratorW __fW)
   6596     : __b_(__fB, __lB)
   6597 {
   6598     if (__b_.size() < 2)
   6599     {
   6600         __b_.resize(2);
   6601         __b_[0] = 0;
   6602         __b_[1] = 1;
   6603         __densities_.assign(2, 1.0);
   6604         __areas_.assign(1, 0.0);
   6605     }
   6606     else
   6607     {
   6608         __densities_.reserve(__b_.size());
   6609         for (size_t __i = 0; __i < __b_.size(); ++__i, ++__fW)
   6610             __densities_.push_back(*__fW);
   6611         __init();
   6612     }
   6613 }
   6614 
   6615 #ifndef _LIBCPP_CXX03_LANG
   6616 
   6617 template<class _RealType>
   6618 template<class _UnaryOperation>
   6619 piecewise_linear_distribution<_RealType>::param_type::param_type(
   6620         initializer_list<result_type> __bl, _UnaryOperation __fw)
   6621     : __b_(__bl.begin(), __bl.end())
   6622 {
   6623     if (__b_.size() < 2)
   6624     {
   6625         __b_.resize(2);
   6626         __b_[0] = 0;
   6627         __b_[1] = 1;
   6628         __densities_.assign(2, 1.0);
   6629         __areas_.assign(1, 0.0);
   6630     }
   6631     else
   6632     {
   6633         __densities_.reserve(__b_.size());
   6634         for (size_t __i = 0; __i < __b_.size(); ++__i)
   6635             __densities_.push_back(__fw(__b_[__i]));
   6636         __init();
   6637     }
   6638 }
   6639 
   6640 #endif  // _LIBCPP_CXX03_LANG
   6641 
   6642 template<class _RealType>
   6643 template<class _UnaryOperation>
   6644 piecewise_linear_distribution<_RealType>::param_type::param_type(
   6645         size_t __nw, result_type __xmin, result_type __xmax, _UnaryOperation __fw)
   6646     : __b_(__nw == 0 ? 2 : __nw + 1)
   6647 {
   6648     size_t __n = __b_.size() - 1;
   6649     result_type __d = (__xmax - __xmin) / __n;
   6650     __densities_.reserve(__b_.size());
   6651     for (size_t __i = 0; __i < __n; ++__i)
   6652     {
   6653         __b_[__i] = __xmin + __i * __d;
   6654         __densities_.push_back(__fw(__b_[__i]));
   6655     }
   6656     __b_[__n] = __xmax;
   6657     __densities_.push_back(__fw(__b_[__n]));
   6658     __init();
   6659 }
   6660 
   6661 template<class _RealType>
   6662 template<class _URNG>
   6663 _RealType
   6664 piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
   6665 {
   6666     typedef uniform_real_distribution<result_type> _Gen;
   6667     result_type __u = _Gen()(__g);
   6668     ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
   6669                                       __u) - __p.__areas_.begin() - 1;
   6670     __u -= __p.__areas_[__k];
   6671     const result_type __dk = __p.__densities_[__k];
   6672     const result_type __dk1 = __p.__densities_[__k+1];
   6673     const result_type __deltad = __dk1 - __dk;
   6674     const result_type __bk = __p.__b_[__k];
   6675     if (__deltad == 0)
   6676         return __u / __dk + __bk;
   6677     const result_type __bk1 = __p.__b_[__k+1];
   6678     const result_type __deltab = __bk1 - __bk;
   6679     return (__bk * __dk1 - __bk1 * __dk +
   6680         _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
   6681         __deltad;
   6682 }
   6683 
   6684 template <class _CharT, class _Traits, class _RT>
   6685 basic_ostream<_CharT, _Traits>&
   6686 operator<<(basic_ostream<_CharT, _Traits>& __os,
   6687            const piecewise_linear_distribution<_RT>& __x)
   6688 {
   6689     __save_flags<_CharT, _Traits> __lx(__os);
   6690     __os.flags(ios_base::dec | ios_base::left | ios_base::fixed |
   6691                ios_base::scientific);
   6692     _CharT __sp = __os.widen(' ');
   6693     __os.fill(__sp);
   6694     size_t __n = __x.__p_.__b_.size();
   6695     __os << __n;
   6696     for (size_t __i = 0; __i < __n; ++__i)
   6697         __os << __sp << __x.__p_.__b_[__i];
   6698     __n = __x.__p_.__densities_.size();
   6699     __os << __sp << __n;
   6700     for (size_t __i = 0; __i < __n; ++__i)
   6701         __os << __sp << __x.__p_.__densities_[__i];
   6702     __n = __x.__p_.__areas_.size();
   6703     __os << __sp << __n;
   6704     for (size_t __i = 0; __i < __n; ++__i)
   6705         __os << __sp << __x.__p_.__areas_[__i];
   6706     return __os;
   6707 }
   6708 
   6709 template <class _CharT, class _Traits, class _RT>
   6710 basic_istream<_CharT, _Traits>&
   6711 operator>>(basic_istream<_CharT, _Traits>& __is,
   6712            piecewise_linear_distribution<_RT>& __x)
   6713 {
   6714     typedef piecewise_linear_distribution<_RT> _Eng;
   6715     typedef typename _Eng::result_type result_type;
   6716     __save_flags<_CharT, _Traits> __lx(__is);
   6717     __is.flags(ios_base::dec | ios_base::skipws);
   6718     size_t __n;
   6719     __is >> __n;
   6720     vector<result_type> __b(__n);
   6721     for (size_t __i = 0; __i < __n; ++__i)
   6722         __is >> __b[__i];
   6723     __is >> __n;
   6724     vector<result_type> __densities(__n);
   6725     for (size_t __i = 0; __i < __n; ++__i)
   6726         __is >> __densities[__i];
   6727     __is >> __n;
   6728     vector<result_type> __areas(__n);
   6729     for (size_t __i = 0; __i < __n; ++__i)
   6730         __is >> __areas[__i];
   6731     if (!__is.fail())
   6732     {
   6733         swap(__x.__p_.__b_, __b);
   6734         swap(__x.__p_.__densities_, __densities);
   6735         swap(__x.__p_.__areas_, __areas);
   6736     }
   6737     return __is;
   6738 }
   6739 
   6740 _LIBCPP_END_NAMESPACE_STD
   6741 
   6742 _LIBCPP_POP_MACROS
   6743 
   6744 #endif  // _LIBCPP_RANDOM
   6745