1// -*- C++ -*- 2//===----------------------------------------------------------------------===// 3// 4// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 5// See https://llvm.org/LICENSE.txt for license information. 6// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 7// 8//===----------------------------------------------------------------------===// 9 10#ifndef _LIBCPP_RANDOM 11#define _LIBCPP_RANDOM 12 13/* 14 random synopsis 15 16#include <initializer_list> 17 18namespace std 19{ 20// [rand.req.urng], uniform random bit generator requirements 21template<class G> 22concept uniform_random_bit_generator = see below; // C++20 23 24// Engines 25 26template <class UIntType, UIntType a, UIntType c, UIntType m> 27class linear_congruential_engine 28{ 29public: 30 // types 31 typedef UIntType result_type; 32 33 // engine characteristics 34 static constexpr result_type multiplier = a; 35 static constexpr result_type increment = c; 36 static constexpr result_type modulus = m; 37 static constexpr result_type min() { return c == 0u ? 1u: 0u;} 38 static constexpr result_type max() { return m - 1u;} 39 static constexpr result_type default_seed = 1u; 40 41 // constructors and seeding functions 42 explicit linear_congruential_engine(result_type s = default_seed); // before C++20 43 linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++20 44 explicit linear_congruential_engine(result_type s); // C++20 45 template<class Sseq> explicit linear_congruential_engine(Sseq& q); 46 void seed(result_type s = default_seed); 47 template<class Sseq> void seed(Sseq& q); 48 49 // generating functions 50 result_type operator()(); 51 void discard(unsigned long long z); 52}; 53 54template <class UIntType, UIntType a, UIntType c, UIntType m> 55bool 56operator==(const linear_congruential_engine<UIntType, a, c, m>& x, 57 const linear_congruential_engine<UIntType, a, c, m>& y); 58 59template <class UIntType, UIntType a, UIntType c, UIntType m> 60bool 61operator!=(const linear_congruential_engine<UIntType, a, c, m>& x, 62 const linear_congruential_engine<UIntType, a, c, m>& y); 63 64template <class charT, class traits, 65 class UIntType, UIntType a, UIntType c, UIntType m> 66basic_ostream<charT, traits>& 67operator<<(basic_ostream<charT, traits>& os, 68 const linear_congruential_engine<UIntType, a, c, m>& x); 69 70template <class charT, class traits, 71 class UIntType, UIntType a, UIntType c, UIntType m> 72basic_istream<charT, traits>& 73operator>>(basic_istream<charT, traits>& is, 74 linear_congruential_engine<UIntType, a, c, m>& x); 75 76template <class UIntType, size_t w, size_t n, size_t m, size_t r, 77 UIntType a, size_t u, UIntType d, size_t s, 78 UIntType b, size_t t, UIntType c, size_t l, UIntType f> 79class mersenne_twister_engine 80{ 81public: 82 // types 83 typedef UIntType result_type; 84 85 // engine characteristics 86 static constexpr size_t word_size = w; 87 static constexpr size_t state_size = n; 88 static constexpr size_t shift_size = m; 89 static constexpr size_t mask_bits = r; 90 static constexpr result_type xor_mask = a; 91 static constexpr size_t tempering_u = u; 92 static constexpr result_type tempering_d = d; 93 static constexpr size_t tempering_s = s; 94 static constexpr result_type tempering_b = b; 95 static constexpr size_t tempering_t = t; 96 static constexpr result_type tempering_c = c; 97 static constexpr size_t tempering_l = l; 98 static constexpr result_type initialization_multiplier = f; 99 static constexpr result_type min () { return 0; } 100 static constexpr result_type max() { return 2^w - 1; } 101 static constexpr result_type default_seed = 5489u; 102 103 // constructors and seeding functions 104 explicit mersenne_twister_engine(result_type s = default_seed); // before C++20 105 mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20 106 explicit mersenne_twister_engine(result_type s); // C++20 107 template<class Sseq> explicit mersenne_twister_engine(Sseq& q); 108 void seed(result_type value = default_seed); 109 template<class Sseq> void seed(Sseq& q); 110 111 // generating functions 112 result_type operator()(); 113 void discard(unsigned long long z); 114}; 115 116template <class UIntType, size_t w, size_t n, size_t m, size_t r, 117 UIntType a, size_t u, UIntType d, size_t s, 118 UIntType b, size_t t, UIntType c, size_t l, UIntType f> 119bool 120operator==( 121 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x, 122 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y); 123 124template <class UIntType, size_t w, size_t n, size_t m, size_t r, 125 UIntType a, size_t u, UIntType d, size_t s, 126 UIntType b, size_t t, UIntType c, size_t l, UIntType f> 127bool 128operator!=( 129 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x, 130 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& y); 131 132template <class charT, class traits, 133 class UIntType, size_t w, size_t n, size_t m, size_t r, 134 UIntType a, size_t u, UIntType d, size_t s, 135 UIntType b, size_t t, UIntType c, size_t l, UIntType f> 136basic_ostream<charT, traits>& 137operator<<(basic_ostream<charT, traits>& os, 138 const mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x); 139 140template <class charT, class traits, 141 class UIntType, size_t w, size_t n, size_t m, size_t r, 142 UIntType a, size_t u, UIntType d, size_t s, 143 UIntType b, size_t t, UIntType c, size_t l, UIntType f> 144basic_istream<charT, traits>& 145operator>>(basic_istream<charT, traits>& is, 146 mersenne_twister_engine<UIntType, w, n, m, r, a, u, d, s, b, t, c, l, f>& x); 147 148template<class UIntType, size_t w, size_t s, size_t r> 149class subtract_with_carry_engine 150{ 151public: 152 // types 153 typedef UIntType result_type; 154 155 // engine characteristics 156 static constexpr size_t word_size = w; 157 static constexpr size_t short_lag = s; 158 static constexpr size_t long_lag = r; 159 static constexpr result_type min() { return 0; } 160 static constexpr result_type max() { return m-1; } 161 static constexpr result_type default_seed = 19780503u; 162 163 // constructors and seeding functions 164 explicit subtract_with_carry_engine(result_type value = default_seed); // before C++20 165 subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20 166 explicit subtract_with_carry_engine(result_type value); // C++20 167 template<class Sseq> explicit subtract_with_carry_engine(Sseq& q); 168 void seed(result_type value = default_seed); 169 template<class Sseq> void seed(Sseq& q); 170 171 // generating functions 172 result_type operator()(); 173 void discard(unsigned long long z); 174}; 175 176template<class UIntType, size_t w, size_t s, size_t r> 177bool 178operator==( 179 const subtract_with_carry_engine<UIntType, w, s, r>& x, 180 const subtract_with_carry_engine<UIntType, w, s, r>& y); 181 182template<class UIntType, size_t w, size_t s, size_t r> 183bool 184operator!=( 185 const subtract_with_carry_engine<UIntType, w, s, r>& x, 186 const subtract_with_carry_engine<UIntType, w, s, r>& y); 187 188template <class charT, class traits, 189 class UIntType, size_t w, size_t s, size_t r> 190basic_ostream<charT, traits>& 191operator<<(basic_ostream<charT, traits>& os, 192 const subtract_with_carry_engine<UIntType, w, s, r>& x); 193 194template <class charT, class traits, 195 class UIntType, size_t w, size_t s, size_t r> 196basic_istream<charT, traits>& 197operator>>(basic_istream<charT, traits>& is, 198 subtract_with_carry_engine<UIntType, w, s, r>& x); 199 200template<class Engine, size_t p, size_t r> 201class discard_block_engine 202{ 203public: 204 // types 205 typedef typename Engine::result_type result_type; 206 207 // engine characteristics 208 static constexpr size_t block_size = p; 209 static constexpr size_t used_block = r; 210 static constexpr result_type min() { return Engine::min(); } 211 static constexpr result_type max() { return Engine::max(); } 212 213 // constructors and seeding functions 214 discard_block_engine(); 215 explicit discard_block_engine(const Engine& e); 216 explicit discard_block_engine(Engine&& e); 217 explicit discard_block_engine(result_type s); 218 template<class Sseq> explicit discard_block_engine(Sseq& q); 219 void seed(); 220 void seed(result_type s); 221 template<class Sseq> void seed(Sseq& q); 222 223 // generating functions 224 result_type operator()(); 225 void discard(unsigned long long z); 226 227 // property functions 228 const Engine& base() const noexcept; 229}; 230 231template<class Engine, size_t p, size_t r> 232bool 233operator==( 234 const discard_block_engine<Engine, p, r>& x, 235 const discard_block_engine<Engine, p, r>& y); 236 237template<class Engine, size_t p, size_t r> 238bool 239operator!=( 240 const discard_block_engine<Engine, p, r>& x, 241 const discard_block_engine<Engine, p, r>& y); 242 243template <class charT, class traits, 244 class Engine, size_t p, size_t r> 245basic_ostream<charT, traits>& 246operator<<(basic_ostream<charT, traits>& os, 247 const discard_block_engine<Engine, p, r>& x); 248 249template <class charT, class traits, 250 class Engine, size_t p, size_t r> 251basic_istream<charT, traits>& 252operator>>(basic_istream<charT, traits>& is, 253 discard_block_engine<Engine, p, r>& x); 254 255template<class Engine, size_t w, class UIntType> 256class independent_bits_engine 257{ 258public: 259 // types 260 typedef UIntType result_type; 261 262 // engine characteristics 263 static constexpr result_type min() { return 0; } 264 static constexpr result_type max() { return 2^w - 1; } 265 266 // constructors and seeding functions 267 independent_bits_engine(); 268 explicit independent_bits_engine(const Engine& e); 269 explicit independent_bits_engine(Engine&& e); 270 explicit independent_bits_engine(result_type s); 271 template<class Sseq> explicit independent_bits_engine(Sseq& q); 272 void seed(); 273 void seed(result_type s); 274 template<class Sseq> void seed(Sseq& q); 275 276 // generating functions 277 result_type operator()(); void discard(unsigned long long z); 278 279 // property functions 280 const Engine& base() const noexcept; 281}; 282 283template<class Engine, size_t w, class UIntType> 284bool 285operator==( 286 const independent_bits_engine<Engine, w, UIntType>& x, 287 const independent_bits_engine<Engine, w, UIntType>& y); 288 289template<class Engine, size_t w, class UIntType> 290bool 291operator!=( 292 const independent_bits_engine<Engine, w, UIntType>& x, 293 const independent_bits_engine<Engine, w, UIntType>& y); 294 295template <class charT, class traits, 296 class Engine, size_t w, class UIntType> 297basic_ostream<charT, traits>& 298operator<<(basic_ostream<charT, traits>& os, 299 const independent_bits_engine<Engine, w, UIntType>& x); 300 301template <class charT, class traits, 302 class Engine, size_t w, class UIntType> 303basic_istream<charT, traits>& 304operator>>(basic_istream<charT, traits>& is, 305 independent_bits_engine<Engine, w, UIntType>& x); 306 307template<class Engine, size_t k> 308class shuffle_order_engine 309{ 310public: 311 // types 312 typedef typename Engine::result_type result_type; 313 314 // engine characteristics 315 static constexpr size_t table_size = k; 316 static constexpr result_type min() { return Engine::min; } 317 static constexpr result_type max() { return Engine::max; } 318 319 // constructors and seeding functions 320 shuffle_order_engine(); 321 explicit shuffle_order_engine(const Engine& e); 322 explicit shuffle_order_engine(Engine&& e); 323 explicit shuffle_order_engine(result_type s); 324 template<class Sseq> explicit shuffle_order_engine(Sseq& q); 325 void seed(); 326 void seed(result_type s); 327 template<class Sseq> void seed(Sseq& q); 328 329 // generating functions 330 result_type operator()(); 331 void discard(unsigned long long z); 332 333 // property functions 334 const Engine& base() const noexcept; 335}; 336 337template<class Engine, size_t k> 338bool 339operator==( 340 const shuffle_order_engine<Engine, k>& x, 341 const shuffle_order_engine<Engine, k>& y); 342 343template<class Engine, size_t k> 344bool 345operator!=( 346 const shuffle_order_engine<Engine, k>& x, 347 const shuffle_order_engine<Engine, k>& y); 348 349template <class charT, class traits, 350 class Engine, size_t k> 351basic_ostream<charT, traits>& 352operator<<(basic_ostream<charT, traits>& os, 353 const shuffle_order_engine<Engine, k>& x); 354 355template <class charT, class traits, 356 class Engine, size_t k> 357basic_istream<charT, traits>& 358operator>>(basic_istream<charT, traits>& is, 359 shuffle_order_engine<Engine, k>& x); 360 361typedef linear_congruential_engine<uint_fast32_t, 16807, 0, 2147483647> 362 minstd_rand0; 363typedef linear_congruential_engine<uint_fast32_t, 48271, 0, 2147483647> 364 minstd_rand; 365typedef mersenne_twister_engine<uint_fast32_t, 32, 624, 397, 31, 366 0x9908b0df, 367 11, 0xffffffff, 368 7, 0x9d2c5680, 369 15, 0xefc60000, 370 18, 1812433253> mt19937; 371typedef mersenne_twister_engine<uint_fast64_t, 64, 312, 156, 31, 372 0xb5026f5aa96619e9, 373 29, 0x5555555555555555, 374 17, 0x71d67fffeda60000, 375 37, 0xfff7eee000000000, 376 43, 6364136223846793005> mt19937_64; 377typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> ranlux24_base; 378typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> ranlux48_base; 379typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24; 380typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48; 381typedef shuffle_order_engine<minstd_rand0, 256> knuth_b; 382typedef minstd_rand default_random_engine; 383 384// Generators 385 386class random_device 387{ 388public: 389 // types 390 typedef unsigned int result_type; 391 392 // generator characteristics 393 static constexpr result_type min() { return numeric_limits<result_type>::min(); } 394 static constexpr result_type max() { return numeric_limits<result_type>::max(); } 395 396 // constructors 397 explicit random_device(const string& token = implementation-defined); // before C++20 398 random_device() : random_device(implementation-defined) {} // C++20 399 explicit random_device(const string& token); // C++20 400 401 // generating functions 402 result_type operator()(); 403 404 // property functions 405 double entropy() const noexcept; 406 407 // no copy functions 408 random_device(const random_device& ) = delete; 409 void operator=(const random_device& ) = delete; 410}; 411 412// Utilities 413 414class seed_seq 415{ 416public: 417 // types 418 typedef uint_least32_t result_type; 419 420 // constructors 421 seed_seq(); 422 template<class T> 423 seed_seq(initializer_list<T> il); 424 template<class InputIterator> 425 seed_seq(InputIterator begin, InputIterator end); 426 427 // generating functions 428 template<class RandomAccessIterator> 429 void generate(RandomAccessIterator begin, RandomAccessIterator end); 430 431 // property functions 432 size_t size() const; 433 template<class OutputIterator> 434 void param(OutputIterator dest) const; 435 436 // no copy functions 437 seed_seq(const seed_seq&) = delete; 438 void operator=(const seed_seq& ) = delete; 439}; 440 441template<class RealType, size_t bits, class URNG> 442 RealType generate_canonical(URNG& g); 443 444// Distributions 445 446template<class IntType = int> 447class uniform_int_distribution 448{ 449public: 450 // types 451 typedef IntType result_type; 452 453 class param_type 454 { 455 public: 456 typedef uniform_int_distribution distribution_type; 457 458 explicit param_type(IntType a = 0, 459 IntType b = numeric_limits<IntType>::max()); 460 461 result_type a() const; 462 result_type b() const; 463 464 friend bool operator==(const param_type& x, const param_type& y); 465 friend bool operator!=(const param_type& x, const param_type& y); 466 }; 467 468 // constructors and reset functions 469 explicit uniform_int_distribution(IntType a = 0, 470 IntType b = numeric_limits<IntType>::max()); // before C++20 471 uniform_int_distribution() : uniform_int_distribution(0) {} // C++20 472 explicit uniform_int_distribution(IntType a, 473 IntType b = numeric_limits<IntType>::max()); // C++20 474 explicit uniform_int_distribution(const param_type& parm); 475 void reset(); 476 477 // generating functions 478 template<class URNG> result_type operator()(URNG& g); 479 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 480 481 // property functions 482 result_type a() const; 483 result_type b() const; 484 485 param_type param() const; 486 void param(const param_type& parm); 487 488 result_type min() const; 489 result_type max() const; 490 491 friend bool operator==(const uniform_int_distribution& x, 492 const uniform_int_distribution& y); 493 friend bool operator!=(const uniform_int_distribution& x, 494 const uniform_int_distribution& y); 495 496 template <class charT, class traits> 497 friend 498 basic_ostream<charT, traits>& 499 operator<<(basic_ostream<charT, traits>& os, 500 const uniform_int_distribution& x); 501 502 template <class charT, class traits> 503 friend 504 basic_istream<charT, traits>& 505 operator>>(basic_istream<charT, traits>& is, 506 uniform_int_distribution& x); 507}; 508 509template<class RealType = double> 510class uniform_real_distribution 511{ 512public: 513 // types 514 typedef RealType result_type; 515 516 class param_type 517 { 518 public: 519 typedef uniform_real_distribution distribution_type; 520 521 explicit param_type(RealType a = 0, 522 RealType b = 1); 523 524 result_type a() const; 525 result_type b() const; 526 527 friend bool operator==(const param_type& x, const param_type& y); 528 friend bool operator!=(const param_type& x, const param_type& y); 529 }; 530 531 // constructors and reset functions 532 explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20 533 uniform_real_distribution() : uniform_real_distribution(0.0) {} // C++20 534 explicit uniform_real_distribution(RealType a, RealType b = 1.0); // C++20 535 explicit uniform_real_distribution(const param_type& parm); 536 void reset(); 537 538 // generating functions 539 template<class URNG> result_type operator()(URNG& g); 540 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 541 542 // property functions 543 result_type a() const; 544 result_type b() const; 545 546 param_type param() const; 547 void param(const param_type& parm); 548 549 result_type min() const; 550 result_type max() const; 551 552 friend bool operator==(const uniform_real_distribution& x, 553 const uniform_real_distribution& y); 554 friend bool operator!=(const uniform_real_distribution& x, 555 const uniform_real_distribution& y); 556 557 template <class charT, class traits> 558 friend 559 basic_ostream<charT, traits>& 560 operator<<(basic_ostream<charT, traits>& os, 561 const uniform_real_distribution& x); 562 563 template <class charT, class traits> 564 friend 565 basic_istream<charT, traits>& 566 operator>>(basic_istream<charT, traits>& is, 567 uniform_real_distribution& x); 568}; 569 570class bernoulli_distribution 571{ 572public: 573 // types 574 typedef bool result_type; 575 576 class param_type 577 { 578 public: 579 typedef bernoulli_distribution distribution_type; 580 581 explicit param_type(double p = 0.5); 582 583 double p() const; 584 585 friend bool operator==(const param_type& x, const param_type& y); 586 friend bool operator!=(const param_type& x, const param_type& y); 587 }; 588 589 // constructors and reset functions 590 explicit bernoulli_distribution(double p = 0.5); // before C++20 591 bernoulli_distribution() : bernoulli_distribution(0.5) {} // C++20 592 explicit bernoulli_distribution(double p); // C++20 593 explicit bernoulli_distribution(const param_type& parm); 594 void reset(); 595 596 // generating functions 597 template<class URNG> result_type operator()(URNG& g); 598 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 599 600 // property functions 601 double p() const; 602 603 param_type param() const; 604 void param(const param_type& parm); 605 606 result_type min() const; 607 result_type max() const; 608 609 friend bool operator==(const bernoulli_distribution& x, 610 const bernoulli_distribution& y); 611 friend bool operator!=(const bernoulli_distribution& x, 612 const bernoulli_distribution& y); 613 614 template <class charT, class traits> 615 friend 616 basic_ostream<charT, traits>& 617 operator<<(basic_ostream<charT, traits>& os, 618 const bernoulli_distribution& x); 619 620 template <class charT, class traits> 621 friend 622 basic_istream<charT, traits>& 623 operator>>(basic_istream<charT, traits>& is, 624 bernoulli_distribution& x); 625}; 626 627template<class IntType = int> 628class binomial_distribution 629{ 630public: 631 // types 632 typedef IntType result_type; 633 634 class param_type 635 { 636 public: 637 typedef binomial_distribution distribution_type; 638 639 explicit param_type(IntType t = 1, double p = 0.5); 640 641 IntType t() const; 642 double p() const; 643 644 friend bool operator==(const param_type& x, const param_type& y); 645 friend bool operator!=(const param_type& x, const param_type& y); 646 }; 647 648 // constructors and reset functions 649 explicit binomial_distribution(IntType t = 1, double p = 0.5); // before C++20 650 binomial_distribution() : binomial_distribution(1) {} // C++20 651 explicit binomial_distribution(IntType t, double p = 0.5); // C++20 652 explicit binomial_distribution(const param_type& parm); 653 void reset(); 654 655 // generating functions 656 template<class URNG> result_type operator()(URNG& g); 657 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 658 659 // property functions 660 IntType t() const; 661 double p() const; 662 663 param_type param() const; 664 void param(const param_type& parm); 665 666 result_type min() const; 667 result_type max() const; 668 669 friend bool operator==(const binomial_distribution& x, 670 const binomial_distribution& y); 671 friend bool operator!=(const binomial_distribution& x, 672 const binomial_distribution& y); 673 674 template <class charT, class traits> 675 friend 676 basic_ostream<charT, traits>& 677 operator<<(basic_ostream<charT, traits>& os, 678 const binomial_distribution& x); 679 680 template <class charT, class traits> 681 friend 682 basic_istream<charT, traits>& 683 operator>>(basic_istream<charT, traits>& is, 684 binomial_distribution& x); 685}; 686 687template<class IntType = int> 688class geometric_distribution 689{ 690public: 691 // types 692 typedef IntType result_type; 693 694 class param_type 695 { 696 public: 697 typedef geometric_distribution distribution_type; 698 699 explicit param_type(double p = 0.5); 700 701 double p() const; 702 703 friend bool operator==(const param_type& x, const param_type& y); 704 friend bool operator!=(const param_type& x, const param_type& y); 705 }; 706 707 // constructors and reset functions 708 explicit geometric_distribution(double p = 0.5); // before C++20 709 geometric_distribution() : geometric_distribution(0.5) {} // C++20 710 explicit geometric_distribution(double p); // C++20 711 explicit geometric_distribution(const param_type& parm); 712 void reset(); 713 714 // generating functions 715 template<class URNG> result_type operator()(URNG& g); 716 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 717 718 // property functions 719 double p() const; 720 721 param_type param() const; 722 void param(const param_type& parm); 723 724 result_type min() const; 725 result_type max() const; 726 727 friend bool operator==(const geometric_distribution& x, 728 const geometric_distribution& y); 729 friend bool operator!=(const geometric_distribution& x, 730 const geometric_distribution& y); 731 732 template <class charT, class traits> 733 friend 734 basic_ostream<charT, traits>& 735 operator<<(basic_ostream<charT, traits>& os, 736 const geometric_distribution& x); 737 738 template <class charT, class traits> 739 friend 740 basic_istream<charT, traits>& 741 operator>>(basic_istream<charT, traits>& is, 742 geometric_distribution& x); 743}; 744 745template<class IntType = int> 746class negative_binomial_distribution 747{ 748public: 749 // types 750 typedef IntType result_type; 751 752 class param_type 753 { 754 public: 755 typedef negative_binomial_distribution distribution_type; 756 757 explicit param_type(result_type k = 1, double p = 0.5); 758 759 result_type k() const; 760 double p() const; 761 762 friend bool operator==(const param_type& x, const param_type& y); 763 friend bool operator!=(const param_type& x, const param_type& y); 764 }; 765 766 // constructor and reset functions 767 explicit negative_binomial_distribution(IntType k = 1, double p = 0.5); // before C++20 768 negative_binomial_distribution() : negative_binomial_distribution(1) {} // C++20 769 explicit negative_binomial_distribution(IntType k, double p = 0.5); // C++20 770 explicit negative_binomial_distribution(const param_type& parm); 771 void reset(); 772 773 // generating functions 774 template<class URNG> result_type operator()(URNG& g); 775 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 776 777 // property functions 778 result_type k() const; 779 double p() const; 780 781 param_type param() const; 782 void param(const param_type& parm); 783 784 result_type min() const; 785 result_type max() const; 786 787 friend bool operator==(const negative_binomial_distribution& x, 788 const negative_binomial_distribution& y); 789 friend bool operator!=(const negative_binomial_distribution& x, 790 const negative_binomial_distribution& y); 791 792 template <class charT, class traits> 793 friend 794 basic_ostream<charT, traits>& 795 operator<<(basic_ostream<charT, traits>& os, 796 const negative_binomial_distribution& x); 797 798 template <class charT, class traits> 799 friend 800 basic_istream<charT, traits>& 801 operator>>(basic_istream<charT, traits>& is, 802 negative_binomial_distribution& x); 803}; 804 805template<class IntType = int> 806class poisson_distribution 807{ 808public: 809 // types 810 typedef IntType result_type; 811 812 class param_type 813 { 814 public: 815 typedef poisson_distribution distribution_type; 816 817 explicit param_type(double mean = 1.0); 818 819 double mean() const; 820 821 friend bool operator==(const param_type& x, const param_type& y); 822 friend bool operator!=(const param_type& x, const param_type& y); 823 }; 824 825 // constructors and reset functions 826 explicit poisson_distribution(double mean = 1.0); // before C++20 827 poisson_distribution() : poisson_distribution(1.0) {} // C++20 828 explicit poisson_distribution(double mean); // C++20 829 explicit poisson_distribution(const param_type& parm); 830 void reset(); 831 832 // generating functions 833 template<class URNG> result_type operator()(URNG& g); 834 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 835 836 // property functions 837 double mean() const; 838 839 param_type param() const; 840 void param(const param_type& parm); 841 842 result_type min() const; 843 result_type max() const; 844 845 friend bool operator==(const poisson_distribution& x, 846 const poisson_distribution& y); 847 friend bool operator!=(const poisson_distribution& x, 848 const poisson_distribution& y); 849 850 template <class charT, class traits> 851 friend 852 basic_ostream<charT, traits>& 853 operator<<(basic_ostream<charT, traits>& os, 854 const poisson_distribution& x); 855 856 template <class charT, class traits> 857 friend 858 basic_istream<charT, traits>& 859 operator>>(basic_istream<charT, traits>& is, 860 poisson_distribution& x); 861}; 862 863template<class RealType = double> 864class exponential_distribution 865{ 866public: 867 // types 868 typedef RealType result_type; 869 870 class param_type 871 { 872 public: 873 typedef exponential_distribution distribution_type; 874 875 explicit param_type(result_type lambda = 1.0); 876 877 result_type lambda() const; 878 879 friend bool operator==(const param_type& x, const param_type& y); 880 friend bool operator!=(const param_type& x, const param_type& y); 881 }; 882 883 // constructors and reset functions 884 explicit exponential_distribution(RealType lambda = 1.0); // before C++20 885 exponential_distribution() : exponential_distribution(1.0) {} // C++20 886 explicit exponential_distribution(RealType lambda); // C++20 887 explicit exponential_distribution(const param_type& parm); 888 void reset(); 889 890 // generating functions 891 template<class URNG> result_type operator()(URNG& g); 892 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 893 894 // property functions 895 result_type lambda() const; 896 897 param_type param() const; 898 void param(const param_type& parm); 899 900 result_type min() const; 901 result_type max() const; 902 903 friend bool operator==(const exponential_distribution& x, 904 const exponential_distribution& y); 905 friend bool operator!=(const exponential_distribution& x, 906 const exponential_distribution& y); 907 908 template <class charT, class traits> 909 friend 910 basic_ostream<charT, traits>& 911 operator<<(basic_ostream<charT, traits>& os, 912 const exponential_distribution& x); 913 914 template <class charT, class traits> 915 friend 916 basic_istream<charT, traits>& 917 operator>>(basic_istream<charT, traits>& is, 918 exponential_distribution& x); 919}; 920 921template<class RealType = double> 922class gamma_distribution 923{ 924public: 925 // types 926 typedef RealType result_type; 927 928 class param_type 929 { 930 public: 931 typedef gamma_distribution distribution_type; 932 933 explicit param_type(result_type alpha = 1, result_type beta = 1); 934 935 result_type alpha() const; 936 result_type beta() const; 937 938 friend bool operator==(const param_type& x, const param_type& y); 939 friend bool operator!=(const param_type& x, const param_type& y); 940 }; 941 942 // constructors and reset functions 943 explicit gamma_distribution(RealType alpha = 0.0, RealType beta = 1.0); // before C++20 944 gamma_distribution() : gamma_distribution(0.0) {} // C++20 945 explicit gamma_distribution(RealType alpha, RealType beta = 1.0); // C++20 946 explicit gamma_distribution(const param_type& parm); 947 void reset(); 948 949 // generating functions 950 template<class URNG> result_type operator()(URNG& g); 951 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 952 953 // property functions 954 result_type alpha() const; 955 result_type beta() const; 956 957 param_type param() const; 958 void param(const param_type& parm); 959 960 result_type min() const; 961 result_type max() const; 962 963 friend bool operator==(const gamma_distribution& x, 964 const gamma_distribution& y); 965 friend bool operator!=(const gamma_distribution& x, 966 const gamma_distribution& y); 967 968 template <class charT, class traits> 969 friend 970 basic_ostream<charT, traits>& 971 operator<<(basic_ostream<charT, traits>& os, 972 const gamma_distribution& x); 973 974 template <class charT, class traits> 975 friend 976 basic_istream<charT, traits>& 977 operator>>(basic_istream<charT, traits>& is, 978 gamma_distribution& x); 979}; 980 981template<class RealType = double> 982class weibull_distribution 983{ 984public: 985 // types 986 typedef RealType result_type; 987 988 class param_type 989 { 990 public: 991 typedef weibull_distribution distribution_type; 992 993 explicit param_type(result_type alpha = 1, result_type beta = 1); 994 995 result_type a() const; 996 result_type b() const; 997 998 friend bool operator==(const param_type& x, const param_type& y); 999 friend bool operator!=(const param_type& x, const param_type& y); 1000 }; 1001 1002 // constructor and reset functions 1003 explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0); // before C++20 1004 weibull_distribution() : weibull_distribution(1.0) {} // C++20 1005 explicit weibull_distribution(RealType a, RealType b = 1.0); // C++20 1006 explicit weibull_distribution(const param_type& parm); 1007 void reset(); 1008 1009 // generating functions 1010 template<class URNG> result_type operator()(URNG& g); 1011 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1012 1013 // property functions 1014 result_type a() const; 1015 result_type b() const; 1016 1017 param_type param() const; 1018 void param(const param_type& parm); 1019 1020 result_type min() const; 1021 result_type max() const; 1022 1023 friend bool operator==(const weibull_distribution& x, 1024 const weibull_distribution& y); 1025 friend bool operator!=(const weibull_distribution& x, 1026 const weibull_distribution& y); 1027 1028 template <class charT, class traits> 1029 friend 1030 basic_ostream<charT, traits>& 1031 operator<<(basic_ostream<charT, traits>& os, 1032 const weibull_distribution& x); 1033 1034 template <class charT, class traits> 1035 friend 1036 basic_istream<charT, traits>& 1037 operator>>(basic_istream<charT, traits>& is, 1038 weibull_distribution& x); 1039}; 1040 1041template<class RealType = double> 1042class extreme_value_distribution 1043{ 1044public: 1045 // types 1046 typedef RealType result_type; 1047 1048 class param_type 1049 { 1050 public: 1051 typedef extreme_value_distribution distribution_type; 1052 1053 explicit param_type(result_type a = 0, result_type b = 1); 1054 1055 result_type a() const; 1056 result_type b() const; 1057 1058 friend bool operator==(const param_type& x, const param_type& y); 1059 friend bool operator!=(const param_type& x, const param_type& y); 1060 }; 1061 1062 // constructor and reset functions 1063 explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20 1064 extreme_value_distribution() : extreme_value_distribution(0.0) {} // C++20 1065 explicit extreme_value_distribution(RealType a, RealType b = 1.0); // C++20 1066 explicit extreme_value_distribution(const param_type& parm); 1067 void reset(); 1068 1069 // generating functions 1070 template<class URNG> result_type operator()(URNG& g); 1071 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1072 1073 // property functions 1074 result_type a() const; 1075 result_type b() const; 1076 1077 param_type param() const; 1078 void param(const param_type& parm); 1079 1080 result_type min() const; 1081 result_type max() const; 1082 1083 friend bool operator==(const extreme_value_distribution& x, 1084 const extreme_value_distribution& y); 1085 friend bool operator!=(const extreme_value_distribution& x, 1086 const extreme_value_distribution& y); 1087 1088 template <class charT, class traits> 1089 friend 1090 basic_ostream<charT, traits>& 1091 operator<<(basic_ostream<charT, traits>& os, 1092 const extreme_value_distribution& x); 1093 1094 template <class charT, class traits> 1095 friend 1096 basic_istream<charT, traits>& 1097 operator>>(basic_istream<charT, traits>& is, 1098 extreme_value_distribution& x); 1099}; 1100 1101template<class RealType = double> 1102class normal_distribution 1103{ 1104public: 1105 // types 1106 typedef RealType result_type; 1107 1108 class param_type 1109 { 1110 public: 1111 typedef normal_distribution distribution_type; 1112 1113 explicit param_type(result_type mean = 0, result_type stddev = 1); 1114 1115 result_type mean() const; 1116 result_type stddev() const; 1117 1118 friend bool operator==(const param_type& x, const param_type& y); 1119 friend bool operator!=(const param_type& x, const param_type& y); 1120 }; 1121 1122 // constructors and reset functions 1123 explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20 1124 normal_distribution() : normal_distribution(0.0) {} // C++20 1125 explicit normal_distribution(RealType mean, RealType stddev = 1.0); // C++20 1126 explicit normal_distribution(const param_type& parm); 1127 void reset(); 1128 1129 // generating functions 1130 template<class URNG> result_type operator()(URNG& g); 1131 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1132 1133 // property functions 1134 result_type mean() const; 1135 result_type stddev() const; 1136 1137 param_type param() const; 1138 void param(const param_type& parm); 1139 1140 result_type min() const; 1141 result_type max() const; 1142 1143 friend bool operator==(const normal_distribution& x, 1144 const normal_distribution& y); 1145 friend bool operator!=(const normal_distribution& x, 1146 const normal_distribution& y); 1147 1148 template <class charT, class traits> 1149 friend 1150 basic_ostream<charT, traits>& 1151 operator<<(basic_ostream<charT, traits>& os, 1152 const normal_distribution& x); 1153 1154 template <class charT, class traits> 1155 friend 1156 basic_istream<charT, traits>& 1157 operator>>(basic_istream<charT, traits>& is, 1158 normal_distribution& x); 1159}; 1160 1161template<class RealType = double> 1162class lognormal_distribution 1163{ 1164public: 1165 // types 1166 typedef RealType result_type; 1167 1168 class param_type 1169 { 1170 public: 1171 typedef lognormal_distribution distribution_type; 1172 1173 explicit param_type(result_type m = 0, result_type s = 1); 1174 1175 result_type m() const; 1176 result_type s() const; 1177 1178 friend bool operator==(const param_type& x, const param_type& y); 1179 friend bool operator!=(const param_type& x, const param_type& y); 1180 }; 1181 1182 // constructor and reset functions 1183 explicit lognormal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++20 1184 lognormal_distribution() : lognormal_distribution(0.0) {} // C++20 1185 explicit lognormal_distribution(RealType mean, RealType stddev = 1.0); // C++20 1186 explicit lognormal_distribution(const param_type& parm); 1187 void reset(); 1188 1189 // generating functions 1190 template<class URNG> result_type operator()(URNG& g); 1191 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1192 1193 // property functions 1194 result_type m() const; 1195 result_type s() const; 1196 1197 param_type param() const; 1198 void param(const param_type& parm); 1199 1200 result_type min() const; 1201 result_type max() const; 1202 1203 friend bool operator==(const lognormal_distribution& x, 1204 const lognormal_distribution& y); 1205 friend bool operator!=(const lognormal_distribution& x, 1206 const lognormal_distribution& y); 1207 1208 template <class charT, class traits> 1209 friend 1210 basic_ostream<charT, traits>& 1211 operator<<(basic_ostream<charT, traits>& os, 1212 const lognormal_distribution& x); 1213 1214 template <class charT, class traits> 1215 friend 1216 basic_istream<charT, traits>& 1217 operator>>(basic_istream<charT, traits>& is, 1218 lognormal_distribution& x); 1219}; 1220 1221template<class RealType = double> 1222class chi_squared_distribution 1223{ 1224public: 1225 // types 1226 typedef RealType result_type; 1227 1228 class param_type 1229 { 1230 public: 1231 typedef chi_squared_distribution distribution_type; 1232 1233 explicit param_type(result_type n = 1); 1234 1235 result_type n() const; 1236 1237 friend bool operator==(const param_type& x, const param_type& y); 1238 friend bool operator!=(const param_type& x, const param_type& y); 1239 }; 1240 1241 // constructor and reset functions 1242 explicit chi_squared_distribution(RealType n = 1.0); // before C++20 1243 chi_squared_distribution() : chi_squared_distribution(1.0) {} // C++20 1244 explicit chi_squared_distribution(RealType n); // C++20 1245 explicit chi_squared_distribution(const param_type& parm); 1246 void reset(); 1247 1248 // generating functions 1249 template<class URNG> result_type operator()(URNG& g); 1250 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1251 1252 // property functions 1253 result_type n() const; 1254 1255 param_type param() const; 1256 void param(const param_type& parm); 1257 1258 result_type min() const; 1259 result_type max() const; 1260 1261 friend bool operator==(const chi_squared_distribution& x, 1262 const chi_squared_distribution& y); 1263 friend bool operator!=(const chi_squared_distribution& x, 1264 const chi_squared_distribution& y); 1265 1266 template <class charT, class traits> 1267 friend 1268 basic_ostream<charT, traits>& 1269 operator<<(basic_ostream<charT, traits>& os, 1270 const chi_squared_distribution& x); 1271 1272 template <class charT, class traits> 1273 friend 1274 basic_istream<charT, traits>& 1275 operator>>(basic_istream<charT, traits>& is, 1276 chi_squared_distribution& x); 1277}; 1278 1279template<class RealType = double> 1280class cauchy_distribution 1281{ 1282public: 1283 // types 1284 typedef RealType result_type; 1285 1286 class param_type 1287 { 1288 public: 1289 typedef cauchy_distribution distribution_type; 1290 1291 explicit param_type(result_type a = 0, result_type b = 1); 1292 1293 result_type a() const; 1294 result_type b() const; 1295 1296 friend bool operator==(const param_type& x, const param_type& y); 1297 friend bool operator!=(const param_type& x, const param_type& y); 1298 }; 1299 1300 // constructor and reset functions 1301 explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20 1302 cauchy_distribution() : cauchy_distribution(0.0) {} // C++20 1303 explicit cauchy_distribution(RealType a, RealType b = 1.0); // C++20 1304 explicit cauchy_distribution(const param_type& parm); 1305 void reset(); 1306 1307 // generating functions 1308 template<class URNG> result_type operator()(URNG& g); 1309 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1310 1311 // property functions 1312 result_type a() const; 1313 result_type b() const; 1314 1315 param_type param() const; 1316 void param(const param_type& parm); 1317 1318 result_type min() const; 1319 result_type max() const; 1320 1321 friend bool operator==(const cauchy_distribution& x, 1322 const cauchy_distribution& y); 1323 friend bool operator!=(const cauchy_distribution& x, 1324 const cauchy_distribution& y); 1325 1326 template <class charT, class traits> 1327 friend 1328 basic_ostream<charT, traits>& 1329 operator<<(basic_ostream<charT, traits>& os, 1330 const cauchy_distribution& x); 1331 1332 template <class charT, class traits> 1333 friend 1334 basic_istream<charT, traits>& 1335 operator>>(basic_istream<charT, traits>& is, 1336 cauchy_distribution& x); 1337}; 1338 1339template<class RealType = double> 1340class fisher_f_distribution 1341{ 1342public: 1343 // types 1344 typedef RealType result_type; 1345 1346 class param_type 1347 { 1348 public: 1349 typedef fisher_f_distribution distribution_type; 1350 1351 explicit param_type(result_type m = 1, result_type n = 1); 1352 1353 result_type m() const; 1354 result_type n() const; 1355 1356 friend bool operator==(const param_type& x, const param_type& y); 1357 friend bool operator!=(const param_type& x, const param_type& y); 1358 }; 1359 1360 // constructor and reset functions 1361 explicit fisher_f_distribution(RealType m = 1.0, RealType n = 1.0); // before C++20 1362 fisher_f_distribution() : fisher_f_distribution(1.0) {} // C++20 1363 explicit fisher_f_distribution(RealType m, RealType n = 1.0); // C++20 1364 explicit fisher_f_distribution(const param_type& parm); 1365 void reset(); 1366 1367 // generating functions 1368 template<class URNG> result_type operator()(URNG& g); 1369 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1370 1371 // property functions 1372 result_type m() const; 1373 result_type n() const; 1374 1375 param_type param() const; 1376 void param(const param_type& parm); 1377 1378 result_type min() const; 1379 result_type max() const; 1380 1381 friend bool operator==(const fisher_f_distribution& x, 1382 const fisher_f_distribution& y); 1383 friend bool operator!=(const fisher_f_distribution& x, 1384 const fisher_f_distribution& y); 1385 1386 template <class charT, class traits> 1387 friend 1388 basic_ostream<charT, traits>& 1389 operator<<(basic_ostream<charT, traits>& os, 1390 const fisher_f_distribution& x); 1391 1392 template <class charT, class traits> 1393 friend 1394 basic_istream<charT, traits>& 1395 operator>>(basic_istream<charT, traits>& is, 1396 fisher_f_distribution& x); 1397}; 1398 1399template<class RealType = double> 1400class student_t_distribution 1401{ 1402public: 1403 // types 1404 typedef RealType result_type; 1405 1406 class param_type 1407 { 1408 public: 1409 typedef student_t_distribution distribution_type; 1410 1411 explicit param_type(result_type n = 1); 1412 1413 result_type n() const; 1414 1415 friend bool operator==(const param_type& x, const param_type& y); 1416 friend bool operator!=(const param_type& x, const param_type& y); 1417 }; 1418 1419 // constructor and reset functions 1420 explicit student_t_distribution(RealType n = 1.0); // before C++20 1421 student_t_distribution() : student_t_distribution(1.0) {} // C++20 1422 explicit student_t_distribution(RealType n); // C++20 1423 explicit student_t_distribution(const param_type& parm); 1424 void reset(); 1425 1426 // generating functions 1427 template<class URNG> result_type operator()(URNG& g); 1428 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1429 1430 // property functions 1431 result_type n() const; 1432 1433 param_type param() const; 1434 void param(const param_type& parm); 1435 1436 result_type min() const; 1437 result_type max() const; 1438 1439 friend bool operator==(const student_t_distribution& x, 1440 const student_t_distribution& y); 1441 friend bool operator!=(const student_t_distribution& x, 1442 const student_t_distribution& y); 1443 1444 template <class charT, class traits> 1445 friend 1446 basic_ostream<charT, traits>& 1447 operator<<(basic_ostream<charT, traits>& os, 1448 const student_t_distribution& x); 1449 1450 template <class charT, class traits> 1451 friend 1452 basic_istream<charT, traits>& 1453 operator>>(basic_istream<charT, traits>& is, 1454 student_t_distribution& x); 1455}; 1456 1457template<class IntType = int> 1458class discrete_distribution 1459{ 1460public: 1461 // types 1462 typedef IntType result_type; 1463 1464 class param_type 1465 { 1466 public: 1467 typedef discrete_distribution distribution_type; 1468 1469 param_type(); 1470 template<class InputIterator> 1471 param_type(InputIterator firstW, InputIterator lastW); 1472 param_type(initializer_list<double> wl); 1473 template<class UnaryOperation> 1474 param_type(size_t nw, double xmin, double xmax, UnaryOperation fw); 1475 1476 vector<double> probabilities() const; 1477 1478 friend bool operator==(const param_type& x, const param_type& y); 1479 friend bool operator!=(const param_type& x, const param_type& y); 1480 }; 1481 1482 // constructor and reset functions 1483 discrete_distribution(); 1484 template<class InputIterator> 1485 discrete_distribution(InputIterator firstW, InputIterator lastW); 1486 discrete_distribution(initializer_list<double> wl); 1487 template<class UnaryOperation> 1488 discrete_distribution(size_t nw, double xmin, double xmax, 1489 UnaryOperation fw); 1490 explicit discrete_distribution(const param_type& parm); 1491 void reset(); 1492 1493 // generating functions 1494 template<class URNG> result_type operator()(URNG& g); 1495 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1496 1497 // property functions 1498 vector<double> probabilities() const; 1499 1500 param_type param() const; 1501 void param(const param_type& parm); 1502 1503 result_type min() const; 1504 result_type max() const; 1505 1506 friend bool operator==(const discrete_distribution& x, 1507 const discrete_distribution& y); 1508 friend bool operator!=(const discrete_distribution& x, 1509 const discrete_distribution& y); 1510 1511 template <class charT, class traits> 1512 friend 1513 basic_ostream<charT, traits>& 1514 operator<<(basic_ostream<charT, traits>& os, 1515 const discrete_distribution& x); 1516 1517 template <class charT, class traits> 1518 friend 1519 basic_istream<charT, traits>& 1520 operator>>(basic_istream<charT, traits>& is, 1521 discrete_distribution& x); 1522}; 1523 1524template<class RealType = double> 1525class piecewise_constant_distribution 1526{ 1527 // types 1528 typedef RealType result_type; 1529 1530 class param_type 1531 { 1532 public: 1533 typedef piecewise_constant_distribution distribution_type; 1534 1535 param_type(); 1536 template<class InputIteratorB, class InputIteratorW> 1537 param_type(InputIteratorB firstB, InputIteratorB lastB, 1538 InputIteratorW firstW); 1539 template<class UnaryOperation> 1540 param_type(initializer_list<result_type> bl, UnaryOperation fw); 1541 template<class UnaryOperation> 1542 param_type(size_t nw, result_type xmin, result_type xmax, 1543 UnaryOperation fw); 1544 1545 vector<result_type> intervals() const; 1546 vector<result_type> densities() const; 1547 1548 friend bool operator==(const param_type& x, const param_type& y); 1549 friend bool operator!=(const param_type& x, const param_type& y); 1550 }; 1551 1552 // constructor and reset functions 1553 piecewise_constant_distribution(); 1554 template<class InputIteratorB, class InputIteratorW> 1555 piecewise_constant_distribution(InputIteratorB firstB, 1556 InputIteratorB lastB, 1557 InputIteratorW firstW); 1558 template<class UnaryOperation> 1559 piecewise_constant_distribution(initializer_list<result_type> bl, 1560 UnaryOperation fw); 1561 template<class UnaryOperation> 1562 piecewise_constant_distribution(size_t nw, result_type xmin, 1563 result_type xmax, UnaryOperation fw); 1564 explicit piecewise_constant_distribution(const param_type& parm); 1565 void reset(); 1566 1567 // generating functions 1568 template<class URNG> result_type operator()(URNG& g); 1569 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1570 1571 // property functions 1572 vector<result_type> intervals() const; 1573 vector<result_type> densities() const; 1574 1575 param_type param() const; 1576 void param(const param_type& parm); 1577 1578 result_type min() const; 1579 result_type max() const; 1580 1581 friend bool operator==(const piecewise_constant_distribution& x, 1582 const piecewise_constant_distribution& y); 1583 friend bool operator!=(const piecewise_constant_distribution& x, 1584 const piecewise_constant_distribution& y); 1585 1586 template <class charT, class traits> 1587 friend 1588 basic_ostream<charT, traits>& 1589 operator<<(basic_ostream<charT, traits>& os, 1590 const piecewise_constant_distribution& x); 1591 1592 template <class charT, class traits> 1593 friend 1594 basic_istream<charT, traits>& 1595 operator>>(basic_istream<charT, traits>& is, 1596 piecewise_constant_distribution& x); 1597}; 1598 1599template<class RealType = double> 1600class piecewise_linear_distribution 1601{ 1602 // types 1603 typedef RealType result_type; 1604 1605 class param_type 1606 { 1607 public: 1608 typedef piecewise_linear_distribution distribution_type; 1609 1610 param_type(); 1611 template<class InputIteratorB, class InputIteratorW> 1612 param_type(InputIteratorB firstB, InputIteratorB lastB, 1613 InputIteratorW firstW); 1614 template<class UnaryOperation> 1615 param_type(initializer_list<result_type> bl, UnaryOperation fw); 1616 template<class UnaryOperation> 1617 param_type(size_t nw, result_type xmin, result_type xmax, 1618 UnaryOperation fw); 1619 1620 vector<result_type> intervals() const; 1621 vector<result_type> densities() const; 1622 1623 friend bool operator==(const param_type& x, const param_type& y); 1624 friend bool operator!=(const param_type& x, const param_type& y); 1625 }; 1626 1627 // constructor and reset functions 1628 piecewise_linear_distribution(); 1629 template<class InputIteratorB, class InputIteratorW> 1630 piecewise_linear_distribution(InputIteratorB firstB, 1631 InputIteratorB lastB, 1632 InputIteratorW firstW); 1633 1634 template<class UnaryOperation> 1635 piecewise_linear_distribution(initializer_list<result_type> bl, 1636 UnaryOperation fw); 1637 1638 template<class UnaryOperation> 1639 piecewise_linear_distribution(size_t nw, result_type xmin, 1640 result_type xmax, UnaryOperation fw); 1641 1642 explicit piecewise_linear_distribution(const param_type& parm); 1643 void reset(); 1644 1645 // generating functions 1646 template<class URNG> result_type operator()(URNG& g); 1647 template<class URNG> result_type operator()(URNG& g, const param_type& parm); 1648 1649 // property functions 1650 vector<result_type> intervals() const; 1651 vector<result_type> densities() const; 1652 1653 param_type param() const; 1654 void param(const param_type& parm); 1655 1656 result_type min() const; 1657 result_type max() const; 1658 1659 friend bool operator==(const piecewise_linear_distribution& x, 1660 const piecewise_linear_distribution& y); 1661 friend bool operator!=(const piecewise_linear_distribution& x, 1662 const piecewise_linear_distribution& y); 1663 1664 template <class charT, class traits> 1665 friend 1666 basic_ostream<charT, traits>& 1667 operator<<(basic_ostream<charT, traits>& os, 1668 const piecewise_linear_distribution& x); 1669 1670 template <class charT, class traits> 1671 friend 1672 basic_istream<charT, traits>& 1673 operator>>(basic_istream<charT, traits>& is, 1674 piecewise_linear_distribution& x); 1675}; 1676 1677} // std 1678*/ 1679 1680#include <__assert> // all public C++ headers provide the assertion handler 1681#include <__config> 1682#include <__random/bernoulli_distribution.h> 1683#include <__random/binomial_distribution.h> 1684#include <__random/cauchy_distribution.h> 1685#include <__random/chi_squared_distribution.h> 1686#include <__random/clamp_to_integral.h> 1687#include <__random/default_random_engine.h> 1688#include <__random/discard_block_engine.h> 1689#include <__random/discrete_distribution.h> 1690#include <__random/exponential_distribution.h> 1691#include <__random/extreme_value_distribution.h> 1692#include <__random/fisher_f_distribution.h> 1693#include <__random/gamma_distribution.h> 1694#include <__random/generate_canonical.h> 1695#include <__random/geometric_distribution.h> 1696#include <__random/independent_bits_engine.h> 1697#include <__random/is_seed_sequence.h> 1698#include <__random/is_valid.h> 1699#include <__random/knuth_b.h> 1700#include <__random/linear_congruential_engine.h> 1701#include <__random/log2.h> 1702#include <__random/lognormal_distribution.h> 1703#include <__random/mersenne_twister_engine.h> 1704#include <__random/negative_binomial_distribution.h> 1705#include <__random/normal_distribution.h> 1706#include <__random/piecewise_constant_distribution.h> 1707#include <__random/piecewise_linear_distribution.h> 1708#include <__random/poisson_distribution.h> 1709#include <__random/random_device.h> 1710#include <__random/ranlux.h> 1711#include <__random/seed_seq.h> 1712#include <__random/shuffle_order_engine.h> 1713#include <__random/student_t_distribution.h> 1714#include <__random/subtract_with_carry_engine.h> 1715#include <__random/uniform_int_distribution.h> 1716#include <__random/uniform_random_bit_generator.h> 1717#include <__random/uniform_real_distribution.h> 1718#include <__random/weibull_distribution.h> 1719#include <version> 1720 1721// standard-mandated includes 1722 1723// [rand.synopsis] 1724#include <initializer_list> 1725 1726#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) 1727# pragma GCC system_header 1728#endif 1729 1730#if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20 1731# include <algorithm> 1732# include <climits> 1733# include <cmath> 1734# include <concepts> 1735# include <cstddef> 1736# include <cstdint> 1737# include <cstdlib> 1738# include <iosfwd> 1739# include <limits> 1740# include <numeric> 1741# include <string> 1742# include <type_traits> 1743# include <vector> 1744#endif 1745 1746#endif // _LIBCPP_RANDOM 1747