1 // random number generation -*- C++ -*- 2 3 // Copyright (C) 2009-2017 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 /** 26 * @file bits/random.h 27 * This is an internal header file, included by other library headers. 28 * Do not attempt to use it directly. @headername{random} 29 */ 30 31 #ifndef _RANDOM_H 32 #define _RANDOM_H 1 33 34 #include <vector> 35 #include <bits/uniform_int_dist.h> 36 37 namespace std _GLIBCXX_VISIBILITY(default) 38 { 39 _GLIBCXX_BEGIN_NAMESPACE_VERSION 40 41 // [26.4] Random number generation 42 43 /** 44 * @defgroup random Random Number Generation 45 * @ingroup numerics 46 * 47 * A facility for generating random numbers on selected distributions. 48 * @{ 49 */ 50 51 /** 52 * @brief A function template for converting the output of a (integral) 53 * uniform random number generator to a floatng point result in the range 54 * [0-1). 55 */ 56 template<typename _RealType, size_t __bits, 57 typename _UniformRandomNumberGenerator> 58 _RealType 59 generate_canonical(_UniformRandomNumberGenerator& __g); 60 61 _GLIBCXX_END_NAMESPACE_VERSION 62 63 /* 64 * Implementation-space details. 65 */ 66 namespace __detail 67 { 68 _GLIBCXX_BEGIN_NAMESPACE_VERSION 69 70 template<typename _UIntType, size_t __w, 71 bool = __w < static_cast<size_t> 72 (std::numeric_limits<_UIntType>::digits)> 73 struct _Shift 74 { static const _UIntType __value = 0; }; 75 76 template<typename _UIntType, size_t __w> 77 struct _Shift<_UIntType, __w, true> 78 { static const _UIntType __value = _UIntType(1) << __w; }; 79 80 template<int __s, 81 int __which = ((__s <= __CHAR_BIT__ * sizeof (int)) 82 + (__s <= __CHAR_BIT__ * sizeof (long)) 83 + (__s <= __CHAR_BIT__ * sizeof (long long)) 84 /* assume long long no bigger than __int128 */ 85 + (__s <= 128))> 86 struct _Select_uint_least_t 87 { 88 static_assert(__which < 0, /* needs to be dependent */ 89 "sorry, would be too much trouble for a slow result"); 90 }; 91 92 template<int __s> 93 struct _Select_uint_least_t<__s, 4> 94 { typedef unsigned int type; }; 95 96 template<int __s> 97 struct _Select_uint_least_t<__s, 3> 98 { typedef unsigned long type; }; 99 100 template<int __s> 101 struct _Select_uint_least_t<__s, 2> 102 { typedef unsigned long long type; }; 103 104 #ifdef _GLIBCXX_USE_INT128 105 template<int __s> 106 struct _Select_uint_least_t<__s, 1> 107 { typedef unsigned __int128 type; }; 108 #endif 109 110 // Assume a != 0, a < m, c < m, x < m. 111 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, 112 bool __big_enough = (!(__m & (__m - 1)) 113 || (_Tp(-1) - __c) / __a >= __m - 1), 114 bool __schrage_ok = __m % __a < __m / __a> 115 struct _Mod 116 { 117 typedef typename _Select_uint_least_t<std::__lg(__a) 118 + std::__lg(__m) + 2>::type _Tp2; 119 static _Tp 120 __calc(_Tp __x) 121 { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); } 122 }; 123 124 // Schrage. 125 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c> 126 struct _Mod<_Tp, __m, __a, __c, false, true> 127 { 128 static _Tp 129 __calc(_Tp __x); 130 }; 131 132 // Special cases: 133 // - for m == 2^n or m == 0, unsigned integer overflow is safe. 134 // - a * (m - 1) + c fits in _Tp, there is no overflow. 135 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s> 136 struct _Mod<_Tp, __m, __a, __c, true, __s> 137 { 138 static _Tp 139 __calc(_Tp __x) 140 { 141 _Tp __res = __a * __x + __c; 142 if (__m) 143 __res %= __m; 144 return __res; 145 } 146 }; 147 148 template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0> 149 inline _Tp 150 __mod(_Tp __x) 151 { return _Mod<_Tp, __m, __a, __c>::__calc(__x); } 152 153 /* 154 * An adaptor class for converting the output of any Generator into 155 * the input for a specific Distribution. 156 */ 157 template<typename _Engine, typename _DInputType> 158 struct _Adaptor 159 { 160 static_assert(std::is_floating_point<_DInputType>::value, 161 "template argument must be a floating point type"); 162 163 public: 164 _Adaptor(_Engine& __g) 165 : _M_g(__g) { } 166 167 _DInputType 168 min() const 169 { return _DInputType(0); } 170 171 _DInputType 172 max() const 173 { return _DInputType(1); } 174 175 /* 176 * Converts a value generated by the adapted random number generator 177 * into a value in the input domain for the dependent random number 178 * distribution. 179 */ 180 _DInputType 181 operator()() 182 { 183 return std::generate_canonical<_DInputType, 184 std::numeric_limits<_DInputType>::digits, 185 _Engine>(_M_g); 186 } 187 188 private: 189 _Engine& _M_g; 190 }; 191 192 _GLIBCXX_END_NAMESPACE_VERSION 193 } // namespace __detail 194 195 _GLIBCXX_BEGIN_NAMESPACE_VERSION 196 197 /** 198 * @addtogroup random_generators Random Number Generators 199 * @ingroup random 200 * 201 * These classes define objects which provide random or pseudorandom 202 * numbers, either from a discrete or a continuous interval. The 203 * random number generator supplied as a part of this library are 204 * all uniform random number generators which provide a sequence of 205 * random number uniformly distributed over their range. 206 * 207 * A number generator is a function object with an operator() that 208 * takes zero arguments and returns a number. 209 * 210 * A compliant random number generator must satisfy the following 211 * requirements. <table border=1 cellpadding=10 cellspacing=0> 212 * <caption align=top>Random Number Generator Requirements</caption> 213 * <tr><td>To be documented.</td></tr> </table> 214 * 215 * @{ 216 */ 217 218 /** 219 * @brief A model of a linear congruential random number generator. 220 * 221 * A random number generator that produces pseudorandom numbers via 222 * linear function: 223 * @f[ 224 * x_{i+1}\leftarrow(ax_{i} + c) \bmod m 225 * @f] 226 * 227 * The template parameter @p _UIntType must be an unsigned integral type 228 * large enough to store values up to (__m-1). If the template parameter 229 * @p __m is 0, the modulus @p __m used is 230 * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template 231 * parameters @p __a and @p __c must be less than @p __m. 232 * 233 * The size of the state is @f$1@f$. 234 */ 235 template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> 236 class linear_congruential_engine 237 { 238 static_assert(std::is_unsigned<_UIntType>::value, 239 "result_type must be an unsigned integral type"); 240 static_assert(__m == 0u || (__a < __m && __c < __m), 241 "template argument substituting __m out of bounds"); 242 243 public: 244 /** The type of the generated random value. */ 245 typedef _UIntType result_type; 246 247 /** The multiplier. */ 248 static constexpr result_type multiplier = __a; 249 /** An increment. */ 250 static constexpr result_type increment = __c; 251 /** The modulus. */ 252 static constexpr result_type modulus = __m; 253 static constexpr result_type default_seed = 1u; 254 255 /** 256 * @brief Constructs a %linear_congruential_engine random number 257 * generator engine with seed @p __s. The default seed value 258 * is 1. 259 * 260 * @param __s The initial seed value. 261 */ 262 explicit 263 linear_congruential_engine(result_type __s = default_seed) 264 { seed(__s); } 265 266 /** 267 * @brief Constructs a %linear_congruential_engine random number 268 * generator engine seeded from the seed sequence @p __q. 269 * 270 * @param __q the seed sequence. 271 */ 272 template<typename _Sseq, typename = typename 273 std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value> 274 ::type> 275 explicit 276 linear_congruential_engine(_Sseq& __q) 277 { seed(__q); } 278 279 /** 280 * @brief Reseeds the %linear_congruential_engine random number generator 281 * engine sequence to the seed @p __s. 282 * 283 * @param __s The new seed. 284 */ 285 void 286 seed(result_type __s = default_seed); 287 288 /** 289 * @brief Reseeds the %linear_congruential_engine random number generator 290 * engine 291 * sequence using values from the seed sequence @p __q. 292 * 293 * @param __q the seed sequence. 294 */ 295 template<typename _Sseq> 296 typename std::enable_if<std::is_class<_Sseq>::value>::type 297 seed(_Sseq& __q); 298 299 /** 300 * @brief Gets the smallest possible value in the output range. 301 * 302 * The minimum depends on the @p __c parameter: if it is zero, the 303 * minimum generated must be > 0, otherwise 0 is allowed. 304 */ 305 static constexpr result_type 306 min() 307 { return __c == 0u ? 1u : 0u; } 308 309 /** 310 * @brief Gets the largest possible value in the output range. 311 */ 312 static constexpr result_type 313 max() 314 { return __m - 1u; } 315 316 /** 317 * @brief Discard a sequence of random numbers. 318 */ 319 void 320 discard(unsigned long long __z) 321 { 322 for (; __z != 0ULL; --__z) 323 (*this)(); 324 } 325 326 /** 327 * @brief Gets the next random number in the sequence. 328 */ 329 result_type 330 operator()() 331 { 332 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x); 333 return _M_x; 334 } 335 336 /** 337 * @brief Compares two linear congruential random number generator 338 * objects of the same type for equality. 339 * 340 * @param __lhs A linear congruential random number generator object. 341 * @param __rhs Another linear congruential random number generator 342 * object. 343 * 344 * @returns true if the infinite sequences of generated values 345 * would be equal, false otherwise. 346 */ 347 friend bool 348 operator==(const linear_congruential_engine& __lhs, 349 const linear_congruential_engine& __rhs) 350 { return __lhs._M_x == __rhs._M_x; } 351 352 /** 353 * @brief Writes the textual representation of the state x(i) of x to 354 * @p __os. 355 * 356 * @param __os The output stream. 357 * @param __lcr A % linear_congruential_engine random number generator. 358 * @returns __os. 359 */ 360 template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1, 361 _UIntType1 __m1, typename _CharT, typename _Traits> 362 friend std::basic_ostream<_CharT, _Traits>& 363 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 364 const std::linear_congruential_engine<_UIntType1, 365 __a1, __c1, __m1>& __lcr); 366 367 /** 368 * @brief Sets the state of the engine by reading its textual 369 * representation from @p __is. 370 * 371 * The textual representation must have been previously written using 372 * an output stream whose imbued locale and whose type's template 373 * specialization arguments _CharT and _Traits were the same as those 374 * of @p __is. 375 * 376 * @param __is The input stream. 377 * @param __lcr A % linear_congruential_engine random number generator. 378 * @returns __is. 379 */ 380 template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1, 381 _UIntType1 __m1, typename _CharT, typename _Traits> 382 friend std::basic_istream<_CharT, _Traits>& 383 operator>>(std::basic_istream<_CharT, _Traits>& __is, 384 std::linear_congruential_engine<_UIntType1, __a1, 385 __c1, __m1>& __lcr); 386 387 private: 388 _UIntType _M_x; 389 }; 390 391 /** 392 * @brief Compares two linear congruential random number generator 393 * objects of the same type for inequality. 394 * 395 * @param __lhs A linear congruential random number generator object. 396 * @param __rhs Another linear congruential random number generator 397 * object. 398 * 399 * @returns true if the infinite sequences of generated values 400 * would be different, false otherwise. 401 */ 402 template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> 403 inline bool 404 operator!=(const std::linear_congruential_engine<_UIntType, __a, 405 __c, __m>& __lhs, 406 const std::linear_congruential_engine<_UIntType, __a, 407 __c, __m>& __rhs) 408 { return !(__lhs == __rhs); } 409 410 411 /** 412 * A generalized feedback shift register discrete random number generator. 413 * 414 * This algorithm avoids multiplication and division and is designed to be 415 * friendly to a pipelined architecture. If the parameters are chosen 416 * correctly, this generator will produce numbers with a very long period and 417 * fairly good apparent entropy, although still not cryptographically strong. 418 * 419 * The best way to use this generator is with the predefined mt19937 class. 420 * 421 * This algorithm was originally invented by Makoto Matsumoto and 422 * Takuji Nishimura. 423 * 424 * @tparam __w Word size, the number of bits in each element of 425 * the state vector. 426 * @tparam __n The degree of recursion. 427 * @tparam __m The period parameter. 428 * @tparam __r The separation point bit index. 429 * @tparam __a The last row of the twist matrix. 430 * @tparam __u The first right-shift tempering matrix parameter. 431 * @tparam __d The first right-shift tempering matrix mask. 432 * @tparam __s The first left-shift tempering matrix parameter. 433 * @tparam __b The first left-shift tempering matrix mask. 434 * @tparam __t The second left-shift tempering matrix parameter. 435 * @tparam __c The second left-shift tempering matrix mask. 436 * @tparam __l The second right-shift tempering matrix parameter. 437 * @tparam __f Initialization multiplier. 438 */ 439 template<typename _UIntType, size_t __w, 440 size_t __n, size_t __m, size_t __r, 441 _UIntType __a, size_t __u, _UIntType __d, size_t __s, 442 _UIntType __b, size_t __t, 443 _UIntType __c, size_t __l, _UIntType __f> 444 class mersenne_twister_engine 445 { 446 static_assert(std::is_unsigned<_UIntType>::value, 447 "result_type must be an unsigned integral type"); 448 static_assert(1u <= __m && __m <= __n, 449 "template argument substituting __m out of bounds"); 450 static_assert(__r <= __w, "template argument substituting " 451 "__r out of bound"); 452 static_assert(__u <= __w, "template argument substituting " 453 "__u out of bound"); 454 static_assert(__s <= __w, "template argument substituting " 455 "__s out of bound"); 456 static_assert(__t <= __w, "template argument substituting " 457 "__t out of bound"); 458 static_assert(__l <= __w, "template argument substituting " 459 "__l out of bound"); 460 static_assert(__w <= std::numeric_limits<_UIntType>::digits, 461 "template argument substituting __w out of bound"); 462 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1), 463 "template argument substituting __a out of bound"); 464 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1), 465 "template argument substituting __b out of bound"); 466 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1), 467 "template argument substituting __c out of bound"); 468 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1), 469 "template argument substituting __d out of bound"); 470 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1), 471 "template argument substituting __f out of bound"); 472 473 public: 474 /** The type of the generated random value. */ 475 typedef _UIntType result_type; 476 477 // parameter values 478 static constexpr size_t word_size = __w; 479 static constexpr size_t state_size = __n; 480 static constexpr size_t shift_size = __m; 481 static constexpr size_t mask_bits = __r; 482 static constexpr result_type xor_mask = __a; 483 static constexpr size_t tempering_u = __u; 484 static constexpr result_type tempering_d = __d; 485 static constexpr size_t tempering_s = __s; 486 static constexpr result_type tempering_b = __b; 487 static constexpr size_t tempering_t = __t; 488 static constexpr result_type tempering_c = __c; 489 static constexpr size_t tempering_l = __l; 490 static constexpr result_type initialization_multiplier = __f; 491 static constexpr result_type default_seed = 5489u; 492 493 // constructors and member function 494 explicit 495 mersenne_twister_engine(result_type __sd = default_seed) 496 { seed(__sd); } 497 498 /** 499 * @brief Constructs a %mersenne_twister_engine random number generator 500 * engine seeded from the seed sequence @p __q. 501 * 502 * @param __q the seed sequence. 503 */ 504 template<typename _Sseq, typename = typename 505 std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value> 506 ::type> 507 explicit 508 mersenne_twister_engine(_Sseq& __q) 509 { seed(__q); } 510 511 void 512 seed(result_type __sd = default_seed); 513 514 template<typename _Sseq> 515 typename std::enable_if<std::is_class<_Sseq>::value>::type 516 seed(_Sseq& __q); 517 518 /** 519 * @brief Gets the smallest possible value in the output range. 520 */ 521 static constexpr result_type 522 min() 523 { return 0; }; 524 525 /** 526 * @brief Gets the largest possible value in the output range. 527 */ 528 static constexpr result_type 529 max() 530 { return __detail::_Shift<_UIntType, __w>::__value - 1; } 531 532 /** 533 * @brief Discard a sequence of random numbers. 534 */ 535 void 536 discard(unsigned long long __z); 537 538 result_type 539 operator()(); 540 541 /** 542 * @brief Compares two % mersenne_twister_engine random number generator 543 * objects of the same type for equality. 544 * 545 * @param __lhs A % mersenne_twister_engine random number generator 546 * object. 547 * @param __rhs Another % mersenne_twister_engine random number 548 * generator object. 549 * 550 * @returns true if the infinite sequences of generated values 551 * would be equal, false otherwise. 552 */ 553 friend bool 554 operator==(const mersenne_twister_engine& __lhs, 555 const mersenne_twister_engine& __rhs) 556 { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x) 557 && __lhs._M_p == __rhs._M_p); } 558 559 /** 560 * @brief Inserts the current state of a % mersenne_twister_engine 561 * random number generator engine @p __x into the output stream 562 * @p __os. 563 * 564 * @param __os An output stream. 565 * @param __x A % mersenne_twister_engine random number generator 566 * engine. 567 * 568 * @returns The output stream with the state of @p __x inserted or in 569 * an error state. 570 */ 571 template<typename _UIntType1, 572 size_t __w1, size_t __n1, 573 size_t __m1, size_t __r1, 574 _UIntType1 __a1, size_t __u1, 575 _UIntType1 __d1, size_t __s1, 576 _UIntType1 __b1, size_t __t1, 577 _UIntType1 __c1, size_t __l1, _UIntType1 __f1, 578 typename _CharT, typename _Traits> 579 friend std::basic_ostream<_CharT, _Traits>& 580 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 581 const std::mersenne_twister_engine<_UIntType1, __w1, __n1, 582 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, 583 __l1, __f1>& __x); 584 585 /** 586 * @brief Extracts the current state of a % mersenne_twister_engine 587 * random number generator engine @p __x from the input stream 588 * @p __is. 589 * 590 * @param __is An input stream. 591 * @param __x A % mersenne_twister_engine random number generator 592 * engine. 593 * 594 * @returns The input stream with the state of @p __x extracted or in 595 * an error state. 596 */ 597 template<typename _UIntType1, 598 size_t __w1, size_t __n1, 599 size_t __m1, size_t __r1, 600 _UIntType1 __a1, size_t __u1, 601 _UIntType1 __d1, size_t __s1, 602 _UIntType1 __b1, size_t __t1, 603 _UIntType1 __c1, size_t __l1, _UIntType1 __f1, 604 typename _CharT, typename _Traits> 605 friend std::basic_istream<_CharT, _Traits>& 606 operator>>(std::basic_istream<_CharT, _Traits>& __is, 607 std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1, 608 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, 609 __l1, __f1>& __x); 610 611 private: 612 void _M_gen_rand(); 613 614 _UIntType _M_x[state_size]; 615 size_t _M_p; 616 }; 617 618 /** 619 * @brief Compares two % mersenne_twister_engine random number generator 620 * objects of the same type for inequality. 621 * 622 * @param __lhs A % mersenne_twister_engine random number generator 623 * object. 624 * @param __rhs Another % mersenne_twister_engine random number 625 * generator object. 626 * 627 * @returns true if the infinite sequences of generated values 628 * would be different, false otherwise. 629 */ 630 template<typename _UIntType, size_t __w, 631 size_t __n, size_t __m, size_t __r, 632 _UIntType __a, size_t __u, _UIntType __d, size_t __s, 633 _UIntType __b, size_t __t, 634 _UIntType __c, size_t __l, _UIntType __f> 635 inline bool 636 operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m, 637 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs, 638 const std::mersenne_twister_engine<_UIntType, __w, __n, __m, 639 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs) 640 { return !(__lhs == __rhs); } 641 642 643 /** 644 * @brief The Marsaglia-Zaman generator. 645 * 646 * This is a model of a Generalized Fibonacci discrete random number 647 * generator, sometimes referred to as the SWC generator. 648 * 649 * A discrete random number generator that produces pseudorandom 650 * numbers using: 651 * @f[ 652 * x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m 653 * @f] 654 * 655 * The size of the state is @f$r@f$ 656 * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$. 657 */ 658 template<typename _UIntType, size_t __w, size_t __s, size_t __r> 659 class subtract_with_carry_engine 660 { 661 static_assert(std::is_unsigned<_UIntType>::value, 662 "result_type must be an unsigned integral type"); 663 static_assert(0u < __s && __s < __r, 664 "0 < s < r"); 665 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, 666 "template argument substituting __w out of bounds"); 667 668 public: 669 /** The type of the generated random value. */ 670 typedef _UIntType result_type; 671 672 // parameter values 673 static constexpr size_t word_size = __w; 674 static constexpr size_t short_lag = __s; 675 static constexpr size_t long_lag = __r; 676 static constexpr result_type default_seed = 19780503u; 677 678 /** 679 * @brief Constructs an explicitly seeded % subtract_with_carry_engine 680 * random number generator. 681 */ 682 explicit 683 subtract_with_carry_engine(result_type __sd = default_seed) 684 { seed(__sd); } 685 686 /** 687 * @brief Constructs a %subtract_with_carry_engine random number engine 688 * seeded from the seed sequence @p __q. 689 * 690 * @param __q the seed sequence. 691 */ 692 template<typename _Sseq, typename = typename 693 std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value> 694 ::type> 695 explicit 696 subtract_with_carry_engine(_Sseq& __q) 697 { seed(__q); } 698 699 /** 700 * @brief Seeds the initial state @f$x_0@f$ of the random number 701 * generator. 702 * 703 * N1688[4.19] modifies this as follows. If @p __value == 0, 704 * sets value to 19780503. In any case, with a linear 705 * congruential generator lcg(i) having parameters @f$ m_{lcg} = 706 * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value 707 * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m 708 * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$ 709 * set carry to 1, otherwise sets carry to 0. 710 */ 711 void 712 seed(result_type __sd = default_seed); 713 714 /** 715 * @brief Seeds the initial state @f$x_0@f$ of the 716 * % subtract_with_carry_engine random number generator. 717 */ 718 template<typename _Sseq> 719 typename std::enable_if<std::is_class<_Sseq>::value>::type 720 seed(_Sseq& __q); 721 722 /** 723 * @brief Gets the inclusive minimum value of the range of random 724 * integers returned by this generator. 725 */ 726 static constexpr result_type 727 min() 728 { return 0; } 729 730 /** 731 * @brief Gets the inclusive maximum value of the range of random 732 * integers returned by this generator. 733 */ 734 static constexpr result_type 735 max() 736 { return __detail::_Shift<_UIntType, __w>::__value - 1; } 737 738 /** 739 * @brief Discard a sequence of random numbers. 740 */ 741 void 742 discard(unsigned long long __z) 743 { 744 for (; __z != 0ULL; --__z) 745 (*this)(); 746 } 747 748 /** 749 * @brief Gets the next random number in the sequence. 750 */ 751 result_type 752 operator()(); 753 754 /** 755 * @brief Compares two % subtract_with_carry_engine random number 756 * generator objects of the same type for equality. 757 * 758 * @param __lhs A % subtract_with_carry_engine random number generator 759 * object. 760 * @param __rhs Another % subtract_with_carry_engine random number 761 * generator object. 762 * 763 * @returns true if the infinite sequences of generated values 764 * would be equal, false otherwise. 765 */ 766 friend bool 767 operator==(const subtract_with_carry_engine& __lhs, 768 const subtract_with_carry_engine& __rhs) 769 { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x) 770 && __lhs._M_carry == __rhs._M_carry 771 && __lhs._M_p == __rhs._M_p); } 772 773 /** 774 * @brief Inserts the current state of a % subtract_with_carry_engine 775 * random number generator engine @p __x into the output stream 776 * @p __os. 777 * 778 * @param __os An output stream. 779 * @param __x A % subtract_with_carry_engine random number generator 780 * engine. 781 * 782 * @returns The output stream with the state of @p __x inserted or in 783 * an error state. 784 */ 785 template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1, 786 typename _CharT, typename _Traits> 787 friend std::basic_ostream<_CharT, _Traits>& 788 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 789 const std::subtract_with_carry_engine<_UIntType1, __w1, 790 __s1, __r1>& __x); 791 792 /** 793 * @brief Extracts the current state of a % subtract_with_carry_engine 794 * random number generator engine @p __x from the input stream 795 * @p __is. 796 * 797 * @param __is An input stream. 798 * @param __x A % subtract_with_carry_engine random number generator 799 * engine. 800 * 801 * @returns The input stream with the state of @p __x extracted or in 802 * an error state. 803 */ 804 template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1, 805 typename _CharT, typename _Traits> 806 friend std::basic_istream<_CharT, _Traits>& 807 operator>>(std::basic_istream<_CharT, _Traits>& __is, 808 std::subtract_with_carry_engine<_UIntType1, __w1, 809 __s1, __r1>& __x); 810 811 private: 812 /// The state of the generator. This is a ring buffer. 813 _UIntType _M_x[long_lag]; 814 _UIntType _M_carry; ///< The carry 815 size_t _M_p; ///< Current index of x(i - r). 816 }; 817 818 /** 819 * @brief Compares two % subtract_with_carry_engine random number 820 * generator objects of the same type for inequality. 821 * 822 * @param __lhs A % subtract_with_carry_engine random number generator 823 * object. 824 * @param __rhs Another % subtract_with_carry_engine random number 825 * generator object. 826 * 827 * @returns true if the infinite sequences of generated values 828 * would be different, false otherwise. 829 */ 830 template<typename _UIntType, size_t __w, size_t __s, size_t __r> 831 inline bool 832 operator!=(const std::subtract_with_carry_engine<_UIntType, __w, 833 __s, __r>& __lhs, 834 const std::subtract_with_carry_engine<_UIntType, __w, 835 __s, __r>& __rhs) 836 { return !(__lhs == __rhs); } 837 838 839 /** 840 * Produces random numbers from some base engine by discarding blocks of 841 * data. 842 * 843 * 0 <= @p __r <= @p __p 844 */ 845 template<typename _RandomNumberEngine, size_t __p, size_t __r> 846 class discard_block_engine 847 { 848 static_assert(1 <= __r && __r <= __p, 849 "template argument substituting __r out of bounds"); 850 851 public: 852 /** The type of the generated random value. */ 853 typedef typename _RandomNumberEngine::result_type result_type; 854 855 // parameter values 856 static constexpr size_t block_size = __p; 857 static constexpr size_t used_block = __r; 858 859 /** 860 * @brief Constructs a default %discard_block_engine engine. 861 * 862 * The underlying engine is default constructed as well. 863 */ 864 discard_block_engine() 865 : _M_b(), _M_n(0) { } 866 867 /** 868 * @brief Copy constructs a %discard_block_engine engine. 869 * 870 * Copies an existing base class random number generator. 871 * @param __rng An existing (base class) engine object. 872 */ 873 explicit 874 discard_block_engine(const _RandomNumberEngine& __rng) 875 : _M_b(__rng), _M_n(0) { } 876 877 /** 878 * @brief Move constructs a %discard_block_engine engine. 879 * 880 * Copies an existing base class random number generator. 881 * @param __rng An existing (base class) engine object. 882 */ 883 explicit 884 discard_block_engine(_RandomNumberEngine&& __rng) 885 : _M_b(std::move(__rng)), _M_n(0) { } 886 887 /** 888 * @brief Seed constructs a %discard_block_engine engine. 889 * 890 * Constructs the underlying generator engine seeded with @p __s. 891 * @param __s A seed value for the base class engine. 892 */ 893 explicit 894 discard_block_engine(result_type __s) 895 : _M_b(__s), _M_n(0) { } 896 897 /** 898 * @brief Generator construct a %discard_block_engine engine. 899 * 900 * @param __q A seed sequence. 901 */ 902 template<typename _Sseq, typename = typename 903 std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value 904 && !std::is_same<_Sseq, _RandomNumberEngine>::value> 905 ::type> 906 explicit 907 discard_block_engine(_Sseq& __q) 908 : _M_b(__q), _M_n(0) 909 { } 910 911 /** 912 * @brief Reseeds the %discard_block_engine object with the default 913 * seed for the underlying base class generator engine. 914 */ 915 void 916 seed() 917 { 918 _M_b.seed(); 919 _M_n = 0; 920 } 921 922 /** 923 * @brief Reseeds the %discard_block_engine object with the default 924 * seed for the underlying base class generator engine. 925 */ 926 void 927 seed(result_type __s) 928 { 929 _M_b.seed(__s); 930 _M_n = 0; 931 } 932 933 /** 934 * @brief Reseeds the %discard_block_engine object with the given seed 935 * sequence. 936 * @param __q A seed generator function. 937 */ 938 template<typename _Sseq> 939 void 940 seed(_Sseq& __q) 941 { 942 _M_b.seed(__q); 943 _M_n = 0; 944 } 945 946 /** 947 * @brief Gets a const reference to the underlying generator engine 948 * object. 949 */ 950 const _RandomNumberEngine& 951 base() const noexcept 952 { return _M_b; } 953 954 /** 955 * @brief Gets the minimum value in the generated random number range. 956 */ 957 static constexpr result_type 958 min() 959 { return _RandomNumberEngine::min(); } 960 961 /** 962 * @brief Gets the maximum value in the generated random number range. 963 */ 964 static constexpr result_type 965 max() 966 { return _RandomNumberEngine::max(); } 967 968 /** 969 * @brief Discard a sequence of random numbers. 970 */ 971 void 972 discard(unsigned long long __z) 973 { 974 for (; __z != 0ULL; --__z) 975 (*this)(); 976 } 977 978 /** 979 * @brief Gets the next value in the generated random number sequence. 980 */ 981 result_type 982 operator()(); 983 984 /** 985 * @brief Compares two %discard_block_engine random number generator 986 * objects of the same type for equality. 987 * 988 * @param __lhs A %discard_block_engine random number generator object. 989 * @param __rhs Another %discard_block_engine random number generator 990 * object. 991 * 992 * @returns true if the infinite sequences of generated values 993 * would be equal, false otherwise. 994 */ 995 friend bool 996 operator==(const discard_block_engine& __lhs, 997 const discard_block_engine& __rhs) 998 { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; } 999 1000 /** 1001 * @brief Inserts the current state of a %discard_block_engine random 1002 * number generator engine @p __x into the output stream 1003 * @p __os. 1004 * 1005 * @param __os An output stream. 1006 * @param __x A %discard_block_engine random number generator engine. 1007 * 1008 * @returns The output stream with the state of @p __x inserted or in 1009 * an error state. 1010 */ 1011 template<typename _RandomNumberEngine1, size_t __p1, size_t __r1, 1012 typename _CharT, typename _Traits> 1013 friend std::basic_ostream<_CharT, _Traits>& 1014 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1015 const std::discard_block_engine<_RandomNumberEngine1, 1016 __p1, __r1>& __x); 1017 1018 /** 1019 * @brief Extracts the current state of a % subtract_with_carry_engine 1020 * random number generator engine @p __x from the input stream 1021 * @p __is. 1022 * 1023 * @param __is An input stream. 1024 * @param __x A %discard_block_engine random number generator engine. 1025 * 1026 * @returns The input stream with the state of @p __x extracted or in 1027 * an error state. 1028 */ 1029 template<typename _RandomNumberEngine1, size_t __p1, size_t __r1, 1030 typename _CharT, typename _Traits> 1031 friend std::basic_istream<_CharT, _Traits>& 1032 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1033 std::discard_block_engine<_RandomNumberEngine1, 1034 __p1, __r1>& __x); 1035 1036 private: 1037 _RandomNumberEngine _M_b; 1038 size_t _M_n; 1039 }; 1040 1041 /** 1042 * @brief Compares two %discard_block_engine random number generator 1043 * objects of the same type for inequality. 1044 * 1045 * @param __lhs A %discard_block_engine random number generator object. 1046 * @param __rhs Another %discard_block_engine random number generator 1047 * object. 1048 * 1049 * @returns true if the infinite sequences of generated values 1050 * would be different, false otherwise. 1051 */ 1052 template<typename _RandomNumberEngine, size_t __p, size_t __r> 1053 inline bool 1054 operator!=(const std::discard_block_engine<_RandomNumberEngine, __p, 1055 __r>& __lhs, 1056 const std::discard_block_engine<_RandomNumberEngine, __p, 1057 __r>& __rhs) 1058 { return !(__lhs == __rhs); } 1059 1060 1061 /** 1062 * Produces random numbers by combining random numbers from some base 1063 * engine to produce random numbers with a specifies number of bits @p __w. 1064 */ 1065 template<typename _RandomNumberEngine, size_t __w, typename _UIntType> 1066 class independent_bits_engine 1067 { 1068 static_assert(std::is_unsigned<_UIntType>::value, 1069 "result_type must be an unsigned integral type"); 1070 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, 1071 "template argument substituting __w out of bounds"); 1072 1073 public: 1074 /** The type of the generated random value. */ 1075 typedef _UIntType result_type; 1076 1077 /** 1078 * @brief Constructs a default %independent_bits_engine engine. 1079 * 1080 * The underlying engine is default constructed as well. 1081 */ 1082 independent_bits_engine() 1083 : _M_b() { } 1084 1085 /** 1086 * @brief Copy constructs a %independent_bits_engine engine. 1087 * 1088 * Copies an existing base class random number generator. 1089 * @param __rng An existing (base class) engine object. 1090 */ 1091 explicit 1092 independent_bits_engine(const _RandomNumberEngine& __rng) 1093 : _M_b(__rng) { } 1094 1095 /** 1096 * @brief Move constructs a %independent_bits_engine engine. 1097 * 1098 * Copies an existing base class random number generator. 1099 * @param __rng An existing (base class) engine object. 1100 */ 1101 explicit 1102 independent_bits_engine(_RandomNumberEngine&& __rng) 1103 : _M_b(std::move(__rng)) { } 1104 1105 /** 1106 * @brief Seed constructs a %independent_bits_engine engine. 1107 * 1108 * Constructs the underlying generator engine seeded with @p __s. 1109 * @param __s A seed value for the base class engine. 1110 */ 1111 explicit 1112 independent_bits_engine(result_type __s) 1113 : _M_b(__s) { } 1114 1115 /** 1116 * @brief Generator construct a %independent_bits_engine engine. 1117 * 1118 * @param __q A seed sequence. 1119 */ 1120 template<typename _Sseq, typename = typename 1121 std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value 1122 && !std::is_same<_Sseq, _RandomNumberEngine>::value> 1123 ::type> 1124 explicit 1125 independent_bits_engine(_Sseq& __q) 1126 : _M_b(__q) 1127 { } 1128 1129 /** 1130 * @brief Reseeds the %independent_bits_engine object with the default 1131 * seed for the underlying base class generator engine. 1132 */ 1133 void 1134 seed() 1135 { _M_b.seed(); } 1136 1137 /** 1138 * @brief Reseeds the %independent_bits_engine object with the default 1139 * seed for the underlying base class generator engine. 1140 */ 1141 void 1142 seed(result_type __s) 1143 { _M_b.seed(__s); } 1144 1145 /** 1146 * @brief Reseeds the %independent_bits_engine object with the given 1147 * seed sequence. 1148 * @param __q A seed generator function. 1149 */ 1150 template<typename _Sseq> 1151 void 1152 seed(_Sseq& __q) 1153 { _M_b.seed(__q); } 1154 1155 /** 1156 * @brief Gets a const reference to the underlying generator engine 1157 * object. 1158 */ 1159 const _RandomNumberEngine& 1160 base() const noexcept 1161 { return _M_b; } 1162 1163 /** 1164 * @brief Gets the minimum value in the generated random number range. 1165 */ 1166 static constexpr result_type 1167 min() 1168 { return 0U; } 1169 1170 /** 1171 * @brief Gets the maximum value in the generated random number range. 1172 */ 1173 static constexpr result_type 1174 max() 1175 { return __detail::_Shift<_UIntType, __w>::__value - 1; } 1176 1177 /** 1178 * @brief Discard a sequence of random numbers. 1179 */ 1180 void 1181 discard(unsigned long long __z) 1182 { 1183 for (; __z != 0ULL; --__z) 1184 (*this)(); 1185 } 1186 1187 /** 1188 * @brief Gets the next value in the generated random number sequence. 1189 */ 1190 result_type 1191 operator()(); 1192 1193 /** 1194 * @brief Compares two %independent_bits_engine random number generator 1195 * objects of the same type for equality. 1196 * 1197 * @param __lhs A %independent_bits_engine random number generator 1198 * object. 1199 * @param __rhs Another %independent_bits_engine random number generator 1200 * object. 1201 * 1202 * @returns true if the infinite sequences of generated values 1203 * would be equal, false otherwise. 1204 */ 1205 friend bool 1206 operator==(const independent_bits_engine& __lhs, 1207 const independent_bits_engine& __rhs) 1208 { return __lhs._M_b == __rhs._M_b; } 1209 1210 /** 1211 * @brief Extracts the current state of a % subtract_with_carry_engine 1212 * random number generator engine @p __x from the input stream 1213 * @p __is. 1214 * 1215 * @param __is An input stream. 1216 * @param __x A %independent_bits_engine random number generator 1217 * engine. 1218 * 1219 * @returns The input stream with the state of @p __x extracted or in 1220 * an error state. 1221 */ 1222 template<typename _CharT, typename _Traits> 1223 friend std::basic_istream<_CharT, _Traits>& 1224 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1225 std::independent_bits_engine<_RandomNumberEngine, 1226 __w, _UIntType>& __x) 1227 { 1228 __is >> __x._M_b; 1229 return __is; 1230 } 1231 1232 private: 1233 _RandomNumberEngine _M_b; 1234 }; 1235 1236 /** 1237 * @brief Compares two %independent_bits_engine random number generator 1238 * objects of the same type for inequality. 1239 * 1240 * @param __lhs A %independent_bits_engine random number generator 1241 * object. 1242 * @param __rhs Another %independent_bits_engine random number generator 1243 * object. 1244 * 1245 * @returns true if the infinite sequences of generated values 1246 * would be different, false otherwise. 1247 */ 1248 template<typename _RandomNumberEngine, size_t __w, typename _UIntType> 1249 inline bool 1250 operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w, 1251 _UIntType>& __lhs, 1252 const std::independent_bits_engine<_RandomNumberEngine, __w, 1253 _UIntType>& __rhs) 1254 { return !(__lhs == __rhs); } 1255 1256 /** 1257 * @brief Inserts the current state of a %independent_bits_engine random 1258 * number generator engine @p __x into the output stream @p __os. 1259 * 1260 * @param __os An output stream. 1261 * @param __x A %independent_bits_engine random number generator engine. 1262 * 1263 * @returns The output stream with the state of @p __x inserted or in 1264 * an error state. 1265 */ 1266 template<typename _RandomNumberEngine, size_t __w, typename _UIntType, 1267 typename _CharT, typename _Traits> 1268 std::basic_ostream<_CharT, _Traits>& 1269 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1270 const std::independent_bits_engine<_RandomNumberEngine, 1271 __w, _UIntType>& __x) 1272 { 1273 __os << __x.base(); 1274 return __os; 1275 } 1276 1277 1278 /** 1279 * @brief Produces random numbers by combining random numbers from some 1280 * base engine to produce random numbers with a specifies number of bits 1281 * @p __k. 1282 */ 1283 template<typename _RandomNumberEngine, size_t __k> 1284 class shuffle_order_engine 1285 { 1286 static_assert(1u <= __k, "template argument substituting " 1287 "__k out of bound"); 1288 1289 public: 1290 /** The type of the generated random value. */ 1291 typedef typename _RandomNumberEngine::result_type result_type; 1292 1293 static constexpr size_t table_size = __k; 1294 1295 /** 1296 * @brief Constructs a default %shuffle_order_engine engine. 1297 * 1298 * The underlying engine is default constructed as well. 1299 */ 1300 shuffle_order_engine() 1301 : _M_b() 1302 { _M_initialize(); } 1303 1304 /** 1305 * @brief Copy constructs a %shuffle_order_engine engine. 1306 * 1307 * Copies an existing base class random number generator. 1308 * @param __rng An existing (base class) engine object. 1309 */ 1310 explicit 1311 shuffle_order_engine(const _RandomNumberEngine& __rng) 1312 : _M_b(__rng) 1313 { _M_initialize(); } 1314 1315 /** 1316 * @brief Move constructs a %shuffle_order_engine engine. 1317 * 1318 * Copies an existing base class random number generator. 1319 * @param __rng An existing (base class) engine object. 1320 */ 1321 explicit 1322 shuffle_order_engine(_RandomNumberEngine&& __rng) 1323 : _M_b(std::move(__rng)) 1324 { _M_initialize(); } 1325 1326 /** 1327 * @brief Seed constructs a %shuffle_order_engine engine. 1328 * 1329 * Constructs the underlying generator engine seeded with @p __s. 1330 * @param __s A seed value for the base class engine. 1331 */ 1332 explicit 1333 shuffle_order_engine(result_type __s) 1334 : _M_b(__s) 1335 { _M_initialize(); } 1336 1337 /** 1338 * @brief Generator construct a %shuffle_order_engine engine. 1339 * 1340 * @param __q A seed sequence. 1341 */ 1342 template<typename _Sseq, typename = typename 1343 std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value 1344 && !std::is_same<_Sseq, _RandomNumberEngine>::value> 1345 ::type> 1346 explicit 1347 shuffle_order_engine(_Sseq& __q) 1348 : _M_b(__q) 1349 { _M_initialize(); } 1350 1351 /** 1352 * @brief Reseeds the %shuffle_order_engine object with the default seed 1353 for the underlying base class generator engine. 1354 */ 1355 void 1356 seed() 1357 { 1358 _M_b.seed(); 1359 _M_initialize(); 1360 } 1361 1362 /** 1363 * @brief Reseeds the %shuffle_order_engine object with the default seed 1364 * for the underlying base class generator engine. 1365 */ 1366 void 1367 seed(result_type __s) 1368 { 1369 _M_b.seed(__s); 1370 _M_initialize(); 1371 } 1372 1373 /** 1374 * @brief Reseeds the %shuffle_order_engine object with the given seed 1375 * sequence. 1376 * @param __q A seed generator function. 1377 */ 1378 template<typename _Sseq> 1379 void 1380 seed(_Sseq& __q) 1381 { 1382 _M_b.seed(__q); 1383 _M_initialize(); 1384 } 1385 1386 /** 1387 * Gets a const reference to the underlying generator engine object. 1388 */ 1389 const _RandomNumberEngine& 1390 base() const noexcept 1391 { return _M_b; } 1392 1393 /** 1394 * Gets the minimum value in the generated random number range. 1395 */ 1396 static constexpr result_type 1397 min() 1398 { return _RandomNumberEngine::min(); } 1399 1400 /** 1401 * Gets the maximum value in the generated random number range. 1402 */ 1403 static constexpr result_type 1404 max() 1405 { return _RandomNumberEngine::max(); } 1406 1407 /** 1408 * Discard a sequence of random numbers. 1409 */ 1410 void 1411 discard(unsigned long long __z) 1412 { 1413 for (; __z != 0ULL; --__z) 1414 (*this)(); 1415 } 1416 1417 /** 1418 * Gets the next value in the generated random number sequence. 1419 */ 1420 result_type 1421 operator()(); 1422 1423 /** 1424 * Compares two %shuffle_order_engine random number generator objects 1425 * of the same type for equality. 1426 * 1427 * @param __lhs A %shuffle_order_engine random number generator object. 1428 * @param __rhs Another %shuffle_order_engine random number generator 1429 * object. 1430 * 1431 * @returns true if the infinite sequences of generated values 1432 * would be equal, false otherwise. 1433 */ 1434 friend bool 1435 operator==(const shuffle_order_engine& __lhs, 1436 const shuffle_order_engine& __rhs) 1437 { return (__lhs._M_b == __rhs._M_b 1438 && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v) 1439 && __lhs._M_y == __rhs._M_y); } 1440 1441 /** 1442 * @brief Inserts the current state of a %shuffle_order_engine random 1443 * number generator engine @p __x into the output stream 1444 @p __os. 1445 * 1446 * @param __os An output stream. 1447 * @param __x A %shuffle_order_engine random number generator engine. 1448 * 1449 * @returns The output stream with the state of @p __x inserted or in 1450 * an error state. 1451 */ 1452 template<typename _RandomNumberEngine1, size_t __k1, 1453 typename _CharT, typename _Traits> 1454 friend std::basic_ostream<_CharT, _Traits>& 1455 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1456 const std::shuffle_order_engine<_RandomNumberEngine1, 1457 __k1>& __x); 1458 1459 /** 1460 * @brief Extracts the current state of a % subtract_with_carry_engine 1461 * random number generator engine @p __x from the input stream 1462 * @p __is. 1463 * 1464 * @param __is An input stream. 1465 * @param __x A %shuffle_order_engine random number generator engine. 1466 * 1467 * @returns The input stream with the state of @p __x extracted or in 1468 * an error state. 1469 */ 1470 template<typename _RandomNumberEngine1, size_t __k1, 1471 typename _CharT, typename _Traits> 1472 friend std::basic_istream<_CharT, _Traits>& 1473 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1474 std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x); 1475 1476 private: 1477 void _M_initialize() 1478 { 1479 for (size_t __i = 0; __i < __k; ++__i) 1480 _M_v[__i] = _M_b(); 1481 _M_y = _M_b(); 1482 } 1483 1484 _RandomNumberEngine _M_b; 1485 result_type _M_v[__k]; 1486 result_type _M_y; 1487 }; 1488 1489 /** 1490 * Compares two %shuffle_order_engine random number generator objects 1491 * of the same type for inequality. 1492 * 1493 * @param __lhs A %shuffle_order_engine random number generator object. 1494 * @param __rhs Another %shuffle_order_engine random number generator 1495 * object. 1496 * 1497 * @returns true if the infinite sequences of generated values 1498 * would be different, false otherwise. 1499 */ 1500 template<typename _RandomNumberEngine, size_t __k> 1501 inline bool 1502 operator!=(const std::shuffle_order_engine<_RandomNumberEngine, 1503 __k>& __lhs, 1504 const std::shuffle_order_engine<_RandomNumberEngine, 1505 __k>& __rhs) 1506 { return !(__lhs == __rhs); } 1507 1508 1509 /** 1510 * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller. 1511 */ 1512 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL> 1513 minstd_rand0; 1514 1515 /** 1516 * An alternative LCR (Lehmer Generator function). 1517 */ 1518 typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL> 1519 minstd_rand; 1520 1521 /** 1522 * The classic Mersenne Twister. 1523 * 1524 * Reference: 1525 * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally 1526 * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions 1527 * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30. 1528 */ 1529 typedef mersenne_twister_engine< 1530 uint_fast32_t, 1531 32, 624, 397, 31, 1532 0x9908b0dfUL, 11, 1533 0xffffffffUL, 7, 1534 0x9d2c5680UL, 15, 1535 0xefc60000UL, 18, 1812433253UL> mt19937; 1536 1537 /** 1538 * An alternative Mersenne Twister. 1539 */ 1540 typedef mersenne_twister_engine< 1541 uint_fast64_t, 1542 64, 312, 156, 31, 1543 0xb5026f5aa96619e9ULL, 29, 1544 0x5555555555555555ULL, 17, 1545 0x71d67fffeda60000ULL, 37, 1546 0xfff7eee000000000ULL, 43, 1547 6364136223846793005ULL> mt19937_64; 1548 1549 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> 1550 ranlux24_base; 1551 1552 typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> 1553 ranlux48_base; 1554 1555 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24; 1556 1557 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48; 1558 1559 typedef shuffle_order_engine<minstd_rand0, 256> knuth_b; 1560 1561 typedef minstd_rand0 default_random_engine; 1562 1563 /** 1564 * A standard interface to a platform-specific non-deterministic 1565 * random number generator (if any are available). 1566 */ 1567 class random_device 1568 { 1569 public: 1570 /** The type of the generated random value. */ 1571 typedef unsigned int result_type; 1572 1573 // constructors, destructors and member functions 1574 1575 #ifdef _GLIBCXX_USE_RANDOM_TR1 1576 1577 explicit 1578 random_device(const std::string& __token = "default") 1579 { 1580 _M_init(__token); 1581 } 1582 1583 ~random_device() 1584 { _M_fini(); } 1585 1586 #else 1587 1588 explicit 1589 random_device(const std::string& __token = "mt19937") 1590 { _M_init_pretr1(__token); } 1591 1592 public: 1593 1594 #endif 1595 1596 static constexpr result_type 1597 min() 1598 { return std::numeric_limits<result_type>::min(); } 1599 1600 static constexpr result_type 1601 max() 1602 { return std::numeric_limits<result_type>::max(); } 1603 1604 double 1605 entropy() const noexcept 1606 { return 0.0; } 1607 1608 result_type 1609 operator()() 1610 { 1611 #ifdef _GLIBCXX_USE_RANDOM_TR1 1612 return this->_M_getval(); 1613 #else 1614 return this->_M_getval_pretr1(); 1615 #endif 1616 } 1617 1618 // No copy functions. 1619 random_device(const random_device&) = delete; 1620 void operator=(const random_device&) = delete; 1621 1622 private: 1623 1624 void _M_init(const std::string& __token); 1625 void _M_init_pretr1(const std::string& __token); 1626 void _M_fini(); 1627 1628 result_type _M_getval(); 1629 result_type _M_getval_pretr1(); 1630 1631 union 1632 { 1633 void* _M_file; 1634 mt19937 _M_mt; 1635 }; 1636 }; 1637 1638 /* @} */ // group random_generators 1639 1640 /** 1641 * @addtogroup random_distributions Random Number Distributions 1642 * @ingroup random 1643 * @{ 1644 */ 1645 1646 /** 1647 * @addtogroup random_distributions_uniform Uniform Distributions 1648 * @ingroup random_distributions 1649 * @{ 1650 */ 1651 1652 // std::uniform_int_distribution is defined in <bits/uniform_int_dist.h> 1653 1654 /** 1655 * @brief Return true if two uniform integer distributions have 1656 * different parameters. 1657 */ 1658 template<typename _IntType> 1659 inline bool 1660 operator!=(const std::uniform_int_distribution<_IntType>& __d1, 1661 const std::uniform_int_distribution<_IntType>& __d2) 1662 { return !(__d1 == __d2); } 1663 1664 /** 1665 * @brief Inserts a %uniform_int_distribution random number 1666 * distribution @p __x into the output stream @p os. 1667 * 1668 * @param __os An output stream. 1669 * @param __x A %uniform_int_distribution random number distribution. 1670 * 1671 * @returns The output stream with the state of @p __x inserted or in 1672 * an error state. 1673 */ 1674 template<typename _IntType, typename _CharT, typename _Traits> 1675 std::basic_ostream<_CharT, _Traits>& 1676 operator<<(std::basic_ostream<_CharT, _Traits>&, 1677 const std::uniform_int_distribution<_IntType>&); 1678 1679 /** 1680 * @brief Extracts a %uniform_int_distribution random number distribution 1681 * @p __x from the input stream @p __is. 1682 * 1683 * @param __is An input stream. 1684 * @param __x A %uniform_int_distribution random number generator engine. 1685 * 1686 * @returns The input stream with @p __x extracted or in an error state. 1687 */ 1688 template<typename _IntType, typename _CharT, typename _Traits> 1689 std::basic_istream<_CharT, _Traits>& 1690 operator>>(std::basic_istream<_CharT, _Traits>&, 1691 std::uniform_int_distribution<_IntType>&); 1692 1693 1694 /** 1695 * @brief Uniform continuous distribution for random numbers. 1696 * 1697 * A continuous random distribution on the range [min, max) with equal 1698 * probability throughout the range. The URNG should be real-valued and 1699 * deliver number in the range [0, 1). 1700 */ 1701 template<typename _RealType = double> 1702 class uniform_real_distribution 1703 { 1704 static_assert(std::is_floating_point<_RealType>::value, 1705 "result_type must be a floating point type"); 1706 1707 public: 1708 /** The type of the range of the distribution. */ 1709 typedef _RealType result_type; 1710 1711 /** Parameter type. */ 1712 struct param_type 1713 { 1714 typedef uniform_real_distribution<_RealType> distribution_type; 1715 1716 explicit 1717 param_type(_RealType __a = _RealType(0), 1718 _RealType __b = _RealType(1)) 1719 : _M_a(__a), _M_b(__b) 1720 { 1721 __glibcxx_assert(_M_a <= _M_b); 1722 } 1723 1724 result_type 1725 a() const 1726 { return _M_a; } 1727 1728 result_type 1729 b() const 1730 { return _M_b; } 1731 1732 friend bool 1733 operator==(const param_type& __p1, const param_type& __p2) 1734 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } 1735 1736 friend bool 1737 operator!=(const param_type& __p1, const param_type& __p2) 1738 { return !(__p1 == __p2); } 1739 1740 private: 1741 _RealType _M_a; 1742 _RealType _M_b; 1743 }; 1744 1745 public: 1746 /** 1747 * @brief Constructs a uniform_real_distribution object. 1748 * 1749 * @param __a [IN] The lower bound of the distribution. 1750 * @param __b [IN] The upper bound of the distribution. 1751 */ 1752 explicit 1753 uniform_real_distribution(_RealType __a = _RealType(0), 1754 _RealType __b = _RealType(1)) 1755 : _M_param(__a, __b) 1756 { } 1757 1758 explicit 1759 uniform_real_distribution(const param_type& __p) 1760 : _M_param(__p) 1761 { } 1762 1763 /** 1764 * @brief Resets the distribution state. 1765 * 1766 * Does nothing for the uniform real distribution. 1767 */ 1768 void 1769 reset() { } 1770 1771 result_type 1772 a() const 1773 { return _M_param.a(); } 1774 1775 result_type 1776 b() const 1777 { return _M_param.b(); } 1778 1779 /** 1780 * @brief Returns the parameter set of the distribution. 1781 */ 1782 param_type 1783 param() const 1784 { return _M_param; } 1785 1786 /** 1787 * @brief Sets the parameter set of the distribution. 1788 * @param __param The new parameter set of the distribution. 1789 */ 1790 void 1791 param(const param_type& __param) 1792 { _M_param = __param; } 1793 1794 /** 1795 * @brief Returns the inclusive lower bound of the distribution range. 1796 */ 1797 result_type 1798 min() const 1799 { return this->a(); } 1800 1801 /** 1802 * @brief Returns the inclusive upper bound of the distribution range. 1803 */ 1804 result_type 1805 max() const 1806 { return this->b(); } 1807 1808 /** 1809 * @brief Generating functions. 1810 */ 1811 template<typename _UniformRandomNumberGenerator> 1812 result_type 1813 operator()(_UniformRandomNumberGenerator& __urng) 1814 { return this->operator()(__urng, _M_param); } 1815 1816 template<typename _UniformRandomNumberGenerator> 1817 result_type 1818 operator()(_UniformRandomNumberGenerator& __urng, 1819 const param_type& __p) 1820 { 1821 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> 1822 __aurng(__urng); 1823 return (__aurng() * (__p.b() - __p.a())) + __p.a(); 1824 } 1825 1826 template<typename _ForwardIterator, 1827 typename _UniformRandomNumberGenerator> 1828 void 1829 __generate(_ForwardIterator __f, _ForwardIterator __t, 1830 _UniformRandomNumberGenerator& __urng) 1831 { this->__generate(__f, __t, __urng, _M_param); } 1832 1833 template<typename _ForwardIterator, 1834 typename _UniformRandomNumberGenerator> 1835 void 1836 __generate(_ForwardIterator __f, _ForwardIterator __t, 1837 _UniformRandomNumberGenerator& __urng, 1838 const param_type& __p) 1839 { this->__generate_impl(__f, __t, __urng, __p); } 1840 1841 template<typename _UniformRandomNumberGenerator> 1842 void 1843 __generate(result_type* __f, result_type* __t, 1844 _UniformRandomNumberGenerator& __urng, 1845 const param_type& __p) 1846 { this->__generate_impl(__f, __t, __urng, __p); } 1847 1848 /** 1849 * @brief Return true if two uniform real distributions have 1850 * the same parameters. 1851 */ 1852 friend bool 1853 operator==(const uniform_real_distribution& __d1, 1854 const uniform_real_distribution& __d2) 1855 { return __d1._M_param == __d2._M_param; } 1856 1857 private: 1858 template<typename _ForwardIterator, 1859 typename _UniformRandomNumberGenerator> 1860 void 1861 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 1862 _UniformRandomNumberGenerator& __urng, 1863 const param_type& __p); 1864 1865 param_type _M_param; 1866 }; 1867 1868 /** 1869 * @brief Return true if two uniform real distributions have 1870 * different parameters. 1871 */ 1872 template<typename _IntType> 1873 inline bool 1874 operator!=(const std::uniform_real_distribution<_IntType>& __d1, 1875 const std::uniform_real_distribution<_IntType>& __d2) 1876 { return !(__d1 == __d2); } 1877 1878 /** 1879 * @brief Inserts a %uniform_real_distribution random number 1880 * distribution @p __x into the output stream @p __os. 1881 * 1882 * @param __os An output stream. 1883 * @param __x A %uniform_real_distribution random number distribution. 1884 * 1885 * @returns The output stream with the state of @p __x inserted or in 1886 * an error state. 1887 */ 1888 template<typename _RealType, typename _CharT, typename _Traits> 1889 std::basic_ostream<_CharT, _Traits>& 1890 operator<<(std::basic_ostream<_CharT, _Traits>&, 1891 const std::uniform_real_distribution<_RealType>&); 1892 1893 /** 1894 * @brief Extracts a %uniform_real_distribution random number distribution 1895 * @p __x from the input stream @p __is. 1896 * 1897 * @param __is An input stream. 1898 * @param __x A %uniform_real_distribution random number generator engine. 1899 * 1900 * @returns The input stream with @p __x extracted or in an error state. 1901 */ 1902 template<typename _RealType, typename _CharT, typename _Traits> 1903 std::basic_istream<_CharT, _Traits>& 1904 operator>>(std::basic_istream<_CharT, _Traits>&, 1905 std::uniform_real_distribution<_RealType>&); 1906 1907 /* @} */ // group random_distributions_uniform 1908 1909 /** 1910 * @addtogroup random_distributions_normal Normal Distributions 1911 * @ingroup random_distributions 1912 * @{ 1913 */ 1914 1915 /** 1916 * @brief A normal continuous distribution for random numbers. 1917 * 1918 * The formula for the normal probability density function is 1919 * @f[ 1920 * p(x|\mu,\sigma) = \frac{1}{\sigma \sqrt{2 \pi}} 1921 * e^{- \frac{{x - \mu}^ {2}}{2 \sigma ^ {2}} } 1922 * @f] 1923 */ 1924 template<typename _RealType = double> 1925 class normal_distribution 1926 { 1927 static_assert(std::is_floating_point<_RealType>::value, 1928 "result_type must be a floating point type"); 1929 1930 public: 1931 /** The type of the range of the distribution. */ 1932 typedef _RealType result_type; 1933 1934 /** Parameter type. */ 1935 struct param_type 1936 { 1937 typedef normal_distribution<_RealType> distribution_type; 1938 1939 explicit 1940 param_type(_RealType __mean = _RealType(0), 1941 _RealType __stddev = _RealType(1)) 1942 : _M_mean(__mean), _M_stddev(__stddev) 1943 { 1944 __glibcxx_assert(_M_stddev > _RealType(0)); 1945 } 1946 1947 _RealType 1948 mean() const 1949 { return _M_mean; } 1950 1951 _RealType 1952 stddev() const 1953 { return _M_stddev; } 1954 1955 friend bool 1956 operator==(const param_type& __p1, const param_type& __p2) 1957 { return (__p1._M_mean == __p2._M_mean 1958 && __p1._M_stddev == __p2._M_stddev); } 1959 1960 friend bool 1961 operator!=(const param_type& __p1, const param_type& __p2) 1962 { return !(__p1 == __p2); } 1963 1964 private: 1965 _RealType _M_mean; 1966 _RealType _M_stddev; 1967 }; 1968 1969 public: 1970 /** 1971 * Constructs a normal distribution with parameters @f$mean@f$ and 1972 * standard deviation. 1973 */ 1974 explicit 1975 normal_distribution(result_type __mean = result_type(0), 1976 result_type __stddev = result_type(1)) 1977 : _M_param(__mean, __stddev), _M_saved_available(false) 1978 { } 1979 1980 explicit 1981 normal_distribution(const param_type& __p) 1982 : _M_param(__p), _M_saved_available(false) 1983 { } 1984 1985 /** 1986 * @brief Resets the distribution state. 1987 */ 1988 void 1989 reset() 1990 { _M_saved_available = false; } 1991 1992 /** 1993 * @brief Returns the mean of the distribution. 1994 */ 1995 _RealType 1996 mean() const 1997 { return _M_param.mean(); } 1998 1999 /** 2000 * @brief Returns the standard deviation of the distribution. 2001 */ 2002 _RealType 2003 stddev() const 2004 { return _M_param.stddev(); } 2005 2006 /** 2007 * @brief Returns the parameter set of the distribution. 2008 */ 2009 param_type 2010 param() const 2011 { return _M_param; } 2012 2013 /** 2014 * @brief Sets the parameter set of the distribution. 2015 * @param __param The new parameter set of the distribution. 2016 */ 2017 void 2018 param(const param_type& __param) 2019 { _M_param = __param; } 2020 2021 /** 2022 * @brief Returns the greatest lower bound value of the distribution. 2023 */ 2024 result_type 2025 min() const 2026 { return std::numeric_limits<result_type>::lowest(); } 2027 2028 /** 2029 * @brief Returns the least upper bound value of the distribution. 2030 */ 2031 result_type 2032 max() const 2033 { return std::numeric_limits<result_type>::max(); } 2034 2035 /** 2036 * @brief Generating functions. 2037 */ 2038 template<typename _UniformRandomNumberGenerator> 2039 result_type 2040 operator()(_UniformRandomNumberGenerator& __urng) 2041 { return this->operator()(__urng, _M_param); } 2042 2043 template<typename _UniformRandomNumberGenerator> 2044 result_type 2045 operator()(_UniformRandomNumberGenerator& __urng, 2046 const param_type& __p); 2047 2048 template<typename _ForwardIterator, 2049 typename _UniformRandomNumberGenerator> 2050 void 2051 __generate(_ForwardIterator __f, _ForwardIterator __t, 2052 _UniformRandomNumberGenerator& __urng) 2053 { this->__generate(__f, __t, __urng, _M_param); } 2054 2055 template<typename _ForwardIterator, 2056 typename _UniformRandomNumberGenerator> 2057 void 2058 __generate(_ForwardIterator __f, _ForwardIterator __t, 2059 _UniformRandomNumberGenerator& __urng, 2060 const param_type& __p) 2061 { this->__generate_impl(__f, __t, __urng, __p); } 2062 2063 template<typename _UniformRandomNumberGenerator> 2064 void 2065 __generate(result_type* __f, result_type* __t, 2066 _UniformRandomNumberGenerator& __urng, 2067 const param_type& __p) 2068 { this->__generate_impl(__f, __t, __urng, __p); } 2069 2070 /** 2071 * @brief Return true if two normal distributions have 2072 * the same parameters and the sequences that would 2073 * be generated are equal. 2074 */ 2075 template<typename _RealType1> 2076 friend bool 2077 operator==(const std::normal_distribution<_RealType1>& __d1, 2078 const std::normal_distribution<_RealType1>& __d2); 2079 2080 /** 2081 * @brief Inserts a %normal_distribution random number distribution 2082 * @p __x into the output stream @p __os. 2083 * 2084 * @param __os An output stream. 2085 * @param __x A %normal_distribution random number distribution. 2086 * 2087 * @returns The output stream with the state of @p __x inserted or in 2088 * an error state. 2089 */ 2090 template<typename _RealType1, typename _CharT, typename _Traits> 2091 friend std::basic_ostream<_CharT, _Traits>& 2092 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 2093 const std::normal_distribution<_RealType1>& __x); 2094 2095 /** 2096 * @brief Extracts a %normal_distribution random number distribution 2097 * @p __x from the input stream @p __is. 2098 * 2099 * @param __is An input stream. 2100 * @param __x A %normal_distribution random number generator engine. 2101 * 2102 * @returns The input stream with @p __x extracted or in an error 2103 * state. 2104 */ 2105 template<typename _RealType1, typename _CharT, typename _Traits> 2106 friend std::basic_istream<_CharT, _Traits>& 2107 operator>>(std::basic_istream<_CharT, _Traits>& __is, 2108 std::normal_distribution<_RealType1>& __x); 2109 2110 private: 2111 template<typename _ForwardIterator, 2112 typename _UniformRandomNumberGenerator> 2113 void 2114 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 2115 _UniformRandomNumberGenerator& __urng, 2116 const param_type& __p); 2117 2118 param_type _M_param; 2119 result_type _M_saved; 2120 bool _M_saved_available; 2121 }; 2122 2123 /** 2124 * @brief Return true if two normal distributions are different. 2125 */ 2126 template<typename _RealType> 2127 inline bool 2128 operator!=(const std::normal_distribution<_RealType>& __d1, 2129 const std::normal_distribution<_RealType>& __d2) 2130 { return !(__d1 == __d2); } 2131 2132 2133 /** 2134 * @brief A lognormal_distribution random number distribution. 2135 * 2136 * The formula for the normal probability mass function is 2137 * @f[ 2138 * p(x|m,s) = \frac{1}{sx\sqrt{2\pi}} 2139 * \exp{-\frac{(\ln{x} - m)^2}{2s^2}} 2140 * @f] 2141 */ 2142 template<typename _RealType = double> 2143 class lognormal_distribution 2144 { 2145 static_assert(std::is_floating_point<_RealType>::value, 2146 "result_type must be a floating point type"); 2147 2148 public: 2149 /** The type of the range of the distribution. */ 2150 typedef _RealType result_type; 2151 2152 /** Parameter type. */ 2153 struct param_type 2154 { 2155 typedef lognormal_distribution<_RealType> distribution_type; 2156 2157 explicit 2158 param_type(_RealType __m = _RealType(0), 2159 _RealType __s = _RealType(1)) 2160 : _M_m(__m), _M_s(__s) 2161 { } 2162 2163 _RealType 2164 m() const 2165 { return _M_m; } 2166 2167 _RealType 2168 s() const 2169 { return _M_s; } 2170 2171 friend bool 2172 operator==(const param_type& __p1, const param_type& __p2) 2173 { return __p1._M_m == __p2._M_m && __p1._M_s == __p2._M_s; } 2174 2175 friend bool 2176 operator!=(const param_type& __p1, const param_type& __p2) 2177 { return !(__p1 == __p2); } 2178 2179 private: 2180 _RealType _M_m; 2181 _RealType _M_s; 2182 }; 2183 2184 explicit 2185 lognormal_distribution(_RealType __m = _RealType(0), 2186 _RealType __s = _RealType(1)) 2187 : _M_param(__m, __s), _M_nd() 2188 { } 2189 2190 explicit 2191 lognormal_distribution(const param_type& __p) 2192 : _M_param(__p), _M_nd() 2193 { } 2194 2195 /** 2196 * Resets the distribution state. 2197 */ 2198 void 2199 reset() 2200 { _M_nd.reset(); } 2201 2202 /** 2203 * 2204 */ 2205 _RealType 2206 m() const 2207 { return _M_param.m(); } 2208 2209 _RealType 2210 s() const 2211 { return _M_param.s(); } 2212 2213 /** 2214 * @brief Returns the parameter set of the distribution. 2215 */ 2216 param_type 2217 param() const 2218 { return _M_param; } 2219 2220 /** 2221 * @brief Sets the parameter set of the distribution. 2222 * @param __param The new parameter set of the distribution. 2223 */ 2224 void 2225 param(const param_type& __param) 2226 { _M_param = __param; } 2227 2228 /** 2229 * @brief Returns the greatest lower bound value of the distribution. 2230 */ 2231 result_type 2232 min() const 2233 { return result_type(0); } 2234 2235 /** 2236 * @brief Returns the least upper bound value of the distribution. 2237 */ 2238 result_type 2239 max() const 2240 { return std::numeric_limits<result_type>::max(); } 2241 2242 /** 2243 * @brief Generating functions. 2244 */ 2245 template<typename _UniformRandomNumberGenerator> 2246 result_type 2247 operator()(_UniformRandomNumberGenerator& __urng) 2248 { return this->operator()(__urng, _M_param); } 2249 2250 template<typename _UniformRandomNumberGenerator> 2251 result_type 2252 operator()(_UniformRandomNumberGenerator& __urng, 2253 const param_type& __p) 2254 { return std::exp(__p.s() * _M_nd(__urng) + __p.m()); } 2255 2256 template<typename _ForwardIterator, 2257 typename _UniformRandomNumberGenerator> 2258 void 2259 __generate(_ForwardIterator __f, _ForwardIterator __t, 2260 _UniformRandomNumberGenerator& __urng) 2261 { this->__generate(__f, __t, __urng, _M_param); } 2262 2263 template<typename _ForwardIterator, 2264 typename _UniformRandomNumberGenerator> 2265 void 2266 __generate(_ForwardIterator __f, _ForwardIterator __t, 2267 _UniformRandomNumberGenerator& __urng, 2268 const param_type& __p) 2269 { this->__generate_impl(__f, __t, __urng, __p); } 2270 2271 template<typename _UniformRandomNumberGenerator> 2272 void 2273 __generate(result_type* __f, result_type* __t, 2274 _UniformRandomNumberGenerator& __urng, 2275 const param_type& __p) 2276 { this->__generate_impl(__f, __t, __urng, __p); } 2277 2278 /** 2279 * @brief Return true if two lognormal distributions have 2280 * the same parameters and the sequences that would 2281 * be generated are equal. 2282 */ 2283 friend bool 2284 operator==(const lognormal_distribution& __d1, 2285 const lognormal_distribution& __d2) 2286 { return (__d1._M_param == __d2._M_param 2287 && __d1._M_nd == __d2._M_nd); } 2288 2289 /** 2290 * @brief Inserts a %lognormal_distribution random number distribution 2291 * @p __x into the output stream @p __os. 2292 * 2293 * @param __os An output stream. 2294 * @param __x A %lognormal_distribution random number distribution. 2295 * 2296 * @returns The output stream with the state of @p __x inserted or in 2297 * an error state. 2298 */ 2299 template<typename _RealType1, typename _CharT, typename _Traits> 2300 friend std::basic_ostream<_CharT, _Traits>& 2301 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 2302 const std::lognormal_distribution<_RealType1>& __x); 2303 2304 /** 2305 * @brief Extracts a %lognormal_distribution random number distribution 2306 * @p __x from the input stream @p __is. 2307 * 2308 * @param __is An input stream. 2309 * @param __x A %lognormal_distribution random number 2310 * generator engine. 2311 * 2312 * @returns The input stream with @p __x extracted or in an error state. 2313 */ 2314 template<typename _RealType1, typename _CharT, typename _Traits> 2315 friend std::basic_istream<_CharT, _Traits>& 2316 operator>>(std::basic_istream<_CharT, _Traits>& __is, 2317 std::lognormal_distribution<_RealType1>& __x); 2318 2319 private: 2320 template<typename _ForwardIterator, 2321 typename _UniformRandomNumberGenerator> 2322 void 2323 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 2324 _UniformRandomNumberGenerator& __urng, 2325 const param_type& __p); 2326 2327 param_type _M_param; 2328 2329 std::normal_distribution<result_type> _M_nd; 2330 }; 2331 2332 /** 2333 * @brief Return true if two lognormal distributions are different. 2334 */ 2335 template<typename _RealType> 2336 inline bool 2337 operator!=(const std::lognormal_distribution<_RealType>& __d1, 2338 const std::lognormal_distribution<_RealType>& __d2) 2339 { return !(__d1 == __d2); } 2340 2341 2342 /** 2343 * @brief A gamma continuous distribution for random numbers. 2344 * 2345 * The formula for the gamma probability density function is: 2346 * @f[ 2347 * p(x|\alpha,\beta) = \frac{1}{\beta\Gamma(\alpha)} 2348 * (x/\beta)^{\alpha - 1} e^{-x/\beta} 2349 * @f] 2350 */ 2351 template<typename _RealType = double> 2352 class gamma_distribution 2353 { 2354 static_assert(std::is_floating_point<_RealType>::value, 2355 "result_type must be a floating point type"); 2356 2357 public: 2358 /** The type of the range of the distribution. */ 2359 typedef _RealType result_type; 2360 2361 /** Parameter type. */ 2362 struct param_type 2363 { 2364 typedef gamma_distribution<_RealType> distribution_type; 2365 friend class gamma_distribution<_RealType>; 2366 2367 explicit 2368 param_type(_RealType __alpha_val = _RealType(1), 2369 _RealType __beta_val = _RealType(1)) 2370 : _M_alpha(__alpha_val), _M_beta(__beta_val) 2371 { 2372 __glibcxx_assert(_M_alpha > _RealType(0)); 2373 _M_initialize(); 2374 } 2375 2376 _RealType 2377 alpha() const 2378 { return _M_alpha; } 2379 2380 _RealType 2381 beta() const 2382 { return _M_beta; } 2383 2384 friend bool 2385 operator==(const param_type& __p1, const param_type& __p2) 2386 { return (__p1._M_alpha == __p2._M_alpha 2387 && __p1._M_beta == __p2._M_beta); } 2388 2389 friend bool 2390 operator!=(const param_type& __p1, const param_type& __p2) 2391 { return !(__p1 == __p2); } 2392 2393 private: 2394 void 2395 _M_initialize(); 2396 2397 _RealType _M_alpha; 2398 _RealType _M_beta; 2399 2400 _RealType _M_malpha, _M_a2; 2401 }; 2402 2403 public: 2404 /** 2405 * @brief Constructs a gamma distribution with parameters 2406 * @f$\alpha@f$ and @f$\beta@f$. 2407 */ 2408 explicit 2409 gamma_distribution(_RealType __alpha_val = _RealType(1), 2410 _RealType __beta_val = _RealType(1)) 2411 : _M_param(__alpha_val, __beta_val), _M_nd() 2412 { } 2413 2414 explicit 2415 gamma_distribution(const param_type& __p) 2416 : _M_param(__p), _M_nd() 2417 { } 2418 2419 /** 2420 * @brief Resets the distribution state. 2421 */ 2422 void 2423 reset() 2424 { _M_nd.reset(); } 2425 2426 /** 2427 * @brief Returns the @f$\alpha@f$ of the distribution. 2428 */ 2429 _RealType 2430 alpha() const 2431 { return _M_param.alpha(); } 2432 2433 /** 2434 * @brief Returns the @f$\beta@f$ of the distribution. 2435 */ 2436 _RealType 2437 beta() const 2438 { return _M_param.beta(); } 2439 2440 /** 2441 * @brief Returns the parameter set of the distribution. 2442 */ 2443 param_type 2444 param() const 2445 { return _M_param; } 2446 2447 /** 2448 * @brief Sets the parameter set of the distribution. 2449 * @param __param The new parameter set of the distribution. 2450 */ 2451 void 2452 param(const param_type& __param) 2453 { _M_param = __param; } 2454 2455 /** 2456 * @brief Returns the greatest lower bound value of the distribution. 2457 */ 2458 result_type 2459 min() const 2460 { return result_type(0); } 2461 2462 /** 2463 * @brief Returns the least upper bound value of the distribution. 2464 */ 2465 result_type 2466 max() const 2467 { return std::numeric_limits<result_type>::max(); } 2468 2469 /** 2470 * @brief Generating functions. 2471 */ 2472 template<typename _UniformRandomNumberGenerator> 2473 result_type 2474 operator()(_UniformRandomNumberGenerator& __urng) 2475 { return this->operator()(__urng, _M_param); } 2476 2477 template<typename _UniformRandomNumberGenerator> 2478 result_type 2479 operator()(_UniformRandomNumberGenerator& __urng, 2480 const param_type& __p); 2481 2482 template<typename _ForwardIterator, 2483 typename _UniformRandomNumberGenerator> 2484 void 2485 __generate(_ForwardIterator __f, _ForwardIterator __t, 2486 _UniformRandomNumberGenerator& __urng) 2487 { this->__generate(__f, __t, __urng, _M_param); } 2488 2489 template<typename _ForwardIterator, 2490 typename _UniformRandomNumberGenerator> 2491 void 2492 __generate(_ForwardIterator __f, _ForwardIterator __t, 2493 _UniformRandomNumberGenerator& __urng, 2494 const param_type& __p) 2495 { this->__generate_impl(__f, __t, __urng, __p); } 2496 2497 template<typename _UniformRandomNumberGenerator> 2498 void 2499 __generate(result_type* __f, result_type* __t, 2500 _UniformRandomNumberGenerator& __urng, 2501 const param_type& __p) 2502 { this->__generate_impl(__f, __t, __urng, __p); } 2503 2504 /** 2505 * @brief Return true if two gamma distributions have the same 2506 * parameters and the sequences that would be generated 2507 * are equal. 2508 */ 2509 friend bool 2510 operator==(const gamma_distribution& __d1, 2511 const gamma_distribution& __d2) 2512 { return (__d1._M_param == __d2._M_param 2513 && __d1._M_nd == __d2._M_nd); } 2514 2515 /** 2516 * @brief Inserts a %gamma_distribution random number distribution 2517 * @p __x into the output stream @p __os. 2518 * 2519 * @param __os An output stream. 2520 * @param __x A %gamma_distribution random number distribution. 2521 * 2522 * @returns The output stream with the state of @p __x inserted or in 2523 * an error state. 2524 */ 2525 template<typename _RealType1, typename _CharT, typename _Traits> 2526 friend std::basic_ostream<_CharT, _Traits>& 2527 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 2528 const std::gamma_distribution<_RealType1>& __x); 2529 2530 /** 2531 * @brief Extracts a %gamma_distribution random number distribution 2532 * @p __x from the input stream @p __is. 2533 * 2534 * @param __is An input stream. 2535 * @param __x A %gamma_distribution random number generator engine. 2536 * 2537 * @returns The input stream with @p __x extracted or in an error state. 2538 */ 2539 template<typename _RealType1, typename _CharT, typename _Traits> 2540 friend std::basic_istream<_CharT, _Traits>& 2541 operator>>(std::basic_istream<_CharT, _Traits>& __is, 2542 std::gamma_distribution<_RealType1>& __x); 2543 2544 private: 2545 template<typename _ForwardIterator, 2546 typename _UniformRandomNumberGenerator> 2547 void 2548 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 2549 _UniformRandomNumberGenerator& __urng, 2550 const param_type& __p); 2551 2552 param_type _M_param; 2553 2554 std::normal_distribution<result_type> _M_nd; 2555 }; 2556 2557 /** 2558 * @brief Return true if two gamma distributions are different. 2559 */ 2560 template<typename _RealType> 2561 inline bool 2562 operator!=(const std::gamma_distribution<_RealType>& __d1, 2563 const std::gamma_distribution<_RealType>& __d2) 2564 { return !(__d1 == __d2); } 2565 2566 2567 /** 2568 * @brief A chi_squared_distribution random number distribution. 2569 * 2570 * The formula for the normal probability mass function is 2571 * @f$p(x|n) = \frac{x^{(n/2) - 1}e^{-x/2}}{\Gamma(n/2) 2^{n/2}}@f$ 2572 */ 2573 template<typename _RealType = double> 2574 class chi_squared_distribution 2575 { 2576 static_assert(std::is_floating_point<_RealType>::value, 2577 "result_type must be a floating point type"); 2578 2579 public: 2580 /** The type of the range of the distribution. */ 2581 typedef _RealType result_type; 2582 2583 /** Parameter type. */ 2584 struct param_type 2585 { 2586 typedef chi_squared_distribution<_RealType> distribution_type; 2587 2588 explicit 2589 param_type(_RealType __n = _RealType(1)) 2590 : _M_n(__n) 2591 { } 2592 2593 _RealType 2594 n() const 2595 { return _M_n; } 2596 2597 friend bool 2598 operator==(const param_type& __p1, const param_type& __p2) 2599 { return __p1._M_n == __p2._M_n; } 2600 2601 friend bool 2602 operator!=(const param_type& __p1, const param_type& __p2) 2603 { return !(__p1 == __p2); } 2604 2605 private: 2606 _RealType _M_n; 2607 }; 2608 2609 explicit 2610 chi_squared_distribution(_RealType __n = _RealType(1)) 2611 : _M_param(__n), _M_gd(__n / 2) 2612 { } 2613 2614 explicit 2615 chi_squared_distribution(const param_type& __p) 2616 : _M_param(__p), _M_gd(__p.n() / 2) 2617 { } 2618 2619 /** 2620 * @brief Resets the distribution state. 2621 */ 2622 void 2623 reset() 2624 { _M_gd.reset(); } 2625 2626 /** 2627 * 2628 */ 2629 _RealType 2630 n() const 2631 { return _M_param.n(); } 2632 2633 /** 2634 * @brief Returns the parameter set of the distribution. 2635 */ 2636 param_type 2637 param() const 2638 { return _M_param; } 2639 2640 /** 2641 * @brief Sets the parameter set of the distribution. 2642 * @param __param The new parameter set of the distribution. 2643 */ 2644 void 2645 param(const param_type& __param) 2646 { 2647 _M_param = __param; 2648 typedef typename std::gamma_distribution<result_type>::param_type 2649 param_type; 2650 _M_gd.param(param_type{__param.n() / 2}); 2651 } 2652 2653 /** 2654 * @brief Returns the greatest lower bound value of the distribution. 2655 */ 2656 result_type 2657 min() const 2658 { return result_type(0); } 2659 2660 /** 2661 * @brief Returns the least upper bound value of the distribution. 2662 */ 2663 result_type 2664 max() const 2665 { return std::numeric_limits<result_type>::max(); } 2666 2667 /** 2668 * @brief Generating functions. 2669 */ 2670 template<typename _UniformRandomNumberGenerator> 2671 result_type 2672 operator()(_UniformRandomNumberGenerator& __urng) 2673 { return 2 * _M_gd(__urng); } 2674 2675 template<typename _UniformRandomNumberGenerator> 2676 result_type 2677 operator()(_UniformRandomNumberGenerator& __urng, 2678 const param_type& __p) 2679 { 2680 typedef typename std::gamma_distribution<result_type>::param_type 2681 param_type; 2682 return 2 * _M_gd(__urng, param_type(__p.n() / 2)); 2683 } 2684 2685 template<typename _ForwardIterator, 2686 typename _UniformRandomNumberGenerator> 2687 void 2688 __generate(_ForwardIterator __f, _ForwardIterator __t, 2689 _UniformRandomNumberGenerator& __urng) 2690 { this->__generate_impl(__f, __t, __urng); } 2691 2692 template<typename _ForwardIterator, 2693 typename _UniformRandomNumberGenerator> 2694 void 2695 __generate(_ForwardIterator __f, _ForwardIterator __t, 2696 _UniformRandomNumberGenerator& __urng, 2697 const param_type& __p) 2698 { typename std::gamma_distribution<result_type>::param_type 2699 __p2(__p.n() / 2); 2700 this->__generate_impl(__f, __t, __urng, __p2); } 2701 2702 template<typename _UniformRandomNumberGenerator> 2703 void 2704 __generate(result_type* __f, result_type* __t, 2705 _UniformRandomNumberGenerator& __urng) 2706 { this->__generate_impl(__f, __t, __urng); } 2707 2708 template<typename _UniformRandomNumberGenerator> 2709 void 2710 __generate(result_type* __f, result_type* __t, 2711 _UniformRandomNumberGenerator& __urng, 2712 const param_type& __p) 2713 { typename std::gamma_distribution<result_type>::param_type 2714 __p2(__p.n() / 2); 2715 this->__generate_impl(__f, __t, __urng, __p2); } 2716 2717 /** 2718 * @brief Return true if two Chi-squared distributions have 2719 * the same parameters and the sequences that would be 2720 * generated are equal. 2721 */ 2722 friend bool 2723 operator==(const chi_squared_distribution& __d1, 2724 const chi_squared_distribution& __d2) 2725 { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; } 2726 2727 /** 2728 * @brief Inserts a %chi_squared_distribution random number distribution 2729 * @p __x into the output stream @p __os. 2730 * 2731 * @param __os An output stream. 2732 * @param __x A %chi_squared_distribution random number distribution. 2733 * 2734 * @returns The output stream with the state of @p __x inserted or in 2735 * an error state. 2736 */ 2737 template<typename _RealType1, typename _CharT, typename _Traits> 2738 friend std::basic_ostream<_CharT, _Traits>& 2739 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 2740 const std::chi_squared_distribution<_RealType1>& __x); 2741 2742 /** 2743 * @brief Extracts a %chi_squared_distribution random number distribution 2744 * @p __x from the input stream @p __is. 2745 * 2746 * @param __is An input stream. 2747 * @param __x A %chi_squared_distribution random number 2748 * generator engine. 2749 * 2750 * @returns The input stream with @p __x extracted or in an error state. 2751 */ 2752 template<typename _RealType1, typename _CharT, typename _Traits> 2753 friend std::basic_istream<_CharT, _Traits>& 2754 operator>>(std::basic_istream<_CharT, _Traits>& __is, 2755 std::chi_squared_distribution<_RealType1>& __x); 2756 2757 private: 2758 template<typename _ForwardIterator, 2759 typename _UniformRandomNumberGenerator> 2760 void 2761 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 2762 _UniformRandomNumberGenerator& __urng); 2763 2764 template<typename _ForwardIterator, 2765 typename _UniformRandomNumberGenerator> 2766 void 2767 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 2768 _UniformRandomNumberGenerator& __urng, 2769 const typename 2770 std::gamma_distribution<result_type>::param_type& __p); 2771 2772 param_type _M_param; 2773 2774 std::gamma_distribution<result_type> _M_gd; 2775 }; 2776 2777 /** 2778 * @brief Return true if two Chi-squared distributions are different. 2779 */ 2780 template<typename _RealType> 2781 inline bool 2782 operator!=(const std::chi_squared_distribution<_RealType>& __d1, 2783 const std::chi_squared_distribution<_RealType>& __d2) 2784 { return !(__d1 == __d2); } 2785 2786 2787 /** 2788 * @brief A cauchy_distribution random number distribution. 2789 * 2790 * The formula for the normal probability mass function is 2791 * @f$p(x|a,b) = (\pi b (1 + (\frac{x-a}{b})^2))^{-1}@f$ 2792 */ 2793 template<typename _RealType = double> 2794 class cauchy_distribution 2795 { 2796 static_assert(std::is_floating_point<_RealType>::value, 2797 "result_type must be a floating point type"); 2798 2799 public: 2800 /** The type of the range of the distribution. */ 2801 typedef _RealType result_type; 2802 2803 /** Parameter type. */ 2804 struct param_type 2805 { 2806 typedef cauchy_distribution<_RealType> distribution_type; 2807 2808 explicit 2809 param_type(_RealType __a = _RealType(0), 2810 _RealType __b = _RealType(1)) 2811 : _M_a(__a), _M_b(__b) 2812 { } 2813 2814 _RealType 2815 a() const 2816 { return _M_a; } 2817 2818 _RealType 2819 b() const 2820 { return _M_b; } 2821 2822 friend bool 2823 operator==(const param_type& __p1, const param_type& __p2) 2824 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } 2825 2826 friend bool 2827 operator!=(const param_type& __p1, const param_type& __p2) 2828 { return !(__p1 == __p2); } 2829 2830 private: 2831 _RealType _M_a; 2832 _RealType _M_b; 2833 }; 2834 2835 explicit 2836 cauchy_distribution(_RealType __a = _RealType(0), 2837 _RealType __b = _RealType(1)) 2838 : _M_param(__a, __b) 2839 { } 2840 2841 explicit 2842 cauchy_distribution(const param_type& __p) 2843 : _M_param(__p) 2844 { } 2845 2846 /** 2847 * @brief Resets the distribution state. 2848 */ 2849 void 2850 reset() 2851 { } 2852 2853 /** 2854 * 2855 */ 2856 _RealType 2857 a() const 2858 { return _M_param.a(); } 2859 2860 _RealType 2861 b() const 2862 { return _M_param.b(); } 2863 2864 /** 2865 * @brief Returns the parameter set of the distribution. 2866 */ 2867 param_type 2868 param() const 2869 { return _M_param; } 2870 2871 /** 2872 * @brief Sets the parameter set of the distribution. 2873 * @param __param The new parameter set of the distribution. 2874 */ 2875 void 2876 param(const param_type& __param) 2877 { _M_param = __param; } 2878 2879 /** 2880 * @brief Returns the greatest lower bound value of the distribution. 2881 */ 2882 result_type 2883 min() const 2884 { return std::numeric_limits<result_type>::lowest(); } 2885 2886 /** 2887 * @brief Returns the least upper bound value of the distribution. 2888 */ 2889 result_type 2890 max() const 2891 { return std::numeric_limits<result_type>::max(); } 2892 2893 /** 2894 * @brief Generating functions. 2895 */ 2896 template<typename _UniformRandomNumberGenerator> 2897 result_type 2898 operator()(_UniformRandomNumberGenerator& __urng) 2899 { return this->operator()(__urng, _M_param); } 2900 2901 template<typename _UniformRandomNumberGenerator> 2902 result_type 2903 operator()(_UniformRandomNumberGenerator& __urng, 2904 const param_type& __p); 2905 2906 template<typename _ForwardIterator, 2907 typename _UniformRandomNumberGenerator> 2908 void 2909 __generate(_ForwardIterator __f, _ForwardIterator __t, 2910 _UniformRandomNumberGenerator& __urng) 2911 { this->__generate(__f, __t, __urng, _M_param); } 2912 2913 template<typename _ForwardIterator, 2914 typename _UniformRandomNumberGenerator> 2915 void 2916 __generate(_ForwardIterator __f, _ForwardIterator __t, 2917 _UniformRandomNumberGenerator& __urng, 2918 const param_type& __p) 2919 { this->__generate_impl(__f, __t, __urng, __p); } 2920 2921 template<typename _UniformRandomNumberGenerator> 2922 void 2923 __generate(result_type* __f, result_type* __t, 2924 _UniformRandomNumberGenerator& __urng, 2925 const param_type& __p) 2926 { this->__generate_impl(__f, __t, __urng, __p); } 2927 2928 /** 2929 * @brief Return true if two Cauchy distributions have 2930 * the same parameters. 2931 */ 2932 friend bool 2933 operator==(const cauchy_distribution& __d1, 2934 const cauchy_distribution& __d2) 2935 { return __d1._M_param == __d2._M_param; } 2936 2937 private: 2938 template<typename _ForwardIterator, 2939 typename _UniformRandomNumberGenerator> 2940 void 2941 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 2942 _UniformRandomNumberGenerator& __urng, 2943 const param_type& __p); 2944 2945 param_type _M_param; 2946 }; 2947 2948 /** 2949 * @brief Return true if two Cauchy distributions have 2950 * different parameters. 2951 */ 2952 template<typename _RealType> 2953 inline bool 2954 operator!=(const std::cauchy_distribution<_RealType>& __d1, 2955 const std::cauchy_distribution<_RealType>& __d2) 2956 { return !(__d1 == __d2); } 2957 2958 /** 2959 * @brief Inserts a %cauchy_distribution random number distribution 2960 * @p __x into the output stream @p __os. 2961 * 2962 * @param __os An output stream. 2963 * @param __x A %cauchy_distribution random number distribution. 2964 * 2965 * @returns The output stream with the state of @p __x inserted or in 2966 * an error state. 2967 */ 2968 template<typename _RealType, typename _CharT, typename _Traits> 2969 std::basic_ostream<_CharT, _Traits>& 2970 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 2971 const std::cauchy_distribution<_RealType>& __x); 2972 2973 /** 2974 * @brief Extracts a %cauchy_distribution random number distribution 2975 * @p __x from the input stream @p __is. 2976 * 2977 * @param __is An input stream. 2978 * @param __x A %cauchy_distribution random number 2979 * generator engine. 2980 * 2981 * @returns The input stream with @p __x extracted or in an error state. 2982 */ 2983 template<typename _RealType, typename _CharT, typename _Traits> 2984 std::basic_istream<_CharT, _Traits>& 2985 operator>>(std::basic_istream<_CharT, _Traits>& __is, 2986 std::cauchy_distribution<_RealType>& __x); 2987 2988 2989 /** 2990 * @brief A fisher_f_distribution random number distribution. 2991 * 2992 * The formula for the normal probability mass function is 2993 * @f[ 2994 * p(x|m,n) = \frac{\Gamma((m+n)/2)}{\Gamma(m/2)\Gamma(n/2)} 2995 * (\frac{m}{n})^{m/2} x^{(m/2)-1} 2996 * (1 + \frac{mx}{n})^{-(m+n)/2} 2997 * @f] 2998 */ 2999 template<typename _RealType = double> 3000 class fisher_f_distribution 3001 { 3002 static_assert(std::is_floating_point<_RealType>::value, 3003 "result_type must be a floating point type"); 3004 3005 public: 3006 /** The type of the range of the distribution. */ 3007 typedef _RealType result_type; 3008 3009 /** Parameter type. */ 3010 struct param_type 3011 { 3012 typedef fisher_f_distribution<_RealType> distribution_type; 3013 3014 explicit 3015 param_type(_RealType __m = _RealType(1), 3016 _RealType __n = _RealType(1)) 3017 : _M_m(__m), _M_n(__n) 3018 { } 3019 3020 _RealType 3021 m() const 3022 { return _M_m; } 3023 3024 _RealType 3025 n() const 3026 { return _M_n; } 3027 3028 friend bool 3029 operator==(const param_type& __p1, const param_type& __p2) 3030 { return __p1._M_m == __p2._M_m && __p1._M_n == __p2._M_n; } 3031 3032 friend bool 3033 operator!=(const param_type& __p1, const param_type& __p2) 3034 { return !(__p1 == __p2); } 3035 3036 private: 3037 _RealType _M_m; 3038 _RealType _M_n; 3039 }; 3040 3041 explicit 3042 fisher_f_distribution(_RealType __m = _RealType(1), 3043 _RealType __n = _RealType(1)) 3044 : _M_param(__m, __n), _M_gd_x(__m / 2), _M_gd_y(__n / 2) 3045 { } 3046 3047 explicit 3048 fisher_f_distribution(const param_type& __p) 3049 : _M_param(__p), _M_gd_x(__p.m() / 2), _M_gd_y(__p.n() / 2) 3050 { } 3051 3052 /** 3053 * @brief Resets the distribution state. 3054 */ 3055 void 3056 reset() 3057 { 3058 _M_gd_x.reset(); 3059 _M_gd_y.reset(); 3060 } 3061 3062 /** 3063 * 3064 */ 3065 _RealType 3066 m() const 3067 { return _M_param.m(); } 3068 3069 _RealType 3070 n() const 3071 { return _M_param.n(); } 3072 3073 /** 3074 * @brief Returns the parameter set of the distribution. 3075 */ 3076 param_type 3077 param() const 3078 { return _M_param; } 3079 3080 /** 3081 * @brief Sets the parameter set of the distribution. 3082 * @param __param The new parameter set of the distribution. 3083 */ 3084 void 3085 param(const param_type& __param) 3086 { _M_param = __param; } 3087 3088 /** 3089 * @brief Returns the greatest lower bound value of the distribution. 3090 */ 3091 result_type 3092 min() const 3093 { return result_type(0); } 3094 3095 /** 3096 * @brief Returns the least upper bound value of the distribution. 3097 */ 3098 result_type 3099 max() const 3100 { return std::numeric_limits<result_type>::max(); } 3101 3102 /** 3103 * @brief Generating functions. 3104 */ 3105 template<typename _UniformRandomNumberGenerator> 3106 result_type 3107 operator()(_UniformRandomNumberGenerator& __urng) 3108 { return (_M_gd_x(__urng) * n()) / (_M_gd_y(__urng) * m()); } 3109 3110 template<typename _UniformRandomNumberGenerator> 3111 result_type 3112 operator()(_UniformRandomNumberGenerator& __urng, 3113 const param_type& __p) 3114 { 3115 typedef typename std::gamma_distribution<result_type>::param_type 3116 param_type; 3117 return ((_M_gd_x(__urng, param_type(__p.m() / 2)) * n()) 3118 / (_M_gd_y(__urng, param_type(__p.n() / 2)) * m())); 3119 } 3120 3121 template<typename _ForwardIterator, 3122 typename _UniformRandomNumberGenerator> 3123 void 3124 __generate(_ForwardIterator __f, _ForwardIterator __t, 3125 _UniformRandomNumberGenerator& __urng) 3126 { this->__generate_impl(__f, __t, __urng); } 3127 3128 template<typename _ForwardIterator, 3129 typename _UniformRandomNumberGenerator> 3130 void 3131 __generate(_ForwardIterator __f, _ForwardIterator __t, 3132 _UniformRandomNumberGenerator& __urng, 3133 const param_type& __p) 3134 { this->__generate_impl(__f, __t, __urng, __p); } 3135 3136 template<typename _UniformRandomNumberGenerator> 3137 void 3138 __generate(result_type* __f, result_type* __t, 3139 _UniformRandomNumberGenerator& __urng) 3140 { this->__generate_impl(__f, __t, __urng); } 3141 3142 template<typename _UniformRandomNumberGenerator> 3143 void 3144 __generate(result_type* __f, result_type* __t, 3145 _UniformRandomNumberGenerator& __urng, 3146 const param_type& __p) 3147 { this->__generate_impl(__f, __t, __urng, __p); } 3148 3149 /** 3150 * @brief Return true if two Fisher f distributions have 3151 * the same parameters and the sequences that would 3152 * be generated are equal. 3153 */ 3154 friend bool 3155 operator==(const fisher_f_distribution& __d1, 3156 const fisher_f_distribution& __d2) 3157 { return (__d1._M_param == __d2._M_param 3158 && __d1._M_gd_x == __d2._M_gd_x 3159 && __d1._M_gd_y == __d2._M_gd_y); } 3160 3161 /** 3162 * @brief Inserts a %fisher_f_distribution random number distribution 3163 * @p __x into the output stream @p __os. 3164 * 3165 * @param __os An output stream. 3166 * @param __x A %fisher_f_distribution random number distribution. 3167 * 3168 * @returns The output stream with the state of @p __x inserted or in 3169 * an error state. 3170 */ 3171 template<typename _RealType1, typename _CharT, typename _Traits> 3172 friend std::basic_ostream<_CharT, _Traits>& 3173 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 3174 const std::fisher_f_distribution<_RealType1>& __x); 3175 3176 /** 3177 * @brief Extracts a %fisher_f_distribution random number distribution 3178 * @p __x from the input stream @p __is. 3179 * 3180 * @param __is An input stream. 3181 * @param __x A %fisher_f_distribution random number 3182 * generator engine. 3183 * 3184 * @returns The input stream with @p __x extracted or in an error state. 3185 */ 3186 template<typename _RealType1, typename _CharT, typename _Traits> 3187 friend std::basic_istream<_CharT, _Traits>& 3188 operator>>(std::basic_istream<_CharT, _Traits>& __is, 3189 std::fisher_f_distribution<_RealType1>& __x); 3190 3191 private: 3192 template<typename _ForwardIterator, 3193 typename _UniformRandomNumberGenerator> 3194 void 3195 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 3196 _UniformRandomNumberGenerator& __urng); 3197 3198 template<typename _ForwardIterator, 3199 typename _UniformRandomNumberGenerator> 3200 void 3201 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 3202 _UniformRandomNumberGenerator& __urng, 3203 const param_type& __p); 3204 3205 param_type _M_param; 3206 3207 std::gamma_distribution<result_type> _M_gd_x, _M_gd_y; 3208 }; 3209 3210 /** 3211 * @brief Return true if two Fisher f distributions are different. 3212 */ 3213 template<typename _RealType> 3214 inline bool 3215 operator!=(const std::fisher_f_distribution<_RealType>& __d1, 3216 const std::fisher_f_distribution<_RealType>& __d2) 3217 { return !(__d1 == __d2); } 3218 3219 /** 3220 * @brief A student_t_distribution random number distribution. 3221 * 3222 * The formula for the normal probability mass function is: 3223 * @f[ 3224 * p(x|n) = \frac{1}{\sqrt(n\pi)} \frac{\Gamma((n+1)/2)}{\Gamma(n/2)} 3225 * (1 + \frac{x^2}{n}) ^{-(n+1)/2} 3226 * @f] 3227 */ 3228 template<typename _RealType = double> 3229 class student_t_distribution 3230 { 3231 static_assert(std::is_floating_point<_RealType>::value, 3232 "result_type must be a floating point type"); 3233 3234 public: 3235 /** The type of the range of the distribution. */ 3236 typedef _RealType result_type; 3237 3238 /** Parameter type. */ 3239 struct param_type 3240 { 3241 typedef student_t_distribution<_RealType> distribution_type; 3242 3243 explicit 3244 param_type(_RealType __n = _RealType(1)) 3245 : _M_n(__n) 3246 { } 3247 3248 _RealType 3249 n() const 3250 { return _M_n; } 3251 3252 friend bool 3253 operator==(const param_type& __p1, const param_type& __p2) 3254 { return __p1._M_n == __p2._M_n; } 3255 3256 friend bool 3257 operator!=(const param_type& __p1, const param_type& __p2) 3258 { return !(__p1 == __p2); } 3259 3260 private: 3261 _RealType _M_n; 3262 }; 3263 3264 explicit 3265 student_t_distribution(_RealType __n = _RealType(1)) 3266 : _M_param(__n), _M_nd(), _M_gd(__n / 2, 2) 3267 { } 3268 3269 explicit 3270 student_t_distribution(const param_type& __p) 3271 : _M_param(__p), _M_nd(), _M_gd(__p.n() / 2, 2) 3272 { } 3273 3274 /** 3275 * @brief Resets the distribution state. 3276 */ 3277 void 3278 reset() 3279 { 3280 _M_nd.reset(); 3281 _M_gd.reset(); 3282 } 3283 3284 /** 3285 * 3286 */ 3287 _RealType 3288 n() const 3289 { return _M_param.n(); } 3290 3291 /** 3292 * @brief Returns the parameter set of the distribution. 3293 */ 3294 param_type 3295 param() const 3296 { return _M_param; } 3297 3298 /** 3299 * @brief Sets the parameter set of the distribution. 3300 * @param __param The new parameter set of the distribution. 3301 */ 3302 void 3303 param(const param_type& __param) 3304 { _M_param = __param; } 3305 3306 /** 3307 * @brief Returns the greatest lower bound value of the distribution. 3308 */ 3309 result_type 3310 min() const 3311 { return std::numeric_limits<result_type>::lowest(); } 3312 3313 /** 3314 * @brief Returns the least upper bound value of the distribution. 3315 */ 3316 result_type 3317 max() const 3318 { return std::numeric_limits<result_type>::max(); } 3319 3320 /** 3321 * @brief Generating functions. 3322 */ 3323 template<typename _UniformRandomNumberGenerator> 3324 result_type 3325 operator()(_UniformRandomNumberGenerator& __urng) 3326 { return _M_nd(__urng) * std::sqrt(n() / _M_gd(__urng)); } 3327 3328 template<typename _UniformRandomNumberGenerator> 3329 result_type 3330 operator()(_UniformRandomNumberGenerator& __urng, 3331 const param_type& __p) 3332 { 3333 typedef typename std::gamma_distribution<result_type>::param_type 3334 param_type; 3335 3336 const result_type __g = _M_gd(__urng, param_type(__p.n() / 2, 2)); 3337 return _M_nd(__urng) * std::sqrt(__p.n() / __g); 3338 } 3339 3340 template<typename _ForwardIterator, 3341 typename _UniformRandomNumberGenerator> 3342 void 3343 __generate(_ForwardIterator __f, _ForwardIterator __t, 3344 _UniformRandomNumberGenerator& __urng) 3345 { this->__generate_impl(__f, __t, __urng); } 3346 3347 template<typename _ForwardIterator, 3348 typename _UniformRandomNumberGenerator> 3349 void 3350 __generate(_ForwardIterator __f, _ForwardIterator __t, 3351 _UniformRandomNumberGenerator& __urng, 3352 const param_type& __p) 3353 { this->__generate_impl(__f, __t, __urng, __p); } 3354 3355 template<typename _UniformRandomNumberGenerator> 3356 void 3357 __generate(result_type* __f, result_type* __t, 3358 _UniformRandomNumberGenerator& __urng) 3359 { this->__generate_impl(__f, __t, __urng); } 3360 3361 template<typename _UniformRandomNumberGenerator> 3362 void 3363 __generate(result_type* __f, result_type* __t, 3364 _UniformRandomNumberGenerator& __urng, 3365 const param_type& __p) 3366 { this->__generate_impl(__f, __t, __urng, __p); } 3367 3368 /** 3369 * @brief Return true if two Student t distributions have 3370 * the same parameters and the sequences that would 3371 * be generated are equal. 3372 */ 3373 friend bool 3374 operator==(const student_t_distribution& __d1, 3375 const student_t_distribution& __d2) 3376 { return (__d1._M_param == __d2._M_param 3377 && __d1._M_nd == __d2._M_nd && __d1._M_gd == __d2._M_gd); } 3378 3379 /** 3380 * @brief Inserts a %student_t_distribution random number distribution 3381 * @p __x into the output stream @p __os. 3382 * 3383 * @param __os An output stream. 3384 * @param __x A %student_t_distribution random number distribution. 3385 * 3386 * @returns The output stream with the state of @p __x inserted or in 3387 * an error state. 3388 */ 3389 template<typename _RealType1, typename _CharT, typename _Traits> 3390 friend std::basic_ostream<_CharT, _Traits>& 3391 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 3392 const std::student_t_distribution<_RealType1>& __x); 3393 3394 /** 3395 * @brief Extracts a %student_t_distribution random number distribution 3396 * @p __x from the input stream @p __is. 3397 * 3398 * @param __is An input stream. 3399 * @param __x A %student_t_distribution random number 3400 * generator engine. 3401 * 3402 * @returns The input stream with @p __x extracted or in an error state. 3403 */ 3404 template<typename _RealType1, typename _CharT, typename _Traits> 3405 friend std::basic_istream<_CharT, _Traits>& 3406 operator>>(std::basic_istream<_CharT, _Traits>& __is, 3407 std::student_t_distribution<_RealType1>& __x); 3408 3409 private: 3410 template<typename _ForwardIterator, 3411 typename _UniformRandomNumberGenerator> 3412 void 3413 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 3414 _UniformRandomNumberGenerator& __urng); 3415 template<typename _ForwardIterator, 3416 typename _UniformRandomNumberGenerator> 3417 void 3418 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 3419 _UniformRandomNumberGenerator& __urng, 3420 const param_type& __p); 3421 3422 param_type _M_param; 3423 3424 std::normal_distribution<result_type> _M_nd; 3425 std::gamma_distribution<result_type> _M_gd; 3426 }; 3427 3428 /** 3429 * @brief Return true if two Student t distributions are different. 3430 */ 3431 template<typename _RealType> 3432 inline bool 3433 operator!=(const std::student_t_distribution<_RealType>& __d1, 3434 const std::student_t_distribution<_RealType>& __d2) 3435 { return !(__d1 == __d2); } 3436 3437 3438 /* @} */ // group random_distributions_normal 3439 3440 /** 3441 * @addtogroup random_distributions_bernoulli Bernoulli Distributions 3442 * @ingroup random_distributions 3443 * @{ 3444 */ 3445 3446 /** 3447 * @brief A Bernoulli random number distribution. 3448 * 3449 * Generates a sequence of true and false values with likelihood @f$p@f$ 3450 * that true will come up and @f$(1 - p)@f$ that false will appear. 3451 */ 3452 class bernoulli_distribution 3453 { 3454 public: 3455 /** The type of the range of the distribution. */ 3456 typedef bool result_type; 3457 3458 /** Parameter type. */ 3459 struct param_type 3460 { 3461 typedef bernoulli_distribution distribution_type; 3462 3463 explicit 3464 param_type(double __p = 0.5) 3465 : _M_p(__p) 3466 { 3467 __glibcxx_assert((_M_p >= 0.0) && (_M_p <= 1.0)); 3468 } 3469 3470 double 3471 p() const 3472 { return _M_p; } 3473 3474 friend bool 3475 operator==(const param_type& __p1, const param_type& __p2) 3476 { return __p1._M_p == __p2._M_p; } 3477 3478 friend bool 3479 operator!=(const param_type& __p1, const param_type& __p2) 3480 { return !(__p1 == __p2); } 3481 3482 private: 3483 double _M_p; 3484 }; 3485 3486 public: 3487 /** 3488 * @brief Constructs a Bernoulli distribution with likelihood @p p. 3489 * 3490 * @param __p [IN] The likelihood of a true result being returned. 3491 * Must be in the interval @f$[0, 1]@f$. 3492 */ 3493 explicit 3494 bernoulli_distribution(double __p = 0.5) 3495 : _M_param(__p) 3496 { } 3497 3498 explicit 3499 bernoulli_distribution(const param_type& __p) 3500 : _M_param(__p) 3501 { } 3502 3503 /** 3504 * @brief Resets the distribution state. 3505 * 3506 * Does nothing for a Bernoulli distribution. 3507 */ 3508 void 3509 reset() { } 3510 3511 /** 3512 * @brief Returns the @p p parameter of the distribution. 3513 */ 3514 double 3515 p() const 3516 { return _M_param.p(); } 3517 3518 /** 3519 * @brief Returns the parameter set of the distribution. 3520 */ 3521 param_type 3522 param() const 3523 { return _M_param; } 3524 3525 /** 3526 * @brief Sets the parameter set of the distribution. 3527 * @param __param The new parameter set of the distribution. 3528 */ 3529 void 3530 param(const param_type& __param) 3531 { _M_param = __param; } 3532 3533 /** 3534 * @brief Returns the greatest lower bound value of the distribution. 3535 */ 3536 result_type 3537 min() const 3538 { return std::numeric_limits<result_type>::min(); } 3539 3540 /** 3541 * @brief Returns the least upper bound value of the distribution. 3542 */ 3543 result_type 3544 max() const 3545 { return std::numeric_limits<result_type>::max(); } 3546 3547 /** 3548 * @brief Generating functions. 3549 */ 3550 template<typename _UniformRandomNumberGenerator> 3551 result_type 3552 operator()(_UniformRandomNumberGenerator& __urng) 3553 { return this->operator()(__urng, _M_param); } 3554 3555 template<typename _UniformRandomNumberGenerator> 3556 result_type 3557 operator()(_UniformRandomNumberGenerator& __urng, 3558 const param_type& __p) 3559 { 3560 __detail::_Adaptor<_UniformRandomNumberGenerator, double> 3561 __aurng(__urng); 3562 if ((__aurng() - __aurng.min()) 3563 < __p.p() * (__aurng.max() - __aurng.min())) 3564 return true; 3565 return false; 3566 } 3567 3568 template<typename _ForwardIterator, 3569 typename _UniformRandomNumberGenerator> 3570 void 3571 __generate(_ForwardIterator __f, _ForwardIterator __t, 3572 _UniformRandomNumberGenerator& __urng) 3573 { this->__generate(__f, __t, __urng, _M_param); } 3574 3575 template<typename _ForwardIterator, 3576 typename _UniformRandomNumberGenerator> 3577 void 3578 __generate(_ForwardIterator __f, _ForwardIterator __t, 3579 _UniformRandomNumberGenerator& __urng, const param_type& __p) 3580 { this->__generate_impl(__f, __t, __urng, __p); } 3581 3582 template<typename _UniformRandomNumberGenerator> 3583 void 3584 __generate(result_type* __f, result_type* __t, 3585 _UniformRandomNumberGenerator& __urng, 3586 const param_type& __p) 3587 { this->__generate_impl(__f, __t, __urng, __p); } 3588 3589 /** 3590 * @brief Return true if two Bernoulli distributions have 3591 * the same parameters. 3592 */ 3593 friend bool 3594 operator==(const bernoulli_distribution& __d1, 3595 const bernoulli_distribution& __d2) 3596 { return __d1._M_param == __d2._M_param; } 3597 3598 private: 3599 template<typename _ForwardIterator, 3600 typename _UniformRandomNumberGenerator> 3601 void 3602 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 3603 _UniformRandomNumberGenerator& __urng, 3604 const param_type& __p); 3605 3606 param_type _M_param; 3607 }; 3608 3609 /** 3610 * @brief Return true if two Bernoulli distributions have 3611 * different parameters. 3612 */ 3613 inline bool 3614 operator!=(const std::bernoulli_distribution& __d1, 3615 const std::bernoulli_distribution& __d2) 3616 { return !(__d1 == __d2); } 3617 3618 /** 3619 * @brief Inserts a %bernoulli_distribution random number distribution 3620 * @p __x into the output stream @p __os. 3621 * 3622 * @param __os An output stream. 3623 * @param __x A %bernoulli_distribution random number distribution. 3624 * 3625 * @returns The output stream with the state of @p __x inserted or in 3626 * an error state. 3627 */ 3628 template<typename _CharT, typename _Traits> 3629 std::basic_ostream<_CharT, _Traits>& 3630 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 3631 const std::bernoulli_distribution& __x); 3632 3633 /** 3634 * @brief Extracts a %bernoulli_distribution random number distribution 3635 * @p __x from the input stream @p __is. 3636 * 3637 * @param __is An input stream. 3638 * @param __x A %bernoulli_distribution random number generator engine. 3639 * 3640 * @returns The input stream with @p __x extracted or in an error state. 3641 */ 3642 template<typename _CharT, typename _Traits> 3643 std::basic_istream<_CharT, _Traits>& 3644 operator>>(std::basic_istream<_CharT, _Traits>& __is, 3645 std::bernoulli_distribution& __x) 3646 { 3647 double __p; 3648 __is >> __p; 3649 __x.param(bernoulli_distribution::param_type(__p)); 3650 return __is; 3651 } 3652 3653 3654 /** 3655 * @brief A discrete binomial random number distribution. 3656 * 3657 * The formula for the binomial probability density function is 3658 * @f$p(i|t,p) = \binom{t}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$ 3659 * and @f$p@f$ are the parameters of the distribution. 3660 */ 3661 template<typename _IntType = int> 3662 class binomial_distribution 3663 { 3664 static_assert(std::is_integral<_IntType>::value, 3665 "result_type must be an integral type"); 3666 3667 public: 3668 /** The type of the range of the distribution. */ 3669 typedef _IntType result_type; 3670 3671 /** Parameter type. */ 3672 struct param_type 3673 { 3674 typedef binomial_distribution<_IntType> distribution_type; 3675 friend class binomial_distribution<_IntType>; 3676 3677 explicit 3678 param_type(_IntType __t = _IntType(1), double __p = 0.5) 3679 : _M_t(__t), _M_p(__p) 3680 { 3681 __glibcxx_assert((_M_t >= _IntType(0)) 3682 && (_M_p >= 0.0) 3683 && (_M_p <= 1.0)); 3684 _M_initialize(); 3685 } 3686 3687 _IntType 3688 t() const 3689 { return _M_t; } 3690 3691 double 3692 p() const 3693 { return _M_p; } 3694 3695 friend bool 3696 operator==(const param_type& __p1, const param_type& __p2) 3697 { return __p1._M_t == __p2._M_t && __p1._M_p == __p2._M_p; } 3698 3699 friend bool 3700 operator!=(const param_type& __p1, const param_type& __p2) 3701 { return !(__p1 == __p2); } 3702 3703 private: 3704 void 3705 _M_initialize(); 3706 3707 _IntType _M_t; 3708 double _M_p; 3709 3710 double _M_q; 3711 #if _GLIBCXX_USE_C99_MATH_TR1 3712 double _M_d1, _M_d2, _M_s1, _M_s2, _M_c, 3713 _M_a1, _M_a123, _M_s, _M_lf, _M_lp1p; 3714 #endif 3715 bool _M_easy; 3716 }; 3717 3718 // constructors and member function 3719 explicit 3720 binomial_distribution(_IntType __t = _IntType(1), 3721 double __p = 0.5) 3722 : _M_param(__t, __p), _M_nd() 3723 { } 3724 3725 explicit 3726 binomial_distribution(const param_type& __p) 3727 : _M_param(__p), _M_nd() 3728 { } 3729 3730 /** 3731 * @brief Resets the distribution state. 3732 */ 3733 void 3734 reset() 3735 { _M_nd.reset(); } 3736 3737 /** 3738 * @brief Returns the distribution @p t parameter. 3739 */ 3740 _IntType 3741 t() const 3742 { return _M_param.t(); } 3743 3744 /** 3745 * @brief Returns the distribution @p p parameter. 3746 */ 3747 double 3748 p() const 3749 { return _M_param.p(); } 3750 3751 /** 3752 * @brief Returns the parameter set of the distribution. 3753 */ 3754 param_type 3755 param() const 3756 { return _M_param; } 3757 3758 /** 3759 * @brief Sets the parameter set of the distribution. 3760 * @param __param The new parameter set of the distribution. 3761 */ 3762 void 3763 param(const param_type& __param) 3764 { _M_param = __param; } 3765 3766 /** 3767 * @brief Returns the greatest lower bound value of the distribution. 3768 */ 3769 result_type 3770 min() const 3771 { return 0; } 3772 3773 /** 3774 * @brief Returns the least upper bound value of the distribution. 3775 */ 3776 result_type 3777 max() const 3778 { return _M_param.t(); } 3779 3780 /** 3781 * @brief Generating functions. 3782 */ 3783 template<typename _UniformRandomNumberGenerator> 3784 result_type 3785 operator()(_UniformRandomNumberGenerator& __urng) 3786 { return this->operator()(__urng, _M_param); } 3787 3788 template<typename _UniformRandomNumberGenerator> 3789 result_type 3790 operator()(_UniformRandomNumberGenerator& __urng, 3791 const param_type& __p); 3792 3793 template<typename _ForwardIterator, 3794 typename _UniformRandomNumberGenerator> 3795 void 3796 __generate(_ForwardIterator __f, _ForwardIterator __t, 3797 _UniformRandomNumberGenerator& __urng) 3798 { this->__generate(__f, __t, __urng, _M_param); } 3799 3800 template<typename _ForwardIterator, 3801 typename _UniformRandomNumberGenerator> 3802 void 3803 __generate(_ForwardIterator __f, _ForwardIterator __t, 3804 _UniformRandomNumberGenerator& __urng, 3805 const param_type& __p) 3806 { this->__generate_impl(__f, __t, __urng, __p); } 3807 3808 template<typename _UniformRandomNumberGenerator> 3809 void 3810 __generate(result_type* __f, result_type* __t, 3811 _UniformRandomNumberGenerator& __urng, 3812 const param_type& __p) 3813 { this->__generate_impl(__f, __t, __urng, __p); } 3814 3815 /** 3816 * @brief Return true if two binomial distributions have 3817 * the same parameters and the sequences that would 3818 * be generated are equal. 3819 */ 3820 friend bool 3821 operator==(const binomial_distribution& __d1, 3822 const binomial_distribution& __d2) 3823 #ifdef _GLIBCXX_USE_C99_MATH_TR1 3824 { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; } 3825 #else 3826 { return __d1._M_param == __d2._M_param; } 3827 #endif 3828 3829 /** 3830 * @brief Inserts a %binomial_distribution random number distribution 3831 * @p __x into the output stream @p __os. 3832 * 3833 * @param __os An output stream. 3834 * @param __x A %binomial_distribution random number distribution. 3835 * 3836 * @returns The output stream with the state of @p __x inserted or in 3837 * an error state. 3838 */ 3839 template<typename _IntType1, 3840 typename _CharT, typename _Traits> 3841 friend std::basic_ostream<_CharT, _Traits>& 3842 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 3843 const std::binomial_distribution<_IntType1>& __x); 3844 3845 /** 3846 * @brief Extracts a %binomial_distribution random number distribution 3847 * @p __x from the input stream @p __is. 3848 * 3849 * @param __is An input stream. 3850 * @param __x A %binomial_distribution random number generator engine. 3851 * 3852 * @returns The input stream with @p __x extracted or in an error 3853 * state. 3854 */ 3855 template<typename _IntType1, 3856 typename _CharT, typename _Traits> 3857 friend std::basic_istream<_CharT, _Traits>& 3858 operator>>(std::basic_istream<_CharT, _Traits>& __is, 3859 std::binomial_distribution<_IntType1>& __x); 3860 3861 private: 3862 template<typename _ForwardIterator, 3863 typename _UniformRandomNumberGenerator> 3864 void 3865 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 3866 _UniformRandomNumberGenerator& __urng, 3867 const param_type& __p); 3868 3869 template<typename _UniformRandomNumberGenerator> 3870 result_type 3871 _M_waiting(_UniformRandomNumberGenerator& __urng, 3872 _IntType __t, double __q); 3873 3874 param_type _M_param; 3875 3876 // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined. 3877 std::normal_distribution<double> _M_nd; 3878 }; 3879 3880 /** 3881 * @brief Return true if two binomial distributions are different. 3882 */ 3883 template<typename _IntType> 3884 inline bool 3885 operator!=(const std::binomial_distribution<_IntType>& __d1, 3886 const std::binomial_distribution<_IntType>& __d2) 3887 { return !(__d1 == __d2); } 3888 3889 3890 /** 3891 * @brief A discrete geometric random number distribution. 3892 * 3893 * The formula for the geometric probability density function is 3894 * @f$p(i|p) = p(1 - p)^{i}@f$ where @f$p@f$ is the parameter of the 3895 * distribution. 3896 */ 3897 template<typename _IntType = int> 3898 class geometric_distribution 3899 { 3900 static_assert(std::is_integral<_IntType>::value, 3901 "result_type must be an integral type"); 3902 3903 public: 3904 /** The type of the range of the distribution. */ 3905 typedef _IntType result_type; 3906 3907 /** Parameter type. */ 3908 struct param_type 3909 { 3910 typedef geometric_distribution<_IntType> distribution_type; 3911 friend class geometric_distribution<_IntType>; 3912 3913 explicit 3914 param_type(double __p = 0.5) 3915 : _M_p(__p) 3916 { 3917 __glibcxx_assert((_M_p > 0.0) && (_M_p < 1.0)); 3918 _M_initialize(); 3919 } 3920 3921 double 3922 p() const 3923 { return _M_p; } 3924 3925 friend bool 3926 operator==(const param_type& __p1, const param_type& __p2) 3927 { return __p1._M_p == __p2._M_p; } 3928 3929 friend bool 3930 operator!=(const param_type& __p1, const param_type& __p2) 3931 { return !(__p1 == __p2); } 3932 3933 private: 3934 void 3935 _M_initialize() 3936 { _M_log_1_p = std::log(1.0 - _M_p); } 3937 3938 double _M_p; 3939 3940 double _M_log_1_p; 3941 }; 3942 3943 // constructors and member function 3944 explicit 3945 geometric_distribution(double __p = 0.5) 3946 : _M_param(__p) 3947 { } 3948 3949 explicit 3950 geometric_distribution(const param_type& __p) 3951 : _M_param(__p) 3952 { } 3953 3954 /** 3955 * @brief Resets the distribution state. 3956 * 3957 * Does nothing for the geometric distribution. 3958 */ 3959 void 3960 reset() { } 3961 3962 /** 3963 * @brief Returns the distribution parameter @p p. 3964 */ 3965 double 3966 p() const 3967 { return _M_param.p(); } 3968 3969 /** 3970 * @brief Returns the parameter set of the distribution. 3971 */ 3972 param_type 3973 param() const 3974 { return _M_param; } 3975 3976 /** 3977 * @brief Sets the parameter set of the distribution. 3978 * @param __param The new parameter set of the distribution. 3979 */ 3980 void 3981 param(const param_type& __param) 3982 { _M_param = __param; } 3983 3984 /** 3985 * @brief Returns the greatest lower bound value of the distribution. 3986 */ 3987 result_type 3988 min() const 3989 { return 0; } 3990 3991 /** 3992 * @brief Returns the least upper bound value of the distribution. 3993 */ 3994 result_type 3995 max() const 3996 { return std::numeric_limits<result_type>::max(); } 3997 3998 /** 3999 * @brief Generating functions. 4000 */ 4001 template<typename _UniformRandomNumberGenerator> 4002 result_type 4003 operator()(_UniformRandomNumberGenerator& __urng) 4004 { return this->operator()(__urng, _M_param); } 4005 4006 template<typename _UniformRandomNumberGenerator> 4007 result_type 4008 operator()(_UniformRandomNumberGenerator& __urng, 4009 const param_type& __p); 4010 4011 template<typename _ForwardIterator, 4012 typename _UniformRandomNumberGenerator> 4013 void 4014 __generate(_ForwardIterator __f, _ForwardIterator __t, 4015 _UniformRandomNumberGenerator& __urng) 4016 { this->__generate(__f, __t, __urng, _M_param); } 4017 4018 template<typename _ForwardIterator, 4019 typename _UniformRandomNumberGenerator> 4020 void 4021 __generate(_ForwardIterator __f, _ForwardIterator __t, 4022 _UniformRandomNumberGenerator& __urng, 4023 const param_type& __p) 4024 { this->__generate_impl(__f, __t, __urng, __p); } 4025 4026 template<typename _UniformRandomNumberGenerator> 4027 void 4028 __generate(result_type* __f, result_type* __t, 4029 _UniformRandomNumberGenerator& __urng, 4030 const param_type& __p) 4031 { this->__generate_impl(__f, __t, __urng, __p); } 4032 4033 /** 4034 * @brief Return true if two geometric distributions have 4035 * the same parameters. 4036 */ 4037 friend bool 4038 operator==(const geometric_distribution& __d1, 4039 const geometric_distribution& __d2) 4040 { return __d1._M_param == __d2._M_param; } 4041 4042 private: 4043 template<typename _ForwardIterator, 4044 typename _UniformRandomNumberGenerator> 4045 void 4046 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 4047 _UniformRandomNumberGenerator& __urng, 4048 const param_type& __p); 4049 4050 param_type _M_param; 4051 }; 4052 4053 /** 4054 * @brief Return true if two geometric distributions have 4055 * different parameters. 4056 */ 4057 template<typename _IntType> 4058 inline bool 4059 operator!=(const std::geometric_distribution<_IntType>& __d1, 4060 const std::geometric_distribution<_IntType>& __d2) 4061 { return !(__d1 == __d2); } 4062 4063 /** 4064 * @brief Inserts a %geometric_distribution random number distribution 4065 * @p __x into the output stream @p __os. 4066 * 4067 * @param __os An output stream. 4068 * @param __x A %geometric_distribution random number distribution. 4069 * 4070 * @returns The output stream with the state of @p __x inserted or in 4071 * an error state. 4072 */ 4073 template<typename _IntType, 4074 typename _CharT, typename _Traits> 4075 std::basic_ostream<_CharT, _Traits>& 4076 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 4077 const std::geometric_distribution<_IntType>& __x); 4078 4079 /** 4080 * @brief Extracts a %geometric_distribution random number distribution 4081 * @p __x from the input stream @p __is. 4082 * 4083 * @param __is An input stream. 4084 * @param __x A %geometric_distribution random number generator engine. 4085 * 4086 * @returns The input stream with @p __x extracted or in an error state. 4087 */ 4088 template<typename _IntType, 4089 typename _CharT, typename _Traits> 4090 std::basic_istream<_CharT, _Traits>& 4091 operator>>(std::basic_istream<_CharT, _Traits>& __is, 4092 std::geometric_distribution<_IntType>& __x); 4093 4094 4095 /** 4096 * @brief A negative_binomial_distribution random number distribution. 4097 * 4098 * The formula for the negative binomial probability mass function is 4099 * @f$p(i) = \binom{n}{i} p^i (1 - p)^{t - i}@f$ where @f$t@f$ 4100 * and @f$p@f$ are the parameters of the distribution. 4101 */ 4102 template<typename _IntType = int> 4103 class negative_binomial_distribution 4104 { 4105 static_assert(std::is_integral<_IntType>::value, 4106 "result_type must be an integral type"); 4107 4108 public: 4109 /** The type of the range of the distribution. */ 4110 typedef _IntType result_type; 4111 4112 /** Parameter type. */ 4113 struct param_type 4114 { 4115 typedef negative_binomial_distribution<_IntType> distribution_type; 4116 4117 explicit 4118 param_type(_IntType __k = 1, double __p = 0.5) 4119 : _M_k(__k), _M_p(__p) 4120 { 4121 __glibcxx_assert((_M_k > 0) && (_M_p > 0.0) && (_M_p <= 1.0)); 4122 } 4123 4124 _IntType 4125 k() const 4126 { return _M_k; } 4127 4128 double 4129 p() const 4130 { return _M_p; } 4131 4132 friend bool 4133 operator==(const param_type& __p1, const param_type& __p2) 4134 { return __p1._M_k == __p2._M_k && __p1._M_p == __p2._M_p; } 4135 4136 friend bool 4137 operator!=(const param_type& __p1, const param_type& __p2) 4138 { return !(__p1 == __p2); } 4139 4140 private: 4141 _IntType _M_k; 4142 double _M_p; 4143 }; 4144 4145 explicit 4146 negative_binomial_distribution(_IntType __k = 1, double __p = 0.5) 4147 : _M_param(__k, __p), _M_gd(__k, (1.0 - __p) / __p) 4148 { } 4149 4150 explicit 4151 negative_binomial_distribution(const param_type& __p) 4152 : _M_param(__p), _M_gd(__p.k(), (1.0 - __p.p()) / __p.p()) 4153 { } 4154 4155 /** 4156 * @brief Resets the distribution state. 4157 */ 4158 void 4159 reset() 4160 { _M_gd.reset(); } 4161 4162 /** 4163 * @brief Return the @f$k@f$ parameter of the distribution. 4164 */ 4165 _IntType 4166 k() const 4167 { return _M_param.k(); } 4168 4169 /** 4170 * @brief Return the @f$p@f$ parameter of the distribution. 4171 */ 4172 double 4173 p() const 4174 { return _M_param.p(); } 4175 4176 /** 4177 * @brief Returns the parameter set of the distribution. 4178 */ 4179 param_type 4180 param() const 4181 { return _M_param; } 4182 4183 /** 4184 * @brief Sets the parameter set of the distribution. 4185 * @param __param The new parameter set of the distribution. 4186 */ 4187 void 4188 param(const param_type& __param) 4189 { _M_param = __param; } 4190 4191 /** 4192 * @brief Returns the greatest lower bound value of the distribution. 4193 */ 4194 result_type 4195 min() const 4196 { return result_type(0); } 4197 4198 /** 4199 * @brief Returns the least upper bound value of the distribution. 4200 */ 4201 result_type 4202 max() const 4203 { return std::numeric_limits<result_type>::max(); } 4204 4205 /** 4206 * @brief Generating functions. 4207 */ 4208 template<typename _UniformRandomNumberGenerator> 4209 result_type 4210 operator()(_UniformRandomNumberGenerator& __urng); 4211 4212 template<typename _UniformRandomNumberGenerator> 4213 result_type 4214 operator()(_UniformRandomNumberGenerator& __urng, 4215 const param_type& __p); 4216 4217 template<typename _ForwardIterator, 4218 typename _UniformRandomNumberGenerator> 4219 void 4220 __generate(_ForwardIterator __f, _ForwardIterator __t, 4221 _UniformRandomNumberGenerator& __urng) 4222 { this->__generate_impl(__f, __t, __urng); } 4223 4224 template<typename _ForwardIterator, 4225 typename _UniformRandomNumberGenerator> 4226 void 4227 __generate(_ForwardIterator __f, _ForwardIterator __t, 4228 _UniformRandomNumberGenerator& __urng, 4229 const param_type& __p) 4230 { this->__generate_impl(__f, __t, __urng, __p); } 4231 4232 template<typename _UniformRandomNumberGenerator> 4233 void 4234 __generate(result_type* __f, result_type* __t, 4235 _UniformRandomNumberGenerator& __urng) 4236 { this->__generate_impl(__f, __t, __urng); } 4237 4238 template<typename _UniformRandomNumberGenerator> 4239 void 4240 __generate(result_type* __f, result_type* __t, 4241 _UniformRandomNumberGenerator& __urng, 4242 const param_type& __p) 4243 { this->__generate_impl(__f, __t, __urng, __p); } 4244 4245 /** 4246 * @brief Return true if two negative binomial distributions have 4247 * the same parameters and the sequences that would be 4248 * generated are equal. 4249 */ 4250 friend bool 4251 operator==(const negative_binomial_distribution& __d1, 4252 const negative_binomial_distribution& __d2) 4253 { return __d1._M_param == __d2._M_param && __d1._M_gd == __d2._M_gd; } 4254 4255 /** 4256 * @brief Inserts a %negative_binomial_distribution random 4257 * number distribution @p __x into the output stream @p __os. 4258 * 4259 * @param __os An output stream. 4260 * @param __x A %negative_binomial_distribution random number 4261 * distribution. 4262 * 4263 * @returns The output stream with the state of @p __x inserted or in 4264 * an error state. 4265 */ 4266 template<typename _IntType1, typename _CharT, typename _Traits> 4267 friend std::basic_ostream<_CharT, _Traits>& 4268 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 4269 const std::negative_binomial_distribution<_IntType1>& __x); 4270 4271 /** 4272 * @brief Extracts a %negative_binomial_distribution random number 4273 * distribution @p __x from the input stream @p __is. 4274 * 4275 * @param __is An input stream. 4276 * @param __x A %negative_binomial_distribution random number 4277 * generator engine. 4278 * 4279 * @returns The input stream with @p __x extracted or in an error state. 4280 */ 4281 template<typename _IntType1, typename _CharT, typename _Traits> 4282 friend std::basic_istream<_CharT, _Traits>& 4283 operator>>(std::basic_istream<_CharT, _Traits>& __is, 4284 std::negative_binomial_distribution<_IntType1>& __x); 4285 4286 private: 4287 template<typename _ForwardIterator, 4288 typename _UniformRandomNumberGenerator> 4289 void 4290 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 4291 _UniformRandomNumberGenerator& __urng); 4292 template<typename _ForwardIterator, 4293 typename _UniformRandomNumberGenerator> 4294 void 4295 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 4296 _UniformRandomNumberGenerator& __urng, 4297 const param_type& __p); 4298 4299 param_type _M_param; 4300 4301 std::gamma_distribution<double> _M_gd; 4302 }; 4303 4304 /** 4305 * @brief Return true if two negative binomial distributions are different. 4306 */ 4307 template<typename _IntType> 4308 inline bool 4309 operator!=(const std::negative_binomial_distribution<_IntType>& __d1, 4310 const std::negative_binomial_distribution<_IntType>& __d2) 4311 { return !(__d1 == __d2); } 4312 4313 4314 /* @} */ // group random_distributions_bernoulli 4315 4316 /** 4317 * @addtogroup random_distributions_poisson Poisson Distributions 4318 * @ingroup random_distributions 4319 * @{ 4320 */ 4321 4322 /** 4323 * @brief A discrete Poisson random number distribution. 4324 * 4325 * The formula for the Poisson probability density function is 4326 * @f$p(i|\mu) = \frac{\mu^i}{i!} e^{-\mu}@f$ where @f$\mu@f$ is the 4327 * parameter of the distribution. 4328 */ 4329 template<typename _IntType = int> 4330 class poisson_distribution 4331 { 4332 static_assert(std::is_integral<_IntType>::value, 4333 "result_type must be an integral type"); 4334 4335 public: 4336 /** The type of the range of the distribution. */ 4337 typedef _IntType result_type; 4338 4339 /** Parameter type. */ 4340 struct param_type 4341 { 4342 typedef poisson_distribution<_IntType> distribution_type; 4343 friend class poisson_distribution<_IntType>; 4344 4345 explicit 4346 param_type(double __mean = 1.0) 4347 : _M_mean(__mean) 4348 { 4349 __glibcxx_assert(_M_mean > 0.0); 4350 _M_initialize(); 4351 } 4352 4353 double 4354 mean() const 4355 { return _M_mean; } 4356 4357 friend bool 4358 operator==(const param_type& __p1, const param_type& __p2) 4359 { return __p1._M_mean == __p2._M_mean; } 4360 4361 friend bool 4362 operator!=(const param_type& __p1, const param_type& __p2) 4363 { return !(__p1 == __p2); } 4364 4365 private: 4366 // Hosts either log(mean) or the threshold of the simple method. 4367 void 4368 _M_initialize(); 4369 4370 double _M_mean; 4371 4372 double _M_lm_thr; 4373 #if _GLIBCXX_USE_C99_MATH_TR1 4374 double _M_lfm, _M_sm, _M_d, _M_scx, _M_1cx, _M_c2b, _M_cb; 4375 #endif 4376 }; 4377 4378 // constructors and member function 4379 explicit 4380 poisson_distribution(double __mean = 1.0) 4381 : _M_param(__mean), _M_nd() 4382 { } 4383 4384 explicit 4385 poisson_distribution(const param_type& __p) 4386 : _M_param(__p), _M_nd() 4387 { } 4388 4389 /** 4390 * @brief Resets the distribution state. 4391 */ 4392 void 4393 reset() 4394 { _M_nd.reset(); } 4395 4396 /** 4397 * @brief Returns the distribution parameter @p mean. 4398 */ 4399 double 4400 mean() const 4401 { return _M_param.mean(); } 4402 4403 /** 4404 * @brief Returns the parameter set of the distribution. 4405 */ 4406 param_type 4407 param() const 4408 { return _M_param; } 4409 4410 /** 4411 * @brief Sets the parameter set of the distribution. 4412 * @param __param The new parameter set of the distribution. 4413 */ 4414 void 4415 param(const param_type& __param) 4416 { _M_param = __param; } 4417 4418 /** 4419 * @brief Returns the greatest lower bound value of the distribution. 4420 */ 4421 result_type 4422 min() const 4423 { return 0; } 4424 4425 /** 4426 * @brief Returns the least upper bound value of the distribution. 4427 */ 4428 result_type 4429 max() const 4430 { return std::numeric_limits<result_type>::max(); } 4431 4432 /** 4433 * @brief Generating functions. 4434 */ 4435 template<typename _UniformRandomNumberGenerator> 4436 result_type 4437 operator()(_UniformRandomNumberGenerator& __urng) 4438 { return this->operator()(__urng, _M_param); } 4439 4440 template<typename _UniformRandomNumberGenerator> 4441 result_type 4442 operator()(_UniformRandomNumberGenerator& __urng, 4443 const param_type& __p); 4444 4445 template<typename _ForwardIterator, 4446 typename _UniformRandomNumberGenerator> 4447 void 4448 __generate(_ForwardIterator __f, _ForwardIterator __t, 4449 _UniformRandomNumberGenerator& __urng) 4450 { this->__generate(__f, __t, __urng, _M_param); } 4451 4452 template<typename _ForwardIterator, 4453 typename _UniformRandomNumberGenerator> 4454 void 4455 __generate(_ForwardIterator __f, _ForwardIterator __t, 4456 _UniformRandomNumberGenerator& __urng, 4457 const param_type& __p) 4458 { this->__generate_impl(__f, __t, __urng, __p); } 4459 4460 template<typename _UniformRandomNumberGenerator> 4461 void 4462 __generate(result_type* __f, result_type* __t, 4463 _UniformRandomNumberGenerator& __urng, 4464 const param_type& __p) 4465 { this->__generate_impl(__f, __t, __urng, __p); } 4466 4467 /** 4468 * @brief Return true if two Poisson distributions have the same 4469 * parameters and the sequences that would be generated 4470 * are equal. 4471 */ 4472 friend bool 4473 operator==(const poisson_distribution& __d1, 4474 const poisson_distribution& __d2) 4475 #ifdef _GLIBCXX_USE_C99_MATH_TR1 4476 { return __d1._M_param == __d2._M_param && __d1._M_nd == __d2._M_nd; } 4477 #else 4478 { return __d1._M_param == __d2._M_param; } 4479 #endif 4480 4481 /** 4482 * @brief Inserts a %poisson_distribution random number distribution 4483 * @p __x into the output stream @p __os. 4484 * 4485 * @param __os An output stream. 4486 * @param __x A %poisson_distribution random number distribution. 4487 * 4488 * @returns The output stream with the state of @p __x inserted or in 4489 * an error state. 4490 */ 4491 template<typename _IntType1, typename _CharT, typename _Traits> 4492 friend std::basic_ostream<_CharT, _Traits>& 4493 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 4494 const std::poisson_distribution<_IntType1>& __x); 4495 4496 /** 4497 * @brief Extracts a %poisson_distribution random number distribution 4498 * @p __x from the input stream @p __is. 4499 * 4500 * @param __is An input stream. 4501 * @param __x A %poisson_distribution random number generator engine. 4502 * 4503 * @returns The input stream with @p __x extracted or in an error 4504 * state. 4505 */ 4506 template<typename _IntType1, typename _CharT, typename _Traits> 4507 friend std::basic_istream<_CharT, _Traits>& 4508 operator>>(std::basic_istream<_CharT, _Traits>& __is, 4509 std::poisson_distribution<_IntType1>& __x); 4510 4511 private: 4512 template<typename _ForwardIterator, 4513 typename _UniformRandomNumberGenerator> 4514 void 4515 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 4516 _UniformRandomNumberGenerator& __urng, 4517 const param_type& __p); 4518 4519 param_type _M_param; 4520 4521 // NB: Unused when _GLIBCXX_USE_C99_MATH_TR1 is undefined. 4522 std::normal_distribution<double> _M_nd; 4523 }; 4524 4525 /** 4526 * @brief Return true if two Poisson distributions are different. 4527 */ 4528 template<typename _IntType> 4529 inline bool 4530 operator!=(const std::poisson_distribution<_IntType>& __d1, 4531 const std::poisson_distribution<_IntType>& __d2) 4532 { return !(__d1 == __d2); } 4533 4534 4535 /** 4536 * @brief An exponential continuous distribution for random numbers. 4537 * 4538 * The formula for the exponential probability density function is 4539 * @f$p(x|\lambda) = \lambda e^{-\lambda x}@f$. 4540 * 4541 * <table border=1 cellpadding=10 cellspacing=0> 4542 * <caption align=top>Distribution Statistics</caption> 4543 * <tr><td>Mean</td><td>@f$\frac{1}{\lambda}@f$</td></tr> 4544 * <tr><td>Median</td><td>@f$\frac{\ln 2}{\lambda}@f$</td></tr> 4545 * <tr><td>Mode</td><td>@f$zero@f$</td></tr> 4546 * <tr><td>Range</td><td>@f$[0, \infty]@f$</td></tr> 4547 * <tr><td>Standard Deviation</td><td>@f$\frac{1}{\lambda}@f$</td></tr> 4548 * </table> 4549 */ 4550 template<typename _RealType = double> 4551 class exponential_distribution 4552 { 4553 static_assert(std::is_floating_point<_RealType>::value, 4554 "result_type must be a floating point type"); 4555 4556 public: 4557 /** The type of the range of the distribution. */ 4558 typedef _RealType result_type; 4559 4560 /** Parameter type. */ 4561 struct param_type 4562 { 4563 typedef exponential_distribution<_RealType> distribution_type; 4564 4565 explicit 4566 param_type(_RealType __lambda = _RealType(1)) 4567 : _M_lambda(__lambda) 4568 { 4569 __glibcxx_assert(_M_lambda > _RealType(0)); 4570 } 4571 4572 _RealType 4573 lambda() const 4574 { return _M_lambda; } 4575 4576 friend bool 4577 operator==(const param_type& __p1, const param_type& __p2) 4578 { return __p1._M_lambda == __p2._M_lambda; } 4579 4580 friend bool 4581 operator!=(const param_type& __p1, const param_type& __p2) 4582 { return !(__p1 == __p2); } 4583 4584 private: 4585 _RealType _M_lambda; 4586 }; 4587 4588 public: 4589 /** 4590 * @brief Constructs an exponential distribution with inverse scale 4591 * parameter @f$\lambda@f$. 4592 */ 4593 explicit 4594 exponential_distribution(const result_type& __lambda = result_type(1)) 4595 : _M_param(__lambda) 4596 { } 4597 4598 explicit 4599 exponential_distribution(const param_type& __p) 4600 : _M_param(__p) 4601 { } 4602 4603 /** 4604 * @brief Resets the distribution state. 4605 * 4606 * Has no effect on exponential distributions. 4607 */ 4608 void 4609 reset() { } 4610 4611 /** 4612 * @brief Returns the inverse scale parameter of the distribution. 4613 */ 4614 _RealType 4615 lambda() const 4616 { return _M_param.lambda(); } 4617 4618 /** 4619 * @brief Returns the parameter set of the distribution. 4620 */ 4621 param_type 4622 param() const 4623 { return _M_param; } 4624 4625 /** 4626 * @brief Sets the parameter set of the distribution. 4627 * @param __param The new parameter set of the distribution. 4628 */ 4629 void 4630 param(const param_type& __param) 4631 { _M_param = __param; } 4632 4633 /** 4634 * @brief Returns the greatest lower bound value of the distribution. 4635 */ 4636 result_type 4637 min() const 4638 { return result_type(0); } 4639 4640 /** 4641 * @brief Returns the least upper bound value of the distribution. 4642 */ 4643 result_type 4644 max() const 4645 { return std::numeric_limits<result_type>::max(); } 4646 4647 /** 4648 * @brief Generating functions. 4649 */ 4650 template<typename _UniformRandomNumberGenerator> 4651 result_type 4652 operator()(_UniformRandomNumberGenerator& __urng) 4653 { return this->operator()(__urng, _M_param); } 4654 4655 template<typename _UniformRandomNumberGenerator> 4656 result_type 4657 operator()(_UniformRandomNumberGenerator& __urng, 4658 const param_type& __p) 4659 { 4660 __detail::_Adaptor<_UniformRandomNumberGenerator, result_type> 4661 __aurng(__urng); 4662 return -std::log(result_type(1) - __aurng()) / __p.lambda(); 4663 } 4664 4665 template<typename _ForwardIterator, 4666 typename _UniformRandomNumberGenerator> 4667 void 4668 __generate(_ForwardIterator __f, _ForwardIterator __t, 4669 _UniformRandomNumberGenerator& __urng) 4670 { this->__generate(__f, __t, __urng, _M_param); } 4671 4672 template<typename _ForwardIterator, 4673 typename _UniformRandomNumberGenerator> 4674 void 4675 __generate(_ForwardIterator __f, _ForwardIterator __t, 4676 _UniformRandomNumberGenerator& __urng, 4677 const param_type& __p) 4678 { this->__generate_impl(__f, __t, __urng, __p); } 4679 4680 template<typename _UniformRandomNumberGenerator> 4681 void 4682 __generate(result_type* __f, result_type* __t, 4683 _UniformRandomNumberGenerator& __urng, 4684 const param_type& __p) 4685 { this->__generate_impl(__f, __t, __urng, __p); } 4686 4687 /** 4688 * @brief Return true if two exponential distributions have the same 4689 * parameters. 4690 */ 4691 friend bool 4692 operator==(const exponential_distribution& __d1, 4693 const exponential_distribution& __d2) 4694 { return __d1._M_param == __d2._M_param; } 4695 4696 private: 4697 template<typename _ForwardIterator, 4698 typename _UniformRandomNumberGenerator> 4699 void 4700 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 4701 _UniformRandomNumberGenerator& __urng, 4702 const param_type& __p); 4703 4704 param_type _M_param; 4705 }; 4706 4707 /** 4708 * @brief Return true if two exponential distributions have different 4709 * parameters. 4710 */ 4711 template<typename _RealType> 4712 inline bool 4713 operator!=(const std::exponential_distribution<_RealType>& __d1, 4714 const std::exponential_distribution<_RealType>& __d2) 4715 { return !(__d1 == __d2); } 4716 4717 /** 4718 * @brief Inserts a %exponential_distribution random number distribution 4719 * @p __x into the output stream @p __os. 4720 * 4721 * @param __os An output stream. 4722 * @param __x A %exponential_distribution random number distribution. 4723 * 4724 * @returns The output stream with the state of @p __x inserted or in 4725 * an error state. 4726 */ 4727 template<typename _RealType, typename _CharT, typename _Traits> 4728 std::basic_ostream<_CharT, _Traits>& 4729 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 4730 const std::exponential_distribution<_RealType>& __x); 4731 4732 /** 4733 * @brief Extracts a %exponential_distribution random number distribution 4734 * @p __x from the input stream @p __is. 4735 * 4736 * @param __is An input stream. 4737 * @param __x A %exponential_distribution random number 4738 * generator engine. 4739 * 4740 * @returns The input stream with @p __x extracted or in an error state. 4741 */ 4742 template<typename _RealType, typename _CharT, typename _Traits> 4743 std::basic_istream<_CharT, _Traits>& 4744 operator>>(std::basic_istream<_CharT, _Traits>& __is, 4745 std::exponential_distribution<_RealType>& __x); 4746 4747 4748 /** 4749 * @brief A weibull_distribution random number distribution. 4750 * 4751 * The formula for the normal probability density function is: 4752 * @f[ 4753 * p(x|\alpha,\beta) = \frac{\alpha}{\beta} (\frac{x}{\beta})^{\alpha-1} 4754 * \exp{(-(\frac{x}{\beta})^\alpha)} 4755 * @f] 4756 */ 4757 template<typename _RealType = double> 4758 class weibull_distribution 4759 { 4760 static_assert(std::is_floating_point<_RealType>::value, 4761 "result_type must be a floating point type"); 4762 4763 public: 4764 /** The type of the range of the distribution. */ 4765 typedef _RealType result_type; 4766 4767 /** Parameter type. */ 4768 struct param_type 4769 { 4770 typedef weibull_distribution<_RealType> distribution_type; 4771 4772 explicit 4773 param_type(_RealType __a = _RealType(1), 4774 _RealType __b = _RealType(1)) 4775 : _M_a(__a), _M_b(__b) 4776 { } 4777 4778 _RealType 4779 a() const 4780 { return _M_a; } 4781 4782 _RealType 4783 b() const 4784 { return _M_b; } 4785 4786 friend bool 4787 operator==(const param_type& __p1, const param_type& __p2) 4788 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } 4789 4790 friend bool 4791 operator!=(const param_type& __p1, const param_type& __p2) 4792 { return !(__p1 == __p2); } 4793 4794 private: 4795 _RealType _M_a; 4796 _RealType _M_b; 4797 }; 4798 4799 explicit 4800 weibull_distribution(_RealType __a = _RealType(1), 4801 _RealType __b = _RealType(1)) 4802 : _M_param(__a, __b) 4803 { } 4804 4805 explicit 4806 weibull_distribution(const param_type& __p) 4807 : _M_param(__p) 4808 { } 4809 4810 /** 4811 * @brief Resets the distribution state. 4812 */ 4813 void 4814 reset() 4815 { } 4816 4817 /** 4818 * @brief Return the @f$a@f$ parameter of the distribution. 4819 */ 4820 _RealType 4821 a() const 4822 { return _M_param.a(); } 4823 4824 /** 4825 * @brief Return the @f$b@f$ parameter of the distribution. 4826 */ 4827 _RealType 4828 b() const 4829 { return _M_param.b(); } 4830 4831 /** 4832 * @brief Returns the parameter set of the distribution. 4833 */ 4834 param_type 4835 param() const 4836 { return _M_param; } 4837 4838 /** 4839 * @brief Sets the parameter set of the distribution. 4840 * @param __param The new parameter set of the distribution. 4841 */ 4842 void 4843 param(const param_type& __param) 4844 { _M_param = __param; } 4845 4846 /** 4847 * @brief Returns the greatest lower bound value of the distribution. 4848 */ 4849 result_type 4850 min() const 4851 { return result_type(0); } 4852 4853 /** 4854 * @brief Returns the least upper bound value of the distribution. 4855 */ 4856 result_type 4857 max() const 4858 { return std::numeric_limits<result_type>::max(); } 4859 4860 /** 4861 * @brief Generating functions. 4862 */ 4863 template<typename _UniformRandomNumberGenerator> 4864 result_type 4865 operator()(_UniformRandomNumberGenerator& __urng) 4866 { return this->operator()(__urng, _M_param); } 4867 4868 template<typename _UniformRandomNumberGenerator> 4869 result_type 4870 operator()(_UniformRandomNumberGenerator& __urng, 4871 const param_type& __p); 4872 4873 template<typename _ForwardIterator, 4874 typename _UniformRandomNumberGenerator> 4875 void 4876 __generate(_ForwardIterator __f, _ForwardIterator __t, 4877 _UniformRandomNumberGenerator& __urng) 4878 { this->__generate(__f, __t, __urng, _M_param); } 4879 4880 template<typename _ForwardIterator, 4881 typename _UniformRandomNumberGenerator> 4882 void 4883 __generate(_ForwardIterator __f, _ForwardIterator __t, 4884 _UniformRandomNumberGenerator& __urng, 4885 const param_type& __p) 4886 { this->__generate_impl(__f, __t, __urng, __p); } 4887 4888 template<typename _UniformRandomNumberGenerator> 4889 void 4890 __generate(result_type* __f, result_type* __t, 4891 _UniformRandomNumberGenerator& __urng, 4892 const param_type& __p) 4893 { this->__generate_impl(__f, __t, __urng, __p); } 4894 4895 /** 4896 * @brief Return true if two Weibull distributions have the same 4897 * parameters. 4898 */ 4899 friend bool 4900 operator==(const weibull_distribution& __d1, 4901 const weibull_distribution& __d2) 4902 { return __d1._M_param == __d2._M_param; } 4903 4904 private: 4905 template<typename _ForwardIterator, 4906 typename _UniformRandomNumberGenerator> 4907 void 4908 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 4909 _UniformRandomNumberGenerator& __urng, 4910 const param_type& __p); 4911 4912 param_type _M_param; 4913 }; 4914 4915 /** 4916 * @brief Return true if two Weibull distributions have different 4917 * parameters. 4918 */ 4919 template<typename _RealType> 4920 inline bool 4921 operator!=(const std::weibull_distribution<_RealType>& __d1, 4922 const std::weibull_distribution<_RealType>& __d2) 4923 { return !(__d1 == __d2); } 4924 4925 /** 4926 * @brief Inserts a %weibull_distribution random number distribution 4927 * @p __x into the output stream @p __os. 4928 * 4929 * @param __os An output stream. 4930 * @param __x A %weibull_distribution random number distribution. 4931 * 4932 * @returns The output stream with the state of @p __x inserted or in 4933 * an error state. 4934 */ 4935 template<typename _RealType, typename _CharT, typename _Traits> 4936 std::basic_ostream<_CharT, _Traits>& 4937 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 4938 const std::weibull_distribution<_RealType>& __x); 4939 4940 /** 4941 * @brief Extracts a %weibull_distribution random number distribution 4942 * @p __x from the input stream @p __is. 4943 * 4944 * @param __is An input stream. 4945 * @param __x A %weibull_distribution random number 4946 * generator engine. 4947 * 4948 * @returns The input stream with @p __x extracted or in an error state. 4949 */ 4950 template<typename _RealType, typename _CharT, typename _Traits> 4951 std::basic_istream<_CharT, _Traits>& 4952 operator>>(std::basic_istream<_CharT, _Traits>& __is, 4953 std::weibull_distribution<_RealType>& __x); 4954 4955 4956 /** 4957 * @brief A extreme_value_distribution random number distribution. 4958 * 4959 * The formula for the normal probability mass function is 4960 * @f[ 4961 * p(x|a,b) = \frac{1}{b} 4962 * \exp( \frac{a-x}{b} - \exp(\frac{a-x}{b})) 4963 * @f] 4964 */ 4965 template<typename _RealType = double> 4966 class extreme_value_distribution 4967 { 4968 static_assert(std::is_floating_point<_RealType>::value, 4969 "result_type must be a floating point type"); 4970 4971 public: 4972 /** The type of the range of the distribution. */ 4973 typedef _RealType result_type; 4974 4975 /** Parameter type. */ 4976 struct param_type 4977 { 4978 typedef extreme_value_distribution<_RealType> distribution_type; 4979 4980 explicit 4981 param_type(_RealType __a = _RealType(0), 4982 _RealType __b = _RealType(1)) 4983 : _M_a(__a), _M_b(__b) 4984 { } 4985 4986 _RealType 4987 a() const 4988 { return _M_a; } 4989 4990 _RealType 4991 b() const 4992 { return _M_b; } 4993 4994 friend bool 4995 operator==(const param_type& __p1, const param_type& __p2) 4996 { return __p1._M_a == __p2._M_a && __p1._M_b == __p2._M_b; } 4997 4998 friend bool 4999 operator!=(const param_type& __p1, const param_type& __p2) 5000 { return !(__p1 == __p2); } 5001 5002 private: 5003 _RealType _M_a; 5004 _RealType _M_b; 5005 }; 5006 5007 explicit 5008 extreme_value_distribution(_RealType __a = _RealType(0), 5009 _RealType __b = _RealType(1)) 5010 : _M_param(__a, __b) 5011 { } 5012 5013 explicit 5014 extreme_value_distribution(const param_type& __p) 5015 : _M_param(__p) 5016 { } 5017 5018 /** 5019 * @brief Resets the distribution state. 5020 */ 5021 void 5022 reset() 5023 { } 5024 5025 /** 5026 * @brief Return the @f$a@f$ parameter of the distribution. 5027 */ 5028 _RealType 5029 a() const 5030 { return _M_param.a(); } 5031 5032 /** 5033 * @brief Return the @f$b@f$ parameter of the distribution. 5034 */ 5035 _RealType 5036 b() const 5037 { return _M_param.b(); } 5038 5039 /** 5040 * @brief Returns the parameter set of the distribution. 5041 */ 5042 param_type 5043 param() const 5044 { return _M_param; } 5045 5046 /** 5047 * @brief Sets the parameter set of the distribution. 5048 * @param __param The new parameter set of the distribution. 5049 */ 5050 void 5051 param(const param_type& __param) 5052 { _M_param = __param; } 5053 5054 /** 5055 * @brief Returns the greatest lower bound value of the distribution. 5056 */ 5057 result_type 5058 min() const 5059 { return std::numeric_limits<result_type>::lowest(); } 5060 5061 /** 5062 * @brief Returns the least upper bound value of the distribution. 5063 */ 5064 result_type 5065 max() const 5066 { return std::numeric_limits<result_type>::max(); } 5067 5068 /** 5069 * @brief Generating functions. 5070 */ 5071 template<typename _UniformRandomNumberGenerator> 5072 result_type 5073 operator()(_UniformRandomNumberGenerator& __urng) 5074 { return this->operator()(__urng, _M_param); } 5075 5076 template<typename _UniformRandomNumberGenerator> 5077 result_type 5078 operator()(_UniformRandomNumberGenerator& __urng, 5079 const param_type& __p); 5080 5081 template<typename _ForwardIterator, 5082 typename _UniformRandomNumberGenerator> 5083 void 5084 __generate(_ForwardIterator __f, _ForwardIterator __t, 5085 _UniformRandomNumberGenerator& __urng) 5086 { this->__generate(__f, __t, __urng, _M_param); } 5087 5088 template<typename _ForwardIterator, 5089 typename _UniformRandomNumberGenerator> 5090 void 5091 __generate(_ForwardIterator __f, _ForwardIterator __t, 5092 _UniformRandomNumberGenerator& __urng, 5093 const param_type& __p) 5094 { this->__generate_impl(__f, __t, __urng, __p); } 5095 5096 template<typename _UniformRandomNumberGenerator> 5097 void 5098 __generate(result_type* __f, result_type* __t, 5099 _UniformRandomNumberGenerator& __urng, 5100 const param_type& __p) 5101 { this->__generate_impl(__f, __t, __urng, __p); } 5102 5103 /** 5104 * @brief Return true if two extreme value distributions have the same 5105 * parameters. 5106 */ 5107 friend bool 5108 operator==(const extreme_value_distribution& __d1, 5109 const extreme_value_distribution& __d2) 5110 { return __d1._M_param == __d2._M_param; } 5111 5112 private: 5113 template<typename _ForwardIterator, 5114 typename _UniformRandomNumberGenerator> 5115 void 5116 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 5117 _UniformRandomNumberGenerator& __urng, 5118 const param_type& __p); 5119 5120 param_type _M_param; 5121 }; 5122 5123 /** 5124 * @brief Return true if two extreme value distributions have different 5125 * parameters. 5126 */ 5127 template<typename _RealType> 5128 inline bool 5129 operator!=(const std::extreme_value_distribution<_RealType>& __d1, 5130 const std::extreme_value_distribution<_RealType>& __d2) 5131 { return !(__d1 == __d2); } 5132 5133 /** 5134 * @brief Inserts a %extreme_value_distribution random number distribution 5135 * @p __x into the output stream @p __os. 5136 * 5137 * @param __os An output stream. 5138 * @param __x A %extreme_value_distribution random number distribution. 5139 * 5140 * @returns The output stream with the state of @p __x inserted or in 5141 * an error state. 5142 */ 5143 template<typename _RealType, typename _CharT, typename _Traits> 5144 std::basic_ostream<_CharT, _Traits>& 5145 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 5146 const std::extreme_value_distribution<_RealType>& __x); 5147 5148 /** 5149 * @brief Extracts a %extreme_value_distribution random number 5150 * distribution @p __x from the input stream @p __is. 5151 * 5152 * @param __is An input stream. 5153 * @param __x A %extreme_value_distribution random number 5154 * generator engine. 5155 * 5156 * @returns The input stream with @p __x extracted or in an error state. 5157 */ 5158 template<typename _RealType, typename _CharT, typename _Traits> 5159 std::basic_istream<_CharT, _Traits>& 5160 operator>>(std::basic_istream<_CharT, _Traits>& __is, 5161 std::extreme_value_distribution<_RealType>& __x); 5162 5163 5164 /** 5165 * @brief A discrete_distribution random number distribution. 5166 * 5167 * The formula for the discrete probability mass function is 5168 * 5169 */ 5170 template<typename _IntType = int> 5171 class discrete_distribution 5172 { 5173 static_assert(std::is_integral<_IntType>::value, 5174 "result_type must be an integral type"); 5175 5176 public: 5177 /** The type of the range of the distribution. */ 5178 typedef _IntType result_type; 5179 5180 /** Parameter type. */ 5181 struct param_type 5182 { 5183 typedef discrete_distribution<_IntType> distribution_type; 5184 friend class discrete_distribution<_IntType>; 5185 5186 param_type() 5187 : _M_prob(), _M_cp() 5188 { } 5189 5190 template<typename _InputIterator> 5191 param_type(_InputIterator __wbegin, 5192 _InputIterator __wend) 5193 : _M_prob(__wbegin, __wend), _M_cp() 5194 { _M_initialize(); } 5195 5196 param_type(initializer_list<double> __wil) 5197 : _M_prob(__wil.begin(), __wil.end()), _M_cp() 5198 { _M_initialize(); } 5199 5200 template<typename _Func> 5201 param_type(size_t __nw, double __xmin, double __xmax, 5202 _Func __fw); 5203 5204 // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/ 5205 param_type(const param_type&) = default; 5206 param_type& operator=(const param_type&) = default; 5207 5208 std::vector<double> 5209 probabilities() const 5210 { return _M_prob.empty() ? std::vector<double>(1, 1.0) : _M_prob; } 5211 5212 friend bool 5213 operator==(const param_type& __p1, const param_type& __p2) 5214 { return __p1._M_prob == __p2._M_prob; } 5215 5216 friend bool 5217 operator!=(const param_type& __p1, const param_type& __p2) 5218 { return !(__p1 == __p2); } 5219 5220 private: 5221 void 5222 _M_initialize(); 5223 5224 std::vector<double> _M_prob; 5225 std::vector<double> _M_cp; 5226 }; 5227 5228 discrete_distribution() 5229 : _M_param() 5230 { } 5231 5232 template<typename _InputIterator> 5233 discrete_distribution(_InputIterator __wbegin, 5234 _InputIterator __wend) 5235 : _M_param(__wbegin, __wend) 5236 { } 5237 5238 discrete_distribution(initializer_list<double> __wl) 5239 : _M_param(__wl) 5240 { } 5241 5242 template<typename _Func> 5243 discrete_distribution(size_t __nw, double __xmin, double __xmax, 5244 _Func __fw) 5245 : _M_param(__nw, __xmin, __xmax, __fw) 5246 { } 5247 5248 explicit 5249 discrete_distribution(const param_type& __p) 5250 : _M_param(__p) 5251 { } 5252 5253 /** 5254 * @brief Resets the distribution state. 5255 */ 5256 void 5257 reset() 5258 { } 5259 5260 /** 5261 * @brief Returns the probabilities of the distribution. 5262 */ 5263 std::vector<double> 5264 probabilities() const 5265 { 5266 return _M_param._M_prob.empty() 5267 ? std::vector<double>(1, 1.0) : _M_param._M_prob; 5268 } 5269 5270 /** 5271 * @brief Returns the parameter set of the distribution. 5272 */ 5273 param_type 5274 param() const 5275 { return _M_param; } 5276 5277 /** 5278 * @brief Sets the parameter set of the distribution. 5279 * @param __param The new parameter set of the distribution. 5280 */ 5281 void 5282 param(const param_type& __param) 5283 { _M_param = __param; } 5284 5285 /** 5286 * @brief Returns the greatest lower bound value of the distribution. 5287 */ 5288 result_type 5289 min() const 5290 { return result_type(0); } 5291 5292 /** 5293 * @brief Returns the least upper bound value of the distribution. 5294 */ 5295 result_type 5296 max() const 5297 { 5298 return _M_param._M_prob.empty() 5299 ? result_type(0) : result_type(_M_param._M_prob.size() - 1); 5300 } 5301 5302 /** 5303 * @brief Generating functions. 5304 */ 5305 template<typename _UniformRandomNumberGenerator> 5306 result_type 5307 operator()(_UniformRandomNumberGenerator& __urng) 5308 { return this->operator()(__urng, _M_param); } 5309 5310 template<typename _UniformRandomNumberGenerator> 5311 result_type 5312 operator()(_UniformRandomNumberGenerator& __urng, 5313 const param_type& __p); 5314 5315 template<typename _ForwardIterator, 5316 typename _UniformRandomNumberGenerator> 5317 void 5318 __generate(_ForwardIterator __f, _ForwardIterator __t, 5319 _UniformRandomNumberGenerator& __urng) 5320 { this->__generate(__f, __t, __urng, _M_param); } 5321 5322 template<typename _ForwardIterator, 5323 typename _UniformRandomNumberGenerator> 5324 void 5325 __generate(_ForwardIterator __f, _ForwardIterator __t, 5326 _UniformRandomNumberGenerator& __urng, 5327 const param_type& __p) 5328 { this->__generate_impl(__f, __t, __urng, __p); } 5329 5330 template<typename _UniformRandomNumberGenerator> 5331 void 5332 __generate(result_type* __f, result_type* __t, 5333 _UniformRandomNumberGenerator& __urng, 5334 const param_type& __p) 5335 { this->__generate_impl(__f, __t, __urng, __p); } 5336 5337 /** 5338 * @brief Return true if two discrete distributions have the same 5339 * parameters. 5340 */ 5341 friend bool 5342 operator==(const discrete_distribution& __d1, 5343 const discrete_distribution& __d2) 5344 { return __d1._M_param == __d2._M_param; } 5345 5346 /** 5347 * @brief Inserts a %discrete_distribution random number distribution 5348 * @p __x into the output stream @p __os. 5349 * 5350 * @param __os An output stream. 5351 * @param __x A %discrete_distribution random number distribution. 5352 * 5353 * @returns The output stream with the state of @p __x inserted or in 5354 * an error state. 5355 */ 5356 template<typename _IntType1, typename _CharT, typename _Traits> 5357 friend std::basic_ostream<_CharT, _Traits>& 5358 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 5359 const std::discrete_distribution<_IntType1>& __x); 5360 5361 /** 5362 * @brief Extracts a %discrete_distribution random number distribution 5363 * @p __x from the input stream @p __is. 5364 * 5365 * @param __is An input stream. 5366 * @param __x A %discrete_distribution random number 5367 * generator engine. 5368 * 5369 * @returns The input stream with @p __x extracted or in an error 5370 * state. 5371 */ 5372 template<typename _IntType1, typename _CharT, typename _Traits> 5373 friend std::basic_istream<_CharT, _Traits>& 5374 operator>>(std::basic_istream<_CharT, _Traits>& __is, 5375 std::discrete_distribution<_IntType1>& __x); 5376 5377 private: 5378 template<typename _ForwardIterator, 5379 typename _UniformRandomNumberGenerator> 5380 void 5381 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 5382 _UniformRandomNumberGenerator& __urng, 5383 const param_type& __p); 5384 5385 param_type _M_param; 5386 }; 5387 5388 /** 5389 * @brief Return true if two discrete distributions have different 5390 * parameters. 5391 */ 5392 template<typename _IntType> 5393 inline bool 5394 operator!=(const std::discrete_distribution<_IntType>& __d1, 5395 const std::discrete_distribution<_IntType>& __d2) 5396 { return !(__d1 == __d2); } 5397 5398 5399 /** 5400 * @brief A piecewise_constant_distribution random number distribution. 5401 * 5402 * The formula for the piecewise constant probability mass function is 5403 * 5404 */ 5405 template<typename _RealType = double> 5406 class piecewise_constant_distribution 5407 { 5408 static_assert(std::is_floating_point<_RealType>::value, 5409 "result_type must be a floating point type"); 5410 5411 public: 5412 /** The type of the range of the distribution. */ 5413 typedef _RealType result_type; 5414 5415 /** Parameter type. */ 5416 struct param_type 5417 { 5418 typedef piecewise_constant_distribution<_RealType> distribution_type; 5419 friend class piecewise_constant_distribution<_RealType>; 5420 5421 param_type() 5422 : _M_int(), _M_den(), _M_cp() 5423 { } 5424 5425 template<typename _InputIteratorB, typename _InputIteratorW> 5426 param_type(_InputIteratorB __bfirst, 5427 _InputIteratorB __bend, 5428 _InputIteratorW __wbegin); 5429 5430 template<typename _Func> 5431 param_type(initializer_list<_RealType> __bi, _Func __fw); 5432 5433 template<typename _Func> 5434 param_type(size_t __nw, _RealType __xmin, _RealType __xmax, 5435 _Func __fw); 5436 5437 // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/ 5438 param_type(const param_type&) = default; 5439 param_type& operator=(const param_type&) = default; 5440 5441 std::vector<_RealType> 5442 intervals() const 5443 { 5444 if (_M_int.empty()) 5445 { 5446 std::vector<_RealType> __tmp(2); 5447 __tmp[1] = _RealType(1); 5448 return __tmp; 5449 } 5450 else 5451 return _M_int; 5452 } 5453 5454 std::vector<double> 5455 densities() const 5456 { return _M_den.empty() ? std::vector<double>(1, 1.0) : _M_den; } 5457 5458 friend bool 5459 operator==(const param_type& __p1, const param_type& __p2) 5460 { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; } 5461 5462 friend bool 5463 operator!=(const param_type& __p1, const param_type& __p2) 5464 { return !(__p1 == __p2); } 5465 5466 private: 5467 void 5468 _M_initialize(); 5469 5470 std::vector<_RealType> _M_int; 5471 std::vector<double> _M_den; 5472 std::vector<double> _M_cp; 5473 }; 5474 5475 explicit 5476 piecewise_constant_distribution() 5477 : _M_param() 5478 { } 5479 5480 template<typename _InputIteratorB, typename _InputIteratorW> 5481 piecewise_constant_distribution(_InputIteratorB __bfirst, 5482 _InputIteratorB __bend, 5483 _InputIteratorW __wbegin) 5484 : _M_param(__bfirst, __bend, __wbegin) 5485 { } 5486 5487 template<typename _Func> 5488 piecewise_constant_distribution(initializer_list<_RealType> __bl, 5489 _Func __fw) 5490 : _M_param(__bl, __fw) 5491 { } 5492 5493 template<typename _Func> 5494 piecewise_constant_distribution(size_t __nw, 5495 _RealType __xmin, _RealType __xmax, 5496 _Func __fw) 5497 : _M_param(__nw, __xmin, __xmax, __fw) 5498 { } 5499 5500 explicit 5501 piecewise_constant_distribution(const param_type& __p) 5502 : _M_param(__p) 5503 { } 5504 5505 /** 5506 * @brief Resets the distribution state. 5507 */ 5508 void 5509 reset() 5510 { } 5511 5512 /** 5513 * @brief Returns a vector of the intervals. 5514 */ 5515 std::vector<_RealType> 5516 intervals() const 5517 { 5518 if (_M_param._M_int.empty()) 5519 { 5520 std::vector<_RealType> __tmp(2); 5521 __tmp[1] = _RealType(1); 5522 return __tmp; 5523 } 5524 else 5525 return _M_param._M_int; 5526 } 5527 5528 /** 5529 * @brief Returns a vector of the probability densities. 5530 */ 5531 std::vector<double> 5532 densities() const 5533 { 5534 return _M_param._M_den.empty() 5535 ? std::vector<double>(1, 1.0) : _M_param._M_den; 5536 } 5537 5538 /** 5539 * @brief Returns the parameter set of the distribution. 5540 */ 5541 param_type 5542 param() const 5543 { return _M_param; } 5544 5545 /** 5546 * @brief Sets the parameter set of the distribution. 5547 * @param __param The new parameter set of the distribution. 5548 */ 5549 void 5550 param(const param_type& __param) 5551 { _M_param = __param; } 5552 5553 /** 5554 * @brief Returns the greatest lower bound value of the distribution. 5555 */ 5556 result_type 5557 min() const 5558 { 5559 return _M_param._M_int.empty() 5560 ? result_type(0) : _M_param._M_int.front(); 5561 } 5562 5563 /** 5564 * @brief Returns the least upper bound value of the distribution. 5565 */ 5566 result_type 5567 max() const 5568 { 5569 return _M_param._M_int.empty() 5570 ? result_type(1) : _M_param._M_int.back(); 5571 } 5572 5573 /** 5574 * @brief Generating functions. 5575 */ 5576 template<typename _UniformRandomNumberGenerator> 5577 result_type 5578 operator()(_UniformRandomNumberGenerator& __urng) 5579 { return this->operator()(__urng, _M_param); } 5580 5581 template<typename _UniformRandomNumberGenerator> 5582 result_type 5583 operator()(_UniformRandomNumberGenerator& __urng, 5584 const param_type& __p); 5585 5586 template<typename _ForwardIterator, 5587 typename _UniformRandomNumberGenerator> 5588 void 5589 __generate(_ForwardIterator __f, _ForwardIterator __t, 5590 _UniformRandomNumberGenerator& __urng) 5591 { this->__generate(__f, __t, __urng, _M_param); } 5592 5593 template<typename _ForwardIterator, 5594 typename _UniformRandomNumberGenerator> 5595 void 5596 __generate(_ForwardIterator __f, _ForwardIterator __t, 5597 _UniformRandomNumberGenerator& __urng, 5598 const param_type& __p) 5599 { this->__generate_impl(__f, __t, __urng, __p); } 5600 5601 template<typename _UniformRandomNumberGenerator> 5602 void 5603 __generate(result_type* __f, result_type* __t, 5604 _UniformRandomNumberGenerator& __urng, 5605 const param_type& __p) 5606 { this->__generate_impl(__f, __t, __urng, __p); } 5607 5608 /** 5609 * @brief Return true if two piecewise constant distributions have the 5610 * same parameters. 5611 */ 5612 friend bool 5613 operator==(const piecewise_constant_distribution& __d1, 5614 const piecewise_constant_distribution& __d2) 5615 { return __d1._M_param == __d2._M_param; } 5616 5617 /** 5618 * @brief Inserts a %piecewise_constant_distribution random 5619 * number distribution @p __x into the output stream @p __os. 5620 * 5621 * @param __os An output stream. 5622 * @param __x A %piecewise_constant_distribution random number 5623 * distribution. 5624 * 5625 * @returns The output stream with the state of @p __x inserted or in 5626 * an error state. 5627 */ 5628 template<typename _RealType1, typename _CharT, typename _Traits> 5629 friend std::basic_ostream<_CharT, _Traits>& 5630 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 5631 const std::piecewise_constant_distribution<_RealType1>& __x); 5632 5633 /** 5634 * @brief Extracts a %piecewise_constant_distribution random 5635 * number distribution @p __x from the input stream @p __is. 5636 * 5637 * @param __is An input stream. 5638 * @param __x A %piecewise_constant_distribution random number 5639 * generator engine. 5640 * 5641 * @returns The input stream with @p __x extracted or in an error 5642 * state. 5643 */ 5644 template<typename _RealType1, typename _CharT, typename _Traits> 5645 friend std::basic_istream<_CharT, _Traits>& 5646 operator>>(std::basic_istream<_CharT, _Traits>& __is, 5647 std::piecewise_constant_distribution<_RealType1>& __x); 5648 5649 private: 5650 template<typename _ForwardIterator, 5651 typename _UniformRandomNumberGenerator> 5652 void 5653 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 5654 _UniformRandomNumberGenerator& __urng, 5655 const param_type& __p); 5656 5657 param_type _M_param; 5658 }; 5659 5660 /** 5661 * @brief Return true if two piecewise constant distributions have 5662 * different parameters. 5663 */ 5664 template<typename _RealType> 5665 inline bool 5666 operator!=(const std::piecewise_constant_distribution<_RealType>& __d1, 5667 const std::piecewise_constant_distribution<_RealType>& __d2) 5668 { return !(__d1 == __d2); } 5669 5670 5671 /** 5672 * @brief A piecewise_linear_distribution random number distribution. 5673 * 5674 * The formula for the piecewise linear probability mass function is 5675 * 5676 */ 5677 template<typename _RealType = double> 5678 class piecewise_linear_distribution 5679 { 5680 static_assert(std::is_floating_point<_RealType>::value, 5681 "result_type must be a floating point type"); 5682 5683 public: 5684 /** The type of the range of the distribution. */ 5685 typedef _RealType result_type; 5686 5687 /** Parameter type. */ 5688 struct param_type 5689 { 5690 typedef piecewise_linear_distribution<_RealType> distribution_type; 5691 friend class piecewise_linear_distribution<_RealType>; 5692 5693 param_type() 5694 : _M_int(), _M_den(), _M_cp(), _M_m() 5695 { } 5696 5697 template<typename _InputIteratorB, typename _InputIteratorW> 5698 param_type(_InputIteratorB __bfirst, 5699 _InputIteratorB __bend, 5700 _InputIteratorW __wbegin); 5701 5702 template<typename _Func> 5703 param_type(initializer_list<_RealType> __bl, _Func __fw); 5704 5705 template<typename _Func> 5706 param_type(size_t __nw, _RealType __xmin, _RealType __xmax, 5707 _Func __fw); 5708 5709 // See: http://cpp-next.com/archive/2010/10/implicit-move-must-go/ 5710 param_type(const param_type&) = default; 5711 param_type& operator=(const param_type&) = default; 5712 5713 std::vector<_RealType> 5714 intervals() const 5715 { 5716 if (_M_int.empty()) 5717 { 5718 std::vector<_RealType> __tmp(2); 5719 __tmp[1] = _RealType(1); 5720 return __tmp; 5721 } 5722 else 5723 return _M_int; 5724 } 5725 5726 std::vector<double> 5727 densities() const 5728 { return _M_den.empty() ? std::vector<double>(2, 1.0) : _M_den; } 5729 5730 friend bool 5731 operator==(const param_type& __p1, const param_type& __p2) 5732 { return __p1._M_int == __p2._M_int && __p1._M_den == __p2._M_den; } 5733 5734 friend bool 5735 operator!=(const param_type& __p1, const param_type& __p2) 5736 { return !(__p1 == __p2); } 5737 5738 private: 5739 void 5740 _M_initialize(); 5741 5742 std::vector<_RealType> _M_int; 5743 std::vector<double> _M_den; 5744 std::vector<double> _M_cp; 5745 std::vector<double> _M_m; 5746 }; 5747 5748 explicit 5749 piecewise_linear_distribution() 5750 : _M_param() 5751 { } 5752 5753 template<typename _InputIteratorB, typename _InputIteratorW> 5754 piecewise_linear_distribution(_InputIteratorB __bfirst, 5755 _InputIteratorB __bend, 5756 _InputIteratorW __wbegin) 5757 : _M_param(__bfirst, __bend, __wbegin) 5758 { } 5759 5760 template<typename _Func> 5761 piecewise_linear_distribution(initializer_list<_RealType> __bl, 5762 _Func __fw) 5763 : _M_param(__bl, __fw) 5764 { } 5765 5766 template<typename _Func> 5767 piecewise_linear_distribution(size_t __nw, 5768 _RealType __xmin, _RealType __xmax, 5769 _Func __fw) 5770 : _M_param(__nw, __xmin, __xmax, __fw) 5771 { } 5772 5773 explicit 5774 piecewise_linear_distribution(const param_type& __p) 5775 : _M_param(__p) 5776 { } 5777 5778 /** 5779 * Resets the distribution state. 5780 */ 5781 void 5782 reset() 5783 { } 5784 5785 /** 5786 * @brief Return the intervals of the distribution. 5787 */ 5788 std::vector<_RealType> 5789 intervals() const 5790 { 5791 if (_M_param._M_int.empty()) 5792 { 5793 std::vector<_RealType> __tmp(2); 5794 __tmp[1] = _RealType(1); 5795 return __tmp; 5796 } 5797 else 5798 return _M_param._M_int; 5799 } 5800 5801 /** 5802 * @brief Return a vector of the probability densities of the 5803 * distribution. 5804 */ 5805 std::vector<double> 5806 densities() const 5807 { 5808 return _M_param._M_den.empty() 5809 ? std::vector<double>(2, 1.0) : _M_param._M_den; 5810 } 5811 5812 /** 5813 * @brief Returns the parameter set of the distribution. 5814 */ 5815 param_type 5816 param() const 5817 { return _M_param; } 5818 5819 /** 5820 * @brief Sets the parameter set of the distribution. 5821 * @param __param The new parameter set of the distribution. 5822 */ 5823 void 5824 param(const param_type& __param) 5825 { _M_param = __param; } 5826 5827 /** 5828 * @brief Returns the greatest lower bound value of the distribution. 5829 */ 5830 result_type 5831 min() const 5832 { 5833 return _M_param._M_int.empty() 5834 ? result_type(0) : _M_param._M_int.front(); 5835 } 5836 5837 /** 5838 * @brief Returns the least upper bound value of the distribution. 5839 */ 5840 result_type 5841 max() const 5842 { 5843 return _M_param._M_int.empty() 5844 ? result_type(1) : _M_param._M_int.back(); 5845 } 5846 5847 /** 5848 * @brief Generating functions. 5849 */ 5850 template<typename _UniformRandomNumberGenerator> 5851 result_type 5852 operator()(_UniformRandomNumberGenerator& __urng) 5853 { return this->operator()(__urng, _M_param); } 5854 5855 template<typename _UniformRandomNumberGenerator> 5856 result_type 5857 operator()(_UniformRandomNumberGenerator& __urng, 5858 const param_type& __p); 5859 5860 template<typename _ForwardIterator, 5861 typename _UniformRandomNumberGenerator> 5862 void 5863 __generate(_ForwardIterator __f, _ForwardIterator __t, 5864 _UniformRandomNumberGenerator& __urng) 5865 { this->__generate(__f, __t, __urng, _M_param); } 5866 5867 template<typename _ForwardIterator, 5868 typename _UniformRandomNumberGenerator> 5869 void 5870 __generate(_ForwardIterator __f, _ForwardIterator __t, 5871 _UniformRandomNumberGenerator& __urng, 5872 const param_type& __p) 5873 { this->__generate_impl(__f, __t, __urng, __p); } 5874 5875 template<typename _UniformRandomNumberGenerator> 5876 void 5877 __generate(result_type* __f, result_type* __t, 5878 _UniformRandomNumberGenerator& __urng, 5879 const param_type& __p) 5880 { this->__generate_impl(__f, __t, __urng, __p); } 5881 5882 /** 5883 * @brief Return true if two piecewise linear distributions have the 5884 * same parameters. 5885 */ 5886 friend bool 5887 operator==(const piecewise_linear_distribution& __d1, 5888 const piecewise_linear_distribution& __d2) 5889 { return __d1._M_param == __d2._M_param; } 5890 5891 /** 5892 * @brief Inserts a %piecewise_linear_distribution random number 5893 * distribution @p __x into the output stream @p __os. 5894 * 5895 * @param __os An output stream. 5896 * @param __x A %piecewise_linear_distribution random number 5897 * distribution. 5898 * 5899 * @returns The output stream with the state of @p __x inserted or in 5900 * an error state. 5901 */ 5902 template<typename _RealType1, typename _CharT, typename _Traits> 5903 friend std::basic_ostream<_CharT, _Traits>& 5904 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 5905 const std::piecewise_linear_distribution<_RealType1>& __x); 5906 5907 /** 5908 * @brief Extracts a %piecewise_linear_distribution random number 5909 * distribution @p __x from the input stream @p __is. 5910 * 5911 * @param __is An input stream. 5912 * @param __x A %piecewise_linear_distribution random number 5913 * generator engine. 5914 * 5915 * @returns The input stream with @p __x extracted or in an error 5916 * state. 5917 */ 5918 template<typename _RealType1, typename _CharT, typename _Traits> 5919 friend std::basic_istream<_CharT, _Traits>& 5920 operator>>(std::basic_istream<_CharT, _Traits>& __is, 5921 std::piecewise_linear_distribution<_RealType1>& __x); 5922 5923 private: 5924 template<typename _ForwardIterator, 5925 typename _UniformRandomNumberGenerator> 5926 void 5927 __generate_impl(_ForwardIterator __f, _ForwardIterator __t, 5928 _UniformRandomNumberGenerator& __urng, 5929 const param_type& __p); 5930 5931 param_type _M_param; 5932 }; 5933 5934 /** 5935 * @brief Return true if two piecewise linear distributions have 5936 * different parameters. 5937 */ 5938 template<typename _RealType> 5939 inline bool 5940 operator!=(const std::piecewise_linear_distribution<_RealType>& __d1, 5941 const std::piecewise_linear_distribution<_RealType>& __d2) 5942 { return !(__d1 == __d2); } 5943 5944 5945 /* @} */ // group random_distributions_poisson 5946 5947 /* @} */ // group random_distributions 5948 5949 /** 5950 * @addtogroup random_utilities Random Number Utilities 5951 * @ingroup random 5952 * @{ 5953 */ 5954 5955 /** 5956 * @brief The seed_seq class generates sequences of seeds for random 5957 * number generators. 5958 */ 5959 class seed_seq 5960 { 5961 public: 5962 /** The type of the seed vales. */ 5963 typedef uint_least32_t result_type; 5964 5965 /** Default constructor. */ 5966 seed_seq() noexcept 5967 : _M_v() 5968 { } 5969 5970 template<typename _IntType> 5971 seed_seq(std::initializer_list<_IntType> il); 5972 5973 template<typename _InputIterator> 5974 seed_seq(_InputIterator __begin, _InputIterator __end); 5975 5976 // generating functions 5977 template<typename _RandomAccessIterator> 5978 void 5979 generate(_RandomAccessIterator __begin, _RandomAccessIterator __end); 5980 5981 // property functions 5982 size_t size() const noexcept 5983 { return _M_v.size(); } 5984 5985 template<typename OutputIterator> 5986 void 5987 param(OutputIterator __dest) const 5988 { std::copy(_M_v.begin(), _M_v.end(), __dest); } 5989 5990 // no copy functions 5991 seed_seq(const seed_seq&) = delete; 5992 seed_seq& operator=(const seed_seq&) = delete; 5993 5994 private: 5995 std::vector<result_type> _M_v; 5996 }; 5997 5998 /* @} */ // group random_utilities 5999 6000 /* @} */ // group random 6001 6002 _GLIBCXX_END_NAMESPACE_VERSION 6003 } // namespace std 6004 6005 #endif 6006