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