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