1747 lines · plain
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-exception7//8//===----------------------------------------------------------------------===//9 10#ifndef _LIBCPP_RANDOM11#define _LIBCPP_RANDOM12 13/*14 random synopsis15 16#include <initializer_list>17 18namespace std19{20// [rand.req.urng], uniform random bit generator requirements21template<class G>22concept uniform_random_bit_generator = see below; // C++2023 24// Engines25 26template <class UIntType, UIntType a, UIntType c, UIntType m>27class linear_congruential_engine28{29public:30 // types31 typedef UIntType result_type;32 33 // engine characteristics34 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 functions42 explicit linear_congruential_engine(result_type s = default_seed); // before C++2043 linear_congruential_engine() : linear_congruential_engine(default_seed) {} // C++2044 explicit linear_congruential_engine(result_type s); // C++2045 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 functions50 result_type operator()();51 void discard(unsigned long long z);52};53 54template <class UIntType, UIntType a, UIntType c, UIntType m>55bool56operator==(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>60bool61operator!=(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_engine80{81public:82 // types83 typedef UIntType result_type;84 85 // engine characteristics86 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 functions104 explicit mersenne_twister_engine(result_type s = default_seed); // before C++20105 mersenne_twister_engine() : mersenne_twister_engine(default_seed) {} // C++20106 explicit mersenne_twister_engine(result_type s); // C++20107 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 functions112 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>119bool120operator==(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>127bool128operator!=(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_engine150{151public:152 // types153 typedef UIntType result_type;154 155 // engine characteristics156 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 functions164 explicit subtract_with_carry_engine(result_type value = default_seed); // before C++20165 subtract_with_carry_engine() : subtract_with_carry_engine(default_seed) {} // C++20166 explicit subtract_with_carry_engine(result_type value); // C++20167 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 functions172 result_type operator()();173 void discard(unsigned long long z);174};175 176template<class UIntType, size_t w, size_t s, size_t r>177bool178operator==(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>183bool184operator!=(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_engine202{203public:204 // types205 typedef typename Engine::result_type result_type;206 207 // engine characteristics208 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 functions214 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 functions224 result_type operator()();225 void discard(unsigned long long z);226 227 // property functions228 const Engine& base() const noexcept;229};230 231template<class Engine, size_t p, size_t r>232bool233operator==(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>238bool239operator!=(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_engine257{258public:259 // types260 typedef UIntType result_type;261 262 // engine characteristics263 static constexpr result_type min() { return 0; }264 static constexpr result_type max() { return 2^w - 1; }265 266 // constructors and seeding functions267 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 functions277 result_type operator()(); void discard(unsigned long long z);278 279 // property functions280 const Engine& base() const noexcept;281};282 283template<class Engine, size_t w, class UIntType>284bool285operator==(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>290bool291operator!=(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_engine309{310public:311 // types312 typedef typename Engine::result_type result_type;313 314 // engine characteristics315 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 functions320 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 functions330 result_type operator()();331 void discard(unsigned long long z);332 333 // property functions334 const Engine& base() const noexcept;335};336 337template<class Engine, size_t k>338bool339operator==(340 const shuffle_order_engine<Engine, k>& x,341 const shuffle_order_engine<Engine, k>& y);342 343template<class Engine, size_t k>344bool345operator!=(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// Generators385 386class random_device387{388public:389 // types390 typedef unsigned int result_type;391 392 // generator characteristics393 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 // constructors397 explicit random_device(const string& token = implementation-defined); // before C++20398 random_device() : random_device(implementation-defined) {} // C++20399 explicit random_device(const string& token); // C++20400 401 // generating functions402 result_type operator()();403 404 // property functions405 double entropy() const noexcept;406 407 // no copy functions408 random_device(const random_device& ) = delete;409 void operator=(const random_device& ) = delete;410};411 412// Utilities413 414class seed_seq415{416public:417 // types418 typedef uint_least32_t result_type;419 420 // constructors421 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 functions428 template<class RandomAccessIterator>429 void generate(RandomAccessIterator begin, RandomAccessIterator end);430 431 // property functions432 size_t size() const;433 template<class OutputIterator>434 void param(OutputIterator dest) const;435 436 // no copy functions437 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// Distributions445 446template<class IntType = int>447class uniform_int_distribution448{449public:450 // types451 typedef IntType result_type;452 453 class param_type454 {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 functions469 explicit uniform_int_distribution(IntType a = 0,470 IntType b = numeric_limits<IntType>::max()); // before C++20471 uniform_int_distribution() : uniform_int_distribution(0) {} // C++20472 explicit uniform_int_distribution(IntType a,473 IntType b = numeric_limits<IntType>::max()); // C++20474 explicit uniform_int_distribution(const param_type& parm);475 void reset();476 477 // generating functions478 template<class URNG> result_type operator()(URNG& g);479 template<class URNG> result_type operator()(URNG& g, const param_type& parm);480 481 // property functions482 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 friend498 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 friend504 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_distribution511{512public:513 // types514 typedef RealType result_type;515 516 class param_type517 {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 functions532 explicit uniform_real_distribution(RealType a = 0.0, RealType b = 1.0); // before C++20533 uniform_real_distribution() : uniform_real_distribution(0.0) {} // C++20534 explicit uniform_real_distribution(RealType a, RealType b = 1.0); // C++20535 explicit uniform_real_distribution(const param_type& parm);536 void reset();537 538 // generating functions539 template<class URNG> result_type operator()(URNG& g);540 template<class URNG> result_type operator()(URNG& g, const param_type& parm);541 542 // property functions543 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 friend559 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 friend565 basic_istream<charT, traits>&566 operator>>(basic_istream<charT, traits>& is,567 uniform_real_distribution& x);568};569 570class bernoulli_distribution571{572public:573 // types574 typedef bool result_type;575 576 class param_type577 {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 functions590 explicit bernoulli_distribution(double p = 0.5); // before C++20591 bernoulli_distribution() : bernoulli_distribution(0.5) {} // C++20592 explicit bernoulli_distribution(double p); // C++20593 explicit bernoulli_distribution(const param_type& parm);594 void reset();595 596 // generating functions597 template<class URNG> result_type operator()(URNG& g);598 template<class URNG> result_type operator()(URNG& g, const param_type& parm);599 600 // property functions601 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 friend616 basic_ostream<charT, traits>&617 operator<<(basic_ostream<charT, traits>& os,618 const bernoulli_distribution& x);619 620 template <class charT, class traits>621 friend622 basic_istream<charT, traits>&623 operator>>(basic_istream<charT, traits>& is,624 bernoulli_distribution& x);625};626 627template<class IntType = int>628class binomial_distribution629{630public:631 // types632 typedef IntType result_type;633 634 class param_type635 {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 functions649 explicit binomial_distribution(IntType t = 1, double p = 0.5); // before C++20650 binomial_distribution() : binomial_distribution(1) {} // C++20651 explicit binomial_distribution(IntType t, double p = 0.5); // C++20652 explicit binomial_distribution(const param_type& parm);653 void reset();654 655 // generating functions656 template<class URNG> result_type operator()(URNG& g);657 template<class URNG> result_type operator()(URNG& g, const param_type& parm);658 659 // property functions660 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 friend676 basic_ostream<charT, traits>&677 operator<<(basic_ostream<charT, traits>& os,678 const binomial_distribution& x);679 680 template <class charT, class traits>681 friend682 basic_istream<charT, traits>&683 operator>>(basic_istream<charT, traits>& is,684 binomial_distribution& x);685};686 687template<class IntType = int>688class geometric_distribution689{690public:691 // types692 typedef IntType result_type;693 694 class param_type695 {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 functions708 explicit geometric_distribution(double p = 0.5); // before C++20709 geometric_distribution() : geometric_distribution(0.5) {} // C++20710 explicit geometric_distribution(double p); // C++20711 explicit geometric_distribution(const param_type& parm);712 void reset();713 714 // generating functions715 template<class URNG> result_type operator()(URNG& g);716 template<class URNG> result_type operator()(URNG& g, const param_type& parm);717 718 // property functions719 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 friend734 basic_ostream<charT, traits>&735 operator<<(basic_ostream<charT, traits>& os,736 const geometric_distribution& x);737 738 template <class charT, class traits>739 friend740 basic_istream<charT, traits>&741 operator>>(basic_istream<charT, traits>& is,742 geometric_distribution& x);743};744 745template<class IntType = int>746class negative_binomial_distribution747{748public:749 // types750 typedef IntType result_type;751 752 class param_type753 {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 functions767 explicit negative_binomial_distribution(IntType k = 1, double p = 0.5); // before C++20768 negative_binomial_distribution() : negative_binomial_distribution(1) {} // C++20769 explicit negative_binomial_distribution(IntType k, double p = 0.5); // C++20770 explicit negative_binomial_distribution(const param_type& parm);771 void reset();772 773 // generating functions774 template<class URNG> result_type operator()(URNG& g);775 template<class URNG> result_type operator()(URNG& g, const param_type& parm);776 777 // property functions778 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 friend794 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 friend800 basic_istream<charT, traits>&801 operator>>(basic_istream<charT, traits>& is,802 negative_binomial_distribution& x);803};804 805template<class IntType = int>806class poisson_distribution807{808public:809 // types810 typedef IntType result_type;811 812 class param_type813 {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 functions826 explicit poisson_distribution(double mean = 1.0); // before C++20827 poisson_distribution() : poisson_distribution(1.0) {} // C++20828 explicit poisson_distribution(double mean); // C++20829 explicit poisson_distribution(const param_type& parm);830 void reset();831 832 // generating functions833 template<class URNG> result_type operator()(URNG& g);834 template<class URNG> result_type operator()(URNG& g, const param_type& parm);835 836 // property functions837 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 friend852 basic_ostream<charT, traits>&853 operator<<(basic_ostream<charT, traits>& os,854 const poisson_distribution& x);855 856 template <class charT, class traits>857 friend858 basic_istream<charT, traits>&859 operator>>(basic_istream<charT, traits>& is,860 poisson_distribution& x);861};862 863template<class RealType = double>864class exponential_distribution865{866public:867 // types868 typedef RealType result_type;869 870 class param_type871 {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 functions884 explicit exponential_distribution(RealType lambda = 1.0); // before C++20885 exponential_distribution() : exponential_distribution(1.0) {} // C++20886 explicit exponential_distribution(RealType lambda); // C++20887 explicit exponential_distribution(const param_type& parm);888 void reset();889 890 // generating functions891 template<class URNG> result_type operator()(URNG& g);892 template<class URNG> result_type operator()(URNG& g, const param_type& parm);893 894 // property functions895 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 friend910 basic_ostream<charT, traits>&911 operator<<(basic_ostream<charT, traits>& os,912 const exponential_distribution& x);913 914 template <class charT, class traits>915 friend916 basic_istream<charT, traits>&917 operator>>(basic_istream<charT, traits>& is,918 exponential_distribution& x);919};920 921template<class RealType = double>922class gamma_distribution923{924public:925 // types926 typedef RealType result_type;927 928 class param_type929 {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 functions943 explicit gamma_distribution(RealType alpha = 0.0, RealType beta = 1.0); // before C++20944 gamma_distribution() : gamma_distribution(0.0) {} // C++20945 explicit gamma_distribution(RealType alpha, RealType beta = 1.0); // C++20946 explicit gamma_distribution(const param_type& parm);947 void reset();948 949 // generating functions950 template<class URNG> result_type operator()(URNG& g);951 template<class URNG> result_type operator()(URNG& g, const param_type& parm);952 953 // property functions954 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 friend970 basic_ostream<charT, traits>&971 operator<<(basic_ostream<charT, traits>& os,972 const gamma_distribution& x);973 974 template <class charT, class traits>975 friend976 basic_istream<charT, traits>&977 operator>>(basic_istream<charT, traits>& is,978 gamma_distribution& x);979};980 981template<class RealType = double>982class weibull_distribution983{984public:985 // types986 typedef RealType result_type;987 988 class param_type989 {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 functions1003 explicit weibull_distribution(RealType a = 1.0, RealType b = 1.0); // before C++201004 weibull_distribution() : weibull_distribution(1.0) {} // C++201005 explicit weibull_distribution(RealType a, RealType b = 1.0); // C++201006 explicit weibull_distribution(const param_type& parm);1007 void reset();1008 1009 // generating functions1010 template<class URNG> result_type operator()(URNG& g);1011 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1012 1013 // property functions1014 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 friend1030 basic_ostream<charT, traits>&1031 operator<<(basic_ostream<charT, traits>& os,1032 const weibull_distribution& x);1033 1034 template <class charT, class traits>1035 friend1036 basic_istream<charT, traits>&1037 operator>>(basic_istream<charT, traits>& is,1038 weibull_distribution& x);1039};1040 1041template<class RealType = double>1042class extreme_value_distribution1043{1044public:1045 // types1046 typedef RealType result_type;1047 1048 class param_type1049 {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 functions1063 explicit extreme_value_distribution(RealType a = 0.0, RealType b = 1.0); // before C++201064 extreme_value_distribution() : extreme_value_distribution(0.0) {} // C++201065 explicit extreme_value_distribution(RealType a, RealType b = 1.0); // C++201066 explicit extreme_value_distribution(const param_type& parm);1067 void reset();1068 1069 // generating functions1070 template<class URNG> result_type operator()(URNG& g);1071 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1072 1073 // property functions1074 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 friend1090 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 friend1096 basic_istream<charT, traits>&1097 operator>>(basic_istream<charT, traits>& is,1098 extreme_value_distribution& x);1099};1100 1101template<class RealType = double>1102class normal_distribution1103{1104public:1105 // types1106 typedef RealType result_type;1107 1108 class param_type1109 {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 functions1123 explicit normal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++201124 normal_distribution() : normal_distribution(0.0) {} // C++201125 explicit normal_distribution(RealType mean, RealType stddev = 1.0); // C++201126 explicit normal_distribution(const param_type& parm);1127 void reset();1128 1129 // generating functions1130 template<class URNG> result_type operator()(URNG& g);1131 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1132 1133 // property functions1134 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 friend1150 basic_ostream<charT, traits>&1151 operator<<(basic_ostream<charT, traits>& os,1152 const normal_distribution& x);1153 1154 template <class charT, class traits>1155 friend1156 basic_istream<charT, traits>&1157 operator>>(basic_istream<charT, traits>& is,1158 normal_distribution& x);1159};1160 1161template<class RealType = double>1162class lognormal_distribution1163{1164public:1165 // types1166 typedef RealType result_type;1167 1168 class param_type1169 {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 functions1183 explicit lognormal_distribution(RealType mean = 0.0, RealType stddev = 1.0); // before C++201184 lognormal_distribution() : lognormal_distribution(0.0) {} // C++201185 explicit lognormal_distribution(RealType mean, RealType stddev = 1.0); // C++201186 explicit lognormal_distribution(const param_type& parm);1187 void reset();1188 1189 // generating functions1190 template<class URNG> result_type operator()(URNG& g);1191 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1192 1193 // property functions1194 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 friend1210 basic_ostream<charT, traits>&1211 operator<<(basic_ostream<charT, traits>& os,1212 const lognormal_distribution& x);1213 1214 template <class charT, class traits>1215 friend1216 basic_istream<charT, traits>&1217 operator>>(basic_istream<charT, traits>& is,1218 lognormal_distribution& x);1219};1220 1221template<class RealType = double>1222class chi_squared_distribution1223{1224public:1225 // types1226 typedef RealType result_type;1227 1228 class param_type1229 {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 functions1242 explicit chi_squared_distribution(RealType n = 1.0); // before C++201243 chi_squared_distribution() : chi_squared_distribution(1.0) {} // C++201244 explicit chi_squared_distribution(RealType n); // C++201245 explicit chi_squared_distribution(const param_type& parm);1246 void reset();1247 1248 // generating functions1249 template<class URNG> result_type operator()(URNG& g);1250 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1251 1252 // property functions1253 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 friend1268 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 friend1274 basic_istream<charT, traits>&1275 operator>>(basic_istream<charT, traits>& is,1276 chi_squared_distribution& x);1277};1278 1279template<class RealType = double>1280class cauchy_distribution1281{1282public:1283 // types1284 typedef RealType result_type;1285 1286 class param_type1287 {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 functions1301 explicit cauchy_distribution(RealType a = 0.0, RealType b = 1.0); // before C++201302 cauchy_distribution() : cauchy_distribution(0.0) {} // C++201303 explicit cauchy_distribution(RealType a, RealType b = 1.0); // C++201304 explicit cauchy_distribution(const param_type& parm);1305 void reset();1306 1307 // generating functions1308 template<class URNG> result_type operator()(URNG& g);1309 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1310 1311 // property functions1312 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 friend1328 basic_ostream<charT, traits>&1329 operator<<(basic_ostream<charT, traits>& os,1330 const cauchy_distribution& x);1331 1332 template <class charT, class traits>1333 friend1334 basic_istream<charT, traits>&1335 operator>>(basic_istream<charT, traits>& is,1336 cauchy_distribution& x);1337};1338 1339template<class RealType = double>1340class fisher_f_distribution1341{1342public:1343 // types1344 typedef RealType result_type;1345 1346 class param_type1347 {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 functions1361 explicit fisher_f_distribution(RealType m = 1.0, RealType n = 1.0); // before C++201362 fisher_f_distribution() : fisher_f_distribution(1.0) {} // C++201363 explicit fisher_f_distribution(RealType m, RealType n = 1.0); // C++201364 explicit fisher_f_distribution(const param_type& parm);1365 void reset();1366 1367 // generating functions1368 template<class URNG> result_type operator()(URNG& g);1369 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1370 1371 // property functions1372 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 friend1388 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 friend1394 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_distribution1401{1402public:1403 // types1404 typedef RealType result_type;1405 1406 class param_type1407 {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 functions1420 explicit student_t_distribution(RealType n = 1.0); // before C++201421 student_t_distribution() : student_t_distribution(1.0) {} // C++201422 explicit student_t_distribution(RealType n); // C++201423 explicit student_t_distribution(const param_type& parm);1424 void reset();1425 1426 // generating functions1427 template<class URNG> result_type operator()(URNG& g);1428 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1429 1430 // property functions1431 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 friend1446 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 friend1452 basic_istream<charT, traits>&1453 operator>>(basic_istream<charT, traits>& is,1454 student_t_distribution& x);1455};1456 1457template<class IntType = int>1458class discrete_distribution1459{1460public:1461 // types1462 typedef IntType result_type;1463 1464 class param_type1465 {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 functions1483 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 functions1494 template<class URNG> result_type operator()(URNG& g);1495 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1496 1497 // property functions1498 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 friend1513 basic_ostream<charT, traits>&1514 operator<<(basic_ostream<charT, traits>& os,1515 const discrete_distribution& x);1516 1517 template <class charT, class traits>1518 friend1519 basic_istream<charT, traits>&1520 operator>>(basic_istream<charT, traits>& is,1521 discrete_distribution& x);1522};1523 1524template<class RealType = double>1525class piecewise_constant_distribution1526{1527 // types1528 typedef RealType result_type;1529 1530 class param_type1531 {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 functions1553 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 functions1568 template<class URNG> result_type operator()(URNG& g);1569 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1570 1571 // property functions1572 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 friend1588 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 friend1594 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_distribution1601{1602 // types1603 typedef RealType result_type;1604 1605 class param_type1606 {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 functions1628 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 functions1646 template<class URNG> result_type operator()(URNG& g);1647 template<class URNG> result_type operator()(URNG& g, const param_type& parm);1648 1649 // property functions1650 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 friend1666 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 friend1672 basic_istream<charT, traits>&1673 operator>>(basic_istream<charT, traits>& is,1674 piecewise_linear_distribution& x);1675};1676 1677} // std1678*/1679 1680#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)1681# include <__cxx03/random>1682#else1683# include <__config>1684# include <__random/bernoulli_distribution.h>1685# include <__random/binomial_distribution.h>1686# include <__random/cauchy_distribution.h>1687# include <__random/chi_squared_distribution.h>1688# include <__random/default_random_engine.h>1689# include <__random/discard_block_engine.h>1690# include <__random/discrete_distribution.h>1691# include <__random/exponential_distribution.h>1692# include <__random/extreme_value_distribution.h>1693# include <__random/fisher_f_distribution.h>1694# include <__random/gamma_distribution.h>1695# include <__random/generate_canonical.h>1696# include <__random/geometric_distribution.h>1697# include <__random/independent_bits_engine.h>1698# include <__random/is_seed_sequence.h>1699# include <__random/knuth_b.h>1700# include <__random/linear_congruential_engine.h>1701# include <__random/lognormal_distribution.h>1702# include <__random/mersenne_twister_engine.h>1703# include <__random/negative_binomial_distribution.h>1704# include <__random/normal_distribution.h>1705# include <__random/piecewise_constant_distribution.h>1706# include <__random/piecewise_linear_distribution.h>1707# include <__random/poisson_distribution.h>1708# include <__random/random_device.h>1709# include <__random/ranlux.h>1710# include <__random/seed_seq.h>1711# include <__random/shuffle_order_engine.h>1712# include <__random/student_t_distribution.h>1713# include <__random/subtract_with_carry_engine.h>1714# include <__random/uniform_int_distribution.h>1715# include <__random/uniform_random_bit_generator.h>1716# include <__random/uniform_real_distribution.h>1717# include <__random/weibull_distribution.h>1718# include <version>1719 1720// standard-mandated includes1721 1722// [rand.synopsis]1723# include <initializer_list>1724 1725# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)1726# pragma GCC system_header1727# endif1728 1729# if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 201730# include <algorithm>1731# include <climits>1732# include <cmath>1733# include <concepts>1734# include <cstddef>1735# include <cstdint>1736# include <cstdlib>1737# include <iosfwd>1738# include <limits>1739# include <numeric>1740# include <string>1741# include <type_traits>1742# include <vector>1743# endif1744#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)1745 1746#endif // _LIBCPP_RANDOM1747