1 // random number generation -*- C++ -*- 2 3 // Copyright (C) 2009-2018 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 /* 62 * Implementation-space details. 63 */ 64 namespace __detail 65 { 66 template<typename _UIntType, size_t __w, 67 bool = __w < static_cast<size_t> 68 (std::numeric_limits<_UIntType>::digits)> 69 struct _Shift 70 { static const _UIntType __value = 0; }; 71 72 template<typename _UIntType, size_t __w> 73 struct _Shift<_UIntType, __w, true> 74 { static const _UIntType __value = _UIntType(1) << __w; }; 75 76 template<int __s, 77 int __which = ((__s <= __CHAR_BIT__ * sizeof (int)) 78 + (__s <= __CHAR_BIT__ * sizeof (long)) 79 + (__s <= __CHAR_BIT__ * sizeof (long long)) 80 /* assume long long no bigger than __int128 */ 81 + (__s <= 128))> 82 struct _Select_uint_least_t 83 { 84 static_assert(__which < 0, /* needs to be dependent */ 85 "sorry, would be too much trouble for a slow result"); 86 }; 87 88 template<int __s> 89 struct _Select_uint_least_t<__s, 4> 90 { typedef unsigned int type; }; 91 92 template<int __s> 93 struct _Select_uint_least_t<__s, 3> 94 { typedef unsigned long type; }; 95 96 template<int __s> 97 struct _Select_uint_least_t<__s, 2> 98 { typedef unsigned long long type; }; 99 100 #ifdef _GLIBCXX_USE_INT128 101 template<int __s> 102 struct _Select_uint_least_t<__s, 1> 103 { typedef unsigned __int128 type; }; 104 #endif 105 106 // Assume a != 0, a < m, c < m, x < m. 107 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, 108 bool __big_enough = (!(__m & (__m - 1)) 109 || (_Tp(-1) - __c) / __a >= __m - 1), 110 bool __schrage_ok = __m % __a < __m / __a> 111 struct _Mod 112 { 113 typedef typename _Select_uint_least_t<std::__lg(__a) 114 + std::__lg(__m) + 2>::type _Tp2; 115 static _Tp 116 __calc(_Tp __x) 117 { return static_cast<_Tp>((_Tp2(__a) * __x + __c) % __m); } 118 }; 119 120 // Schrage. 121 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c> 122 struct _Mod<_Tp, __m, __a, __c, false, true> 123 { 124 static _Tp 125 __calc(_Tp __x); 126 }; 127 128 // Special cases: 129 // - for m == 2^n or m == 0, unsigned integer overflow is safe. 130 // - a * (m - 1) + c fits in _Tp, there is no overflow. 131 template<typename _Tp, _Tp __m, _Tp __a, _Tp __c, bool __s> 132 struct _Mod<_Tp, __m, __a, __c, true, __s> 133 { 134 static _Tp 135 __calc(_Tp __x) 136 { 137 _Tp __res = __a * __x + __c; 138 if (__m) 139 __res %= __m; 140 return __res; 141 } 142 }; 143 144 template<typename _Tp, _Tp __m, _Tp __a = 1, _Tp __c = 0> 145 inline _Tp 146 __mod(_Tp __x) 147 { return _Mod<_Tp, __m, __a, __c>::__calc(__x); } 148 149 /* 150 * An adaptor class for converting the output of any Generator into 151 * the input for a specific Distribution. 152 */ 153 template<typename _Engine, typename _DInputType> 154 struct _Adaptor 155 { 156 static_assert(std::is_floating_point<_DInputType>::value, 157 "template argument must be a floating point type"); 158 159 public: 160 _Adaptor(_Engine& __g) 161 : _M_g(__g) { } 162 163 _DInputType 164 min() const 165 { return _DInputType(0); } 166 167 _DInputType 168 max() const 169 { return _DInputType(1); } 170 171 /* 172 * Converts a value generated by the adapted random number generator 173 * into a value in the input domain for the dependent random number 174 * distribution. 175 */ 176 _DInputType 177 operator()() 178 { 179 return std::generate_canonical<_DInputType, 180 std::numeric_limits<_DInputType>::digits, 181 _Engine>(_M_g); 182 } 183 184 private: 185 _Engine& _M_g; 186 }; 187 188 } // namespace __detail 189 190 /** 191 * @addtogroup random_generators Random Number Generators 192 * @ingroup random 193 * 194 * These classes define objects which provide random or pseudorandom 195 * numbers, either from a discrete or a continuous interval. The 196 * random number generator supplied as a part of this library are 197 * all uniform random number generators which provide a sequence of 198 * random number uniformly distributed over their range. 199 * 200 * A number generator is a function object with an operator() that 201 * takes zero arguments and returns a number. 202 * 203 * A compliant random number generator must satisfy the following 204 * requirements. <table border=1 cellpadding=10 cellspacing=0> 205 * <caption align=top>Random Number Generator Requirements</caption> 206 * <tr><td>To be documented.</td></tr> </table> 207 * 208 * @{ 209 */ 210 211 /** 212 * @brief A model of a linear congruential random number generator. 213 * 214 * A random number generator that produces pseudorandom numbers via 215 * linear function: 216 * @f[ 217 * x_{i+1}\leftarrow(ax_{i} + c) \bmod m 218 * @f] 219 * 220 * The template parameter @p _UIntType must be an unsigned integral type 221 * large enough to store values up to (__m-1). If the template parameter 222 * @p __m is 0, the modulus @p __m used is 223 * std::numeric_limits<_UIntType>::max() plus 1. Otherwise, the template 224 * parameters @p __a and @p __c must be less than @p __m. 225 * 226 * The size of the state is @f$1@f$. 227 */ 228 template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> 229 class linear_congruential_engine 230 { 231 static_assert(std::is_unsigned<_UIntType>::value, 232 "result_type must be an unsigned integral type"); 233 static_assert(__m == 0u || (__a < __m && __c < __m), 234 "template argument substituting __m out of bounds"); 235 236 public: 237 /** The type of the generated random value. */ 238 typedef _UIntType result_type; 239 240 /** The multiplier. */ 241 static constexpr result_type multiplier = __a; 242 /** An increment. */ 243 static constexpr result_type increment = __c; 244 /** The modulus. */ 245 static constexpr result_type modulus = __m; 246 static constexpr result_type default_seed = 1u; 247 248 /** 249 * @brief Constructs a %linear_congruential_engine random number 250 * generator engine with seed @p __s. The default seed value 251 * is 1. 252 * 253 * @param __s The initial seed value. 254 */ 255 explicit 256 linear_congruential_engine(result_type __s = default_seed) 257 { seed(__s); } 258 259 /** 260 * @brief Constructs a %linear_congruential_engine random number 261 * generator engine seeded from the seed sequence @p __q. 262 * 263 * @param __q the seed sequence. 264 */ 265 template<typename _Sseq, typename = typename 266 std::enable_if<!std::is_same<_Sseq, linear_congruential_engine>::value> 267 ::type> 268 explicit 269 linear_congruential_engine(_Sseq& __q) 270 { seed(__q); } 271 272 /** 273 * @brief Reseeds the %linear_congruential_engine random number generator 274 * engine sequence to the seed @p __s. 275 * 276 * @param __s The new seed. 277 */ 278 void 279 seed(result_type __s = default_seed); 280 281 /** 282 * @brief Reseeds the %linear_congruential_engine random number generator 283 * engine 284 * sequence using values from the seed sequence @p __q. 285 * 286 * @param __q the seed sequence. 287 */ 288 template<typename _Sseq> 289 typename std::enable_if<std::is_class<_Sseq>::value>::type 290 seed(_Sseq& __q); 291 292 /** 293 * @brief Gets the smallest possible value in the output range. 294 * 295 * The minimum depends on the @p __c parameter: if it is zero, the 296 * minimum generated must be > 0, otherwise 0 is allowed. 297 */ 298 static constexpr result_type 299 min() 300 { return __c == 0u ? 1u : 0u; } 301 302 /** 303 * @brief Gets the largest possible value in the output range. 304 */ 305 static constexpr result_type 306 max() 307 { return __m - 1u; } 308 309 /** 310 * @brief Discard a sequence of random numbers. 311 */ 312 void 313 discard(unsigned long long __z) 314 { 315 for (; __z != 0ULL; --__z) 316 (*this)(); 317 } 318 319 /** 320 * @brief Gets the next random number in the sequence. 321 */ 322 result_type 323 operator()() 324 { 325 _M_x = __detail::__mod<_UIntType, __m, __a, __c>(_M_x); 326 return _M_x; 327 } 328 329 /** 330 * @brief Compares two linear congruential random number generator 331 * objects of the same type for equality. 332 * 333 * @param __lhs A linear congruential random number generator object. 334 * @param __rhs Another linear congruential random number generator 335 * object. 336 * 337 * @returns true if the infinite sequences of generated values 338 * would be equal, false otherwise. 339 */ 340 friend bool 341 operator==(const linear_congruential_engine& __lhs, 342 const linear_congruential_engine& __rhs) 343 { return __lhs._M_x == __rhs._M_x; } 344 345 /** 346 * @brief Writes the textual representation of the state x(i) of x to 347 * @p __os. 348 * 349 * @param __os The output stream. 350 * @param __lcr A % linear_congruential_engine random number generator. 351 * @returns __os. 352 */ 353 template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1, 354 _UIntType1 __m1, typename _CharT, typename _Traits> 355 friend std::basic_ostream<_CharT, _Traits>& 356 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 357 const std::linear_congruential_engine<_UIntType1, 358 __a1, __c1, __m1>& __lcr); 359 360 /** 361 * @brief Sets the state of the engine by reading its textual 362 * representation from @p __is. 363 * 364 * The textual representation must have been previously written using 365 * an output stream whose imbued locale and whose type's template 366 * specialization arguments _CharT and _Traits were the same as those 367 * of @p __is. 368 * 369 * @param __is The input stream. 370 * @param __lcr A % linear_congruential_engine random number generator. 371 * @returns __is. 372 */ 373 template<typename _UIntType1, _UIntType1 __a1, _UIntType1 __c1, 374 _UIntType1 __m1, typename _CharT, typename _Traits> 375 friend std::basic_istream<_CharT, _Traits>& 376 operator>>(std::basic_istream<_CharT, _Traits>& __is, 377 std::linear_congruential_engine<_UIntType1, __a1, 378 __c1, __m1>& __lcr); 379 380 private: 381 _UIntType _M_x; 382 }; 383 384 /** 385 * @brief Compares two linear congruential random number generator 386 * objects of the same type for inequality. 387 * 388 * @param __lhs A linear congruential random number generator object. 389 * @param __rhs Another linear congruential random number generator 390 * object. 391 * 392 * @returns true if the infinite sequences of generated values 393 * would be different, false otherwise. 394 */ 395 template<typename _UIntType, _UIntType __a, _UIntType __c, _UIntType __m> 396 inline bool 397 operator!=(const std::linear_congruential_engine<_UIntType, __a, 398 __c, __m>& __lhs, 399 const std::linear_congruential_engine<_UIntType, __a, 400 __c, __m>& __rhs) 401 { return !(__lhs == __rhs); } 402 403 404 /** 405 * A generalized feedback shift register discrete random number generator. 406 * 407 * This algorithm avoids multiplication and division and is designed to be 408 * friendly to a pipelined architecture. If the parameters are chosen 409 * correctly, this generator will produce numbers with a very long period and 410 * fairly good apparent entropy, although still not cryptographically strong. 411 * 412 * The best way to use this generator is with the predefined mt19937 class. 413 * 414 * This algorithm was originally invented by Makoto Matsumoto and 415 * Takuji Nishimura. 416 * 417 * @tparam __w Word size, the number of bits in each element of 418 * the state vector. 419 * @tparam __n The degree of recursion. 420 * @tparam __m The period parameter. 421 * @tparam __r The separation point bit index. 422 * @tparam __a The last row of the twist matrix. 423 * @tparam __u The first right-shift tempering matrix parameter. 424 * @tparam __d The first right-shift tempering matrix mask. 425 * @tparam __s The first left-shift tempering matrix parameter. 426 * @tparam __b The first left-shift tempering matrix mask. 427 * @tparam __t The second left-shift tempering matrix parameter. 428 * @tparam __c The second left-shift tempering matrix mask. 429 * @tparam __l The second right-shift tempering matrix parameter. 430 * @tparam __f Initialization multiplier. 431 */ 432 template<typename _UIntType, size_t __w, 433 size_t __n, size_t __m, size_t __r, 434 _UIntType __a, size_t __u, _UIntType __d, size_t __s, 435 _UIntType __b, size_t __t, 436 _UIntType __c, size_t __l, _UIntType __f> 437 class mersenne_twister_engine 438 { 439 static_assert(std::is_unsigned<_UIntType>::value, 440 "result_type must be an unsigned integral type"); 441 static_assert(1u <= __m && __m <= __n, 442 "template argument substituting __m out of bounds"); 443 static_assert(__r <= __w, "template argument substituting " 444 "__r out of bound"); 445 static_assert(__u <= __w, "template argument substituting " 446 "__u out of bound"); 447 static_assert(__s <= __w, "template argument substituting " 448 "__s out of bound"); 449 static_assert(__t <= __w, "template argument substituting " 450 "__t out of bound"); 451 static_assert(__l <= __w, "template argument substituting " 452 "__l out of bound"); 453 static_assert(__w <= std::numeric_limits<_UIntType>::digits, 454 "template argument substituting __w out of bound"); 455 static_assert(__a <= (__detail::_Shift<_UIntType, __w>::__value - 1), 456 "template argument substituting __a out of bound"); 457 static_assert(__b <= (__detail::_Shift<_UIntType, __w>::__value - 1), 458 "template argument substituting __b out of bound"); 459 static_assert(__c <= (__detail::_Shift<_UIntType, __w>::__value - 1), 460 "template argument substituting __c out of bound"); 461 static_assert(__d <= (__detail::_Shift<_UIntType, __w>::__value - 1), 462 "template argument substituting __d out of bound"); 463 static_assert(__f <= (__detail::_Shift<_UIntType, __w>::__value - 1), 464 "template argument substituting __f out of bound"); 465 466 public: 467 /** The type of the generated random value. */ 468 typedef _UIntType result_type; 469 470 // parameter values 471 static constexpr size_t word_size = __w; 472 static constexpr size_t state_size = __n; 473 static constexpr size_t shift_size = __m; 474 static constexpr size_t mask_bits = __r; 475 static constexpr result_type xor_mask = __a; 476 static constexpr size_t tempering_u = __u; 477 static constexpr result_type tempering_d = __d; 478 static constexpr size_t tempering_s = __s; 479 static constexpr result_type tempering_b = __b; 480 static constexpr size_t tempering_t = __t; 481 static constexpr result_type tempering_c = __c; 482 static constexpr size_t tempering_l = __l; 483 static constexpr result_type initialization_multiplier = __f; 484 static constexpr result_type default_seed = 5489u; 485 486 // constructors and member function 487 explicit 488 mersenne_twister_engine(result_type __sd = default_seed) 489 { seed(__sd); } 490 491 /** 492 * @brief Constructs a %mersenne_twister_engine random number generator 493 * engine seeded from the seed sequence @p __q. 494 * 495 * @param __q the seed sequence. 496 */ 497 template<typename _Sseq, typename = typename 498 std::enable_if<!std::is_same<_Sseq, mersenne_twister_engine>::value> 499 ::type> 500 explicit 501 mersenne_twister_engine(_Sseq& __q) 502 { seed(__q); } 503 504 void 505 seed(result_type __sd = default_seed); 506 507 template<typename _Sseq> 508 typename std::enable_if<std::is_class<_Sseq>::value>::type 509 seed(_Sseq& __q); 510 511 /** 512 * @brief Gets the smallest possible value in the output range. 513 */ 514 static constexpr result_type 515 min() 516 { return 0; } 517 518 /** 519 * @brief Gets the largest possible value in the output range. 520 */ 521 static constexpr result_type 522 max() 523 { return __detail::_Shift<_UIntType, __w>::__value - 1; } 524 525 /** 526 * @brief Discard a sequence of random numbers. 527 */ 528 void 529 discard(unsigned long long __z); 530 531 result_type 532 operator()(); 533 534 /** 535 * @brief Compares two % mersenne_twister_engine random number generator 536 * objects of the same type for equality. 537 * 538 * @param __lhs A % mersenne_twister_engine random number generator 539 * object. 540 * @param __rhs Another % mersenne_twister_engine random number 541 * generator object. 542 * 543 * @returns true if the infinite sequences of generated values 544 * would be equal, false otherwise. 545 */ 546 friend bool 547 operator==(const mersenne_twister_engine& __lhs, 548 const mersenne_twister_engine& __rhs) 549 { return (std::equal(__lhs._M_x, __lhs._M_x + state_size, __rhs._M_x) 550 && __lhs._M_p == __rhs._M_p); } 551 552 /** 553 * @brief Inserts the current state of a % mersenne_twister_engine 554 * random number generator engine @p __x into the output stream 555 * @p __os. 556 * 557 * @param __os An output stream. 558 * @param __x A % mersenne_twister_engine random number generator 559 * engine. 560 * 561 * @returns The output stream with the state of @p __x inserted or in 562 * an error state. 563 */ 564 template<typename _UIntType1, 565 size_t __w1, size_t __n1, 566 size_t __m1, size_t __r1, 567 _UIntType1 __a1, size_t __u1, 568 _UIntType1 __d1, size_t __s1, 569 _UIntType1 __b1, size_t __t1, 570 _UIntType1 __c1, size_t __l1, _UIntType1 __f1, 571 typename _CharT, typename _Traits> 572 friend std::basic_ostream<_CharT, _Traits>& 573 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 574 const std::mersenne_twister_engine<_UIntType1, __w1, __n1, 575 __m1, __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, 576 __l1, __f1>& __x); 577 578 /** 579 * @brief Extracts the current state of a % mersenne_twister_engine 580 * random number generator engine @p __x from the input stream 581 * @p __is. 582 * 583 * @param __is An input stream. 584 * @param __x A % mersenne_twister_engine random number generator 585 * engine. 586 * 587 * @returns The input stream with the state of @p __x extracted or in 588 * an error state. 589 */ 590 template<typename _UIntType1, 591 size_t __w1, size_t __n1, 592 size_t __m1, size_t __r1, 593 _UIntType1 __a1, size_t __u1, 594 _UIntType1 __d1, size_t __s1, 595 _UIntType1 __b1, size_t __t1, 596 _UIntType1 __c1, size_t __l1, _UIntType1 __f1, 597 typename _CharT, typename _Traits> 598 friend std::basic_istream<_CharT, _Traits>& 599 operator>>(std::basic_istream<_CharT, _Traits>& __is, 600 std::mersenne_twister_engine<_UIntType1, __w1, __n1, __m1, 601 __r1, __a1, __u1, __d1, __s1, __b1, __t1, __c1, 602 __l1, __f1>& __x); 603 604 private: 605 void _M_gen_rand(); 606 607 _UIntType _M_x[state_size]; 608 size_t _M_p; 609 }; 610 611 /** 612 * @brief Compares two % mersenne_twister_engine random number generator 613 * objects of the same type for inequality. 614 * 615 * @param __lhs A % mersenne_twister_engine random number generator 616 * object. 617 * @param __rhs Another % mersenne_twister_engine random number 618 * generator object. 619 * 620 * @returns true if the infinite sequences of generated values 621 * would be different, false otherwise. 622 */ 623 template<typename _UIntType, size_t __w, 624 size_t __n, size_t __m, size_t __r, 625 _UIntType __a, size_t __u, _UIntType __d, size_t __s, 626 _UIntType __b, size_t __t, 627 _UIntType __c, size_t __l, _UIntType __f> 628 inline bool 629 operator!=(const std::mersenne_twister_engine<_UIntType, __w, __n, __m, 630 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __lhs, 631 const std::mersenne_twister_engine<_UIntType, __w, __n, __m, 632 __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>& __rhs) 633 { return !(__lhs == __rhs); } 634 635 636 /** 637 * @brief The Marsaglia-Zaman generator. 638 * 639 * This is a model of a Generalized Fibonacci discrete random number 640 * generator, sometimes referred to as the SWC generator. 641 * 642 * A discrete random number generator that produces pseudorandom 643 * numbers using: 644 * @f[ 645 * x_{i}\leftarrow(x_{i - s} - x_{i - r} - carry_{i-1}) \bmod m 646 * @f] 647 * 648 * The size of the state is @f$r@f$ 649 * and the maximum period of the generator is @f$(m^r - m^s - 1)@f$. 650 */ 651 template<typename _UIntType, size_t __w, size_t __s, size_t __r> 652 class subtract_with_carry_engine 653 { 654 static_assert(std::is_unsigned<_UIntType>::value, 655 "result_type must be an unsigned integral type"); 656 static_assert(0u < __s && __s < __r, 657 "0 < s < r"); 658 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, 659 "template argument substituting __w out of bounds"); 660 661 public: 662 /** The type of the generated random value. */ 663 typedef _UIntType result_type; 664 665 // parameter values 666 static constexpr size_t word_size = __w; 667 static constexpr size_t short_lag = __s; 668 static constexpr size_t long_lag = __r; 669 static constexpr result_type default_seed = 19780503u; 670 671 /** 672 * @brief Constructs an explicitly seeded % subtract_with_carry_engine 673 * random number generator. 674 */ 675 explicit 676 subtract_with_carry_engine(result_type __sd = default_seed) 677 { seed(__sd); } 678 679 /** 680 * @brief Constructs a %subtract_with_carry_engine random number engine 681 * seeded from the seed sequence @p __q. 682 * 683 * @param __q the seed sequence. 684 */ 685 template<typename _Sseq, typename = typename 686 std::enable_if<!std::is_same<_Sseq, subtract_with_carry_engine>::value> 687 ::type> 688 explicit 689 subtract_with_carry_engine(_Sseq& __q) 690 { seed(__q); } 691 692 /** 693 * @brief Seeds the initial state @f$x_0@f$ of the random number 694 * generator. 695 * 696 * N1688[4.19] modifies this as follows. If @p __value == 0, 697 * sets value to 19780503. In any case, with a linear 698 * congruential generator lcg(i) having parameters @f$ m_{lcg} = 699 * 2147483563, a_{lcg} = 40014, c_{lcg} = 0, and lcg(0) = value 700 * @f$, sets @f$ x_{-r} \dots x_{-1} @f$ to @f$ lcg(1) \bmod m 701 * \dots lcg(r) \bmod m @f$ respectively. If @f$ x_{-1} = 0 @f$ 702 * set carry to 1, otherwise sets carry to 0. 703 */ 704 void 705 seed(result_type __sd = default_seed); 706 707 /** 708 * @brief Seeds the initial state @f$x_0@f$ of the 709 * % subtract_with_carry_engine random number generator. 710 */ 711 template<typename _Sseq> 712 typename std::enable_if<std::is_class<_Sseq>::value>::type 713 seed(_Sseq& __q); 714 715 /** 716 * @brief Gets the inclusive minimum value of the range of random 717 * integers returned by this generator. 718 */ 719 static constexpr result_type 720 min() 721 { return 0; } 722 723 /** 724 * @brief Gets the inclusive maximum value of the range of random 725 * integers returned by this generator. 726 */ 727 static constexpr result_type 728 max() 729 { return __detail::_Shift<_UIntType, __w>::__value - 1; } 730 731 /** 732 * @brief Discard a sequence of random numbers. 733 */ 734 void 735 discard(unsigned long long __z) 736 { 737 for (; __z != 0ULL; --__z) 738 (*this)(); 739 } 740 741 /** 742 * @brief Gets the next random number in the sequence. 743 */ 744 result_type 745 operator()(); 746 747 /** 748 * @brief Compares two % subtract_with_carry_engine random number 749 * generator objects of the same type for equality. 750 * 751 * @param __lhs A % subtract_with_carry_engine random number generator 752 * object. 753 * @param __rhs Another % subtract_with_carry_engine random number 754 * generator object. 755 * 756 * @returns true if the infinite sequences of generated values 757 * would be equal, false otherwise. 758 */ 759 friend bool 760 operator==(const subtract_with_carry_engine& __lhs, 761 const subtract_with_carry_engine& __rhs) 762 { return (std::equal(__lhs._M_x, __lhs._M_x + long_lag, __rhs._M_x) 763 && __lhs._M_carry == __rhs._M_carry 764 && __lhs._M_p == __rhs._M_p); } 765 766 /** 767 * @brief Inserts the current state of a % subtract_with_carry_engine 768 * random number generator engine @p __x into the output stream 769 * @p __os. 770 * 771 * @param __os An output stream. 772 * @param __x A % subtract_with_carry_engine random number generator 773 * engine. 774 * 775 * @returns The output stream with the state of @p __x inserted or in 776 * an error state. 777 */ 778 template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1, 779 typename _CharT, typename _Traits> 780 friend std::basic_ostream<_CharT, _Traits>& 781 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 782 const std::subtract_with_carry_engine<_UIntType1, __w1, 783 __s1, __r1>& __x); 784 785 /** 786 * @brief Extracts the current state of a % subtract_with_carry_engine 787 * random number generator engine @p __x from the input stream 788 * @p __is. 789 * 790 * @param __is An input stream. 791 * @param __x A % subtract_with_carry_engine random number generator 792 * engine. 793 * 794 * @returns The input stream with the state of @p __x extracted or in 795 * an error state. 796 */ 797 template<typename _UIntType1, size_t __w1, size_t __s1, size_t __r1, 798 typename _CharT, typename _Traits> 799 friend std::basic_istream<_CharT, _Traits>& 800 operator>>(std::basic_istream<_CharT, _Traits>& __is, 801 std::subtract_with_carry_engine<_UIntType1, __w1, 802 __s1, __r1>& __x); 803 804 private: 805 /// The state of the generator. This is a ring buffer. 806 _UIntType _M_x[long_lag]; 807 _UIntType _M_carry; ///< The carry 808 size_t _M_p; ///< Current index of x(i - r). 809 }; 810 811 /** 812 * @brief Compares two % subtract_with_carry_engine random number 813 * generator objects of the same type for inequality. 814 * 815 * @param __lhs A % subtract_with_carry_engine random number generator 816 * object. 817 * @param __rhs Another % subtract_with_carry_engine random number 818 * generator object. 819 * 820 * @returns true if the infinite sequences of generated values 821 * would be different, false otherwise. 822 */ 823 template<typename _UIntType, size_t __w, size_t __s, size_t __r> 824 inline bool 825 operator!=(const std::subtract_with_carry_engine<_UIntType, __w, 826 __s, __r>& __lhs, 827 const std::subtract_with_carry_engine<_UIntType, __w, 828 __s, __r>& __rhs) 829 { return !(__lhs == __rhs); } 830 831 832 /** 833 * Produces random numbers from some base engine by discarding blocks of 834 * data. 835 * 836 * 0 <= @p __r <= @p __p 837 */ 838 template<typename _RandomNumberEngine, size_t __p, size_t __r> 839 class discard_block_engine 840 { 841 static_assert(1 <= __r && __r <= __p, 842 "template argument substituting __r out of bounds"); 843 844 public: 845 /** The type of the generated random value. */ 846 typedef typename _RandomNumberEngine::result_type result_type; 847 848 // parameter values 849 static constexpr size_t block_size = __p; 850 static constexpr size_t used_block = __r; 851 852 /** 853 * @brief Constructs a default %discard_block_engine engine. 854 * 855 * The underlying engine is default constructed as well. 856 */ 857 discard_block_engine() 858 : _M_b(), _M_n(0) { } 859 860 /** 861 * @brief Copy constructs a %discard_block_engine engine. 862 * 863 * Copies an existing base class random number generator. 864 * @param __rng An existing (base class) engine object. 865 */ 866 explicit 867 discard_block_engine(const _RandomNumberEngine& __rng) 868 : _M_b(__rng), _M_n(0) { } 869 870 /** 871 * @brief Move constructs a %discard_block_engine engine. 872 * 873 * Copies an existing base class random number generator. 874 * @param __rng An existing (base class) engine object. 875 */ 876 explicit 877 discard_block_engine(_RandomNumberEngine&& __rng) 878 : _M_b(std::move(__rng)), _M_n(0) { } 879 880 /** 881 * @brief Seed constructs a %discard_block_engine engine. 882 * 883 * Constructs the underlying generator engine seeded with @p __s. 884 * @param __s A seed value for the base class engine. 885 */ 886 explicit 887 discard_block_engine(result_type __s) 888 : _M_b(__s), _M_n(0) { } 889 890 /** 891 * @brief Generator construct a %discard_block_engine engine. 892 * 893 * @param __q A seed sequence. 894 */ 895 template<typename _Sseq, typename = typename 896 std::enable_if<!std::is_same<_Sseq, discard_block_engine>::value 897 && !std::is_same<_Sseq, _RandomNumberEngine>::value> 898 ::type> 899 explicit 900 discard_block_engine(_Sseq& __q) 901 : _M_b(__q), _M_n(0) 902 { } 903 904 /** 905 * @brief Reseeds the %discard_block_engine object with the default 906 * seed for the underlying base class generator engine. 907 */ 908 void 909 seed() 910 { 911 _M_b.seed(); 912 _M_n = 0; 913 } 914 915 /** 916 * @brief Reseeds the %discard_block_engine object with the default 917 * seed for the underlying base class generator engine. 918 */ 919 void 920 seed(result_type __s) 921 { 922 _M_b.seed(__s); 923 _M_n = 0; 924 } 925 926 /** 927 * @brief Reseeds the %discard_block_engine object with the given seed 928 * sequence. 929 * @param __q A seed generator function. 930 */ 931 template<typename _Sseq> 932 void 933 seed(_Sseq& __q) 934 { 935 _M_b.seed(__q); 936 _M_n = 0; 937 } 938 939 /** 940 * @brief Gets a const reference to the underlying generator engine 941 * object. 942 */ 943 const _RandomNumberEngine& 944 base() const noexcept 945 { return _M_b; } 946 947 /** 948 * @brief Gets the minimum value in the generated random number range. 949 */ 950 static constexpr result_type 951 min() 952 { return _RandomNumberEngine::min(); } 953 954 /** 955 * @brief Gets the maximum value in the generated random number range. 956 */ 957 static constexpr result_type 958 max() 959 { return _RandomNumberEngine::max(); } 960 961 /** 962 * @brief Discard a sequence of random numbers. 963 */ 964 void 965 discard(unsigned long long __z) 966 { 967 for (; __z != 0ULL; --__z) 968 (*this)(); 969 } 970 971 /** 972 * @brief Gets the next value in the generated random number sequence. 973 */ 974 result_type 975 operator()(); 976 977 /** 978 * @brief Compares two %discard_block_engine random number generator 979 * objects of the same type for equality. 980 * 981 * @param __lhs A %discard_block_engine random number generator object. 982 * @param __rhs Another %discard_block_engine random number generator 983 * object. 984 * 985 * @returns true if the infinite sequences of generated values 986 * would be equal, false otherwise. 987 */ 988 friend bool 989 operator==(const discard_block_engine& __lhs, 990 const discard_block_engine& __rhs) 991 { return __lhs._M_b == __rhs._M_b && __lhs._M_n == __rhs._M_n; } 992 993 /** 994 * @brief Inserts the current state of a %discard_block_engine random 995 * number generator engine @p __x into the output stream 996 * @p __os. 997 * 998 * @param __os An output stream. 999 * @param __x A %discard_block_engine random number generator engine. 1000 * 1001 * @returns The output stream with the state of @p __x inserted or in 1002 * an error state. 1003 */ 1004 template<typename _RandomNumberEngine1, size_t __p1, size_t __r1, 1005 typename _CharT, typename _Traits> 1006 friend std::basic_ostream<_CharT, _Traits>& 1007 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1008 const std::discard_block_engine<_RandomNumberEngine1, 1009 __p1, __r1>& __x); 1010 1011 /** 1012 * @brief Extracts the current state of a % subtract_with_carry_engine 1013 * random number generator engine @p __x from the input stream 1014 * @p __is. 1015 * 1016 * @param __is An input stream. 1017 * @param __x A %discard_block_engine random number generator engine. 1018 * 1019 * @returns The input stream with the state of @p __x extracted or in 1020 * an error state. 1021 */ 1022 template<typename _RandomNumberEngine1, size_t __p1, size_t __r1, 1023 typename _CharT, typename _Traits> 1024 friend std::basic_istream<_CharT, _Traits>& 1025 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1026 std::discard_block_engine<_RandomNumberEngine1, 1027 __p1, __r1>& __x); 1028 1029 private: 1030 _RandomNumberEngine _M_b; 1031 size_t _M_n; 1032 }; 1033 1034 /** 1035 * @brief Compares two %discard_block_engine random number generator 1036 * objects of the same type for inequality. 1037 * 1038 * @param __lhs A %discard_block_engine random number generator object. 1039 * @param __rhs Another %discard_block_engine random number generator 1040 * object. 1041 * 1042 * @returns true if the infinite sequences of generated values 1043 * would be different, false otherwise. 1044 */ 1045 template<typename _RandomNumberEngine, size_t __p, size_t __r> 1046 inline bool 1047 operator!=(const std::discard_block_engine<_RandomNumberEngine, __p, 1048 __r>& __lhs, 1049 const std::discard_block_engine<_RandomNumberEngine, __p, 1050 __r>& __rhs) 1051 { return !(__lhs == __rhs); } 1052 1053 1054 /** 1055 * Produces random numbers by combining random numbers from some base 1056 * engine to produce random numbers with a specifies number of bits @p __w. 1057 */ 1058 template<typename _RandomNumberEngine, size_t __w, typename _UIntType> 1059 class independent_bits_engine 1060 { 1061 static_assert(std::is_unsigned<_UIntType>::value, 1062 "result_type must be an unsigned integral type"); 1063 static_assert(0u < __w && __w <= std::numeric_limits<_UIntType>::digits, 1064 "template argument substituting __w out of bounds"); 1065 1066 public: 1067 /** The type of the generated random value. */ 1068 typedef _UIntType result_type; 1069 1070 /** 1071 * @brief Constructs a default %independent_bits_engine engine. 1072 * 1073 * The underlying engine is default constructed as well. 1074 */ 1075 independent_bits_engine() 1076 : _M_b() { } 1077 1078 /** 1079 * @brief Copy constructs a %independent_bits_engine engine. 1080 * 1081 * Copies an existing base class random number generator. 1082 * @param __rng An existing (base class) engine object. 1083 */ 1084 explicit 1085 independent_bits_engine(const _RandomNumberEngine& __rng) 1086 : _M_b(__rng) { } 1087 1088 /** 1089 * @brief Move constructs a %independent_bits_engine engine. 1090 * 1091 * Copies an existing base class random number generator. 1092 * @param __rng An existing (base class) engine object. 1093 */ 1094 explicit 1095 independent_bits_engine(_RandomNumberEngine&& __rng) 1096 : _M_b(std::move(__rng)) { } 1097 1098 /** 1099 * @brief Seed constructs a %independent_bits_engine engine. 1100 * 1101 * Constructs the underlying generator engine seeded with @p __s. 1102 * @param __s A seed value for the base class engine. 1103 */ 1104 explicit 1105 independent_bits_engine(result_type __s) 1106 : _M_b(__s) { } 1107 1108 /** 1109 * @brief Generator construct a %independent_bits_engine engine. 1110 * 1111 * @param __q A seed sequence. 1112 */ 1113 template<typename _Sseq, typename = typename 1114 std::enable_if<!std::is_same<_Sseq, independent_bits_engine>::value 1115 && !std::is_same<_Sseq, _RandomNumberEngine>::value> 1116 ::type> 1117 explicit 1118 independent_bits_engine(_Sseq& __q) 1119 : _M_b(__q) 1120 { } 1121 1122 /** 1123 * @brief Reseeds the %independent_bits_engine object with the default 1124 * seed for the underlying base class generator engine. 1125 */ 1126 void 1127 seed() 1128 { _M_b.seed(); } 1129 1130 /** 1131 * @brief Reseeds the %independent_bits_engine object with the default 1132 * seed for the underlying base class generator engine. 1133 */ 1134 void 1135 seed(result_type __s) 1136 { _M_b.seed(__s); } 1137 1138 /** 1139 * @brief Reseeds the %independent_bits_engine object with the given 1140 * seed sequence. 1141 * @param __q A seed generator function. 1142 */ 1143 template<typename _Sseq> 1144 void 1145 seed(_Sseq& __q) 1146 { _M_b.seed(__q); } 1147 1148 /** 1149 * @brief Gets a const reference to the underlying generator engine 1150 * object. 1151 */ 1152 const _RandomNumberEngine& 1153 base() const noexcept 1154 { return _M_b; } 1155 1156 /** 1157 * @brief Gets the minimum value in the generated random number range. 1158 */ 1159 static constexpr result_type 1160 min() 1161 { return 0U; } 1162 1163 /** 1164 * @brief Gets the maximum value in the generated random number range. 1165 */ 1166 static constexpr result_type 1167 max() 1168 { return __detail::_Shift<_UIntType, __w>::__value - 1; } 1169 1170 /** 1171 * @brief Discard a sequence of random numbers. 1172 */ 1173 void 1174 discard(unsigned long long __z) 1175 { 1176 for (; __z != 0ULL; --__z) 1177 (*this)(); 1178 } 1179 1180 /** 1181 * @brief Gets the next value in the generated random number sequence. 1182 */ 1183 result_type 1184 operator()(); 1185 1186 /** 1187 * @brief Compares two %independent_bits_engine random number generator 1188 * objects of the same type for equality. 1189 * 1190 * @param __lhs A %independent_bits_engine random number generator 1191 * object. 1192 * @param __rhs Another %independent_bits_engine random number generator 1193 * object. 1194 * 1195 * @returns true if the infinite sequences of generated values 1196 * would be equal, false otherwise. 1197 */ 1198 friend bool 1199 operator==(const independent_bits_engine& __lhs, 1200 const independent_bits_engine& __rhs) 1201 { return __lhs._M_b == __rhs._M_b; } 1202 1203 /** 1204 * @brief Extracts the current state of a % subtract_with_carry_engine 1205 * random number generator engine @p __x from the input stream 1206 * @p __is. 1207 * 1208 * @param __is An input stream. 1209 * @param __x A %independent_bits_engine random number generator 1210 * engine. 1211 * 1212 * @returns The input stream with the state of @p __x extracted or in 1213 * an error state. 1214 */ 1215 template<typename _CharT, typename _Traits> 1216 friend std::basic_istream<_CharT, _Traits>& 1217 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1218 std::independent_bits_engine<_RandomNumberEngine, 1219 __w, _UIntType>& __x) 1220 { 1221 __is >> __x._M_b; 1222 return __is; 1223 } 1224 1225 private: 1226 _RandomNumberEngine _M_b; 1227 }; 1228 1229 /** 1230 * @brief Compares two %independent_bits_engine random number generator 1231 * objects of the same type for inequality. 1232 * 1233 * @param __lhs A %independent_bits_engine random number generator 1234 * object. 1235 * @param __rhs Another %independent_bits_engine random number generator 1236 * object. 1237 * 1238 * @returns true if the infinite sequences of generated values 1239 * would be different, false otherwise. 1240 */ 1241 template<typename _RandomNumberEngine, size_t __w, typename _UIntType> 1242 inline bool 1243 operator!=(const std::independent_bits_engine<_RandomNumberEngine, __w, 1244 _UIntType>& __lhs, 1245 const std::independent_bits_engine<_RandomNumberEngine, __w, 1246 _UIntType>& __rhs) 1247 { return !(__lhs == __rhs); } 1248 1249 /** 1250 * @brief Inserts the current state of a %independent_bits_engine random 1251 * number generator engine @p __x into the output stream @p __os. 1252 * 1253 * @param __os An output stream. 1254 * @param __x A %independent_bits_engine random number generator engine. 1255 * 1256 * @returns The output stream with the state of @p __x inserted or in 1257 * an error state. 1258 */ 1259 template<typename _RandomNumberEngine, size_t __w, typename _UIntType, 1260 typename _CharT, typename _Traits> 1261 std::basic_ostream<_CharT, _Traits>& 1262 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1263 const std::independent_bits_engine<_RandomNumberEngine, 1264 __w, _UIntType>& __x) 1265 { 1266 __os << __x.base(); 1267 return __os; 1268 } 1269 1270 1271 /** 1272 * @brief Produces random numbers by combining random numbers from some 1273 * base engine to produce random numbers with a specifies number of bits 1274 * @p __k. 1275 */ 1276 template<typename _RandomNumberEngine, size_t __k> 1277 class shuffle_order_engine 1278 { 1279 static_assert(1u <= __k, "template argument substituting " 1280 "__k out of bound"); 1281 1282 public: 1283 /** The type of the generated random value. */ 1284 typedef typename _RandomNumberEngine::result_type result_type; 1285 1286 static constexpr size_t table_size = __k; 1287 1288 /** 1289 * @brief Constructs a default %shuffle_order_engine engine. 1290 * 1291 * The underlying engine is default constructed as well. 1292 */ 1293 shuffle_order_engine() 1294 : _M_b() 1295 { _M_initialize(); } 1296 1297 /** 1298 * @brief Copy constructs a %shuffle_order_engine engine. 1299 * 1300 * Copies an existing base class random number generator. 1301 * @param __rng An existing (base class) engine object. 1302 */ 1303 explicit 1304 shuffle_order_engine(const _RandomNumberEngine& __rng) 1305 : _M_b(__rng) 1306 { _M_initialize(); } 1307 1308 /** 1309 * @brief Move constructs a %shuffle_order_engine engine. 1310 * 1311 * Copies an existing base class random number generator. 1312 * @param __rng An existing (base class) engine object. 1313 */ 1314 explicit 1315 shuffle_order_engine(_RandomNumberEngine&& __rng) 1316 : _M_b(std::move(__rng)) 1317 { _M_initialize(); } 1318 1319 /** 1320 * @brief Seed constructs a %shuffle_order_engine engine. 1321 * 1322 * Constructs the underlying generator engine seeded with @p __s. 1323 * @param __s A seed value for the base class engine. 1324 */ 1325 explicit 1326 shuffle_order_engine(result_type __s) 1327 : _M_b(__s) 1328 { _M_initialize(); } 1329 1330 /** 1331 * @brief Generator construct a %shuffle_order_engine engine. 1332 * 1333 * @param __q A seed sequence. 1334 */ 1335 template<typename _Sseq, typename = typename 1336 std::enable_if<!std::is_same<_Sseq, shuffle_order_engine>::value 1337 && !std::is_same<_Sseq, _RandomNumberEngine>::value> 1338 ::type> 1339 explicit 1340 shuffle_order_engine(_Sseq& __q) 1341 : _M_b(__q) 1342 { _M_initialize(); } 1343 1344 /** 1345 * @brief Reseeds the %shuffle_order_engine object with the default seed 1346 for the underlying base class generator engine. 1347 */ 1348 void 1349 seed() 1350 { 1351 _M_b.seed(); 1352 _M_initialize(); 1353 } 1354 1355 /** 1356 * @brief Reseeds the %shuffle_order_engine object with the default seed 1357 * for the underlying base class generator engine. 1358 */ 1359 void 1360 seed(result_type __s) 1361 { 1362 _M_b.seed(__s); 1363 _M_initialize(); 1364 } 1365 1366 /** 1367 * @brief Reseeds the %shuffle_order_engine object with the given seed 1368 * sequence. 1369 * @param __q A seed generator function. 1370 */ 1371 template<typename _Sseq> 1372 void 1373 seed(_Sseq& __q) 1374 { 1375 _M_b.seed(__q); 1376 _M_initialize(); 1377 } 1378 1379 /** 1380 * Gets a const reference to the underlying generator engine object. 1381 */ 1382 const _RandomNumberEngine& 1383 base() const noexcept 1384 { return _M_b; } 1385 1386 /** 1387 * Gets the minimum value in the generated random number range. 1388 */ 1389 static constexpr result_type 1390 min() 1391 { return _RandomNumberEngine::min(); } 1392 1393 /** 1394 * Gets the maximum value in the generated random number range. 1395 */ 1396 static constexpr result_type 1397 max() 1398 { return _RandomNumberEngine::max(); } 1399 1400 /** 1401 * Discard a sequence of random numbers. 1402 */ 1403 void 1404 discard(unsigned long long __z) 1405 { 1406 for (; __z != 0ULL; --__z) 1407 (*this)(); 1408 } 1409 1410 /** 1411 * Gets the next value in the generated random number sequence. 1412 */ 1413 result_type 1414 operator()(); 1415 1416 /** 1417 * Compares two %shuffle_order_engine random number generator objects 1418 * of the same type for equality. 1419 * 1420 * @param __lhs A %shuffle_order_engine random number generator object. 1421 * @param __rhs Another %shuffle_order_engine random number generator 1422 * object. 1423 * 1424 * @returns true if the infinite sequences of generated values 1425 * would be equal, false otherwise. 1426 */ 1427 friend bool 1428 operator==(const shuffle_order_engine& __lhs, 1429 const shuffle_order_engine& __rhs) 1430 { return (__lhs._M_b == __rhs._M_b 1431 && std::equal(__lhs._M_v, __lhs._M_v + __k, __rhs._M_v) 1432 && __lhs._M_y == __rhs._M_y); } 1433 1434 /** 1435 * @brief Inserts the current state of a %shuffle_order_engine random 1436 * number generator engine @p __x into the output stream 1437 @p __os. 1438 * 1439 * @param __os An output stream. 1440 * @param __x A %shuffle_order_engine random number generator engine. 1441 * 1442 * @returns The output stream with the state of @p __x inserted or in 1443 * an error state. 1444 */ 1445 template<typename _RandomNumberEngine1, size_t __k1, 1446 typename _CharT, typename _Traits> 1447 friend std::basic_ostream<_CharT, _Traits>& 1448 operator<<(std::basic_ostream<_CharT, _Traits>& __os, 1449 const std::shuffle_order_engine<_RandomNumberEngine1, 1450 __k1>& __x); 1451 1452 /** 1453 * @brief Extracts the current state of a % subtract_with_carry_engine 1454 * random number generator engine @p __x from the input stream 1455 * @p __is. 1456 * 1457 * @param __is An input stream. 1458 * @param __x A %shuffle_order_engine random number generator engine. 1459 * 1460 * @returns The input stream with the state of @p __x extracted or in 1461 * an error state. 1462 */ 1463 template<typename _RandomNumberEngine1, size_t __k1, 1464 typename _CharT, typename _Traits> 1465 friend std::basic_istream<_CharT, _Traits>& 1466 operator>>(std::basic_istream<_CharT, _Traits>& __is, 1467 std::shuffle_order_engine<_RandomNumberEngine1, __k1>& __x); 1468 1469 private: 1470 void _M_initialize() 1471 { 1472 for (size_t __i = 0; __i < __k; ++__i) 1473 _M_v[__i] = _M_b(); 1474 _M_y = _M_b(); 1475 } 1476 1477 _RandomNumberEngine _M_b; 1478 result_type _M_v[__k]; 1479 result_type _M_y; 1480 }; 1481 1482 /** 1483 * Compares two %shuffle_order_engine random number generator objects 1484 * of the same type for inequality. 1485 * 1486 * @param __lhs A %shuffle_order_engine random number generator object. 1487 * @param __rhs Another %shuffle_order_engine random number generator 1488 * object. 1489 * 1490 * @returns true if the infinite sequences of generated values 1491 * would be different, false otherwise. 1492 */ 1493 template<typename _RandomNumberEngine, size_t __k> 1494 inline bool 1495 operator!=(const std::shuffle_order_engine<_RandomNumberEngine, 1496 __k>& __lhs, 1497 const std::shuffle_order_engine<_RandomNumberEngine, 1498 __k>& __rhs) 1499 { return !(__lhs == __rhs); } 1500 1501 1502 /** 1503 * The classic Minimum Standard rand0 of Lewis, Goodman, and Miller. 1504 */ 1505 typedef linear_congruential_engine<uint_fast32_t, 16807UL, 0UL, 2147483647UL> 1506 minstd_rand0; 1507 1508 /** 1509 * An alternative LCR (Lehmer Generator function). 1510 */ 1511 typedef linear_congruential_engine<uint_fast32_t, 48271UL, 0UL, 2147483647UL> 1512 minstd_rand; 1513 1514 /** 1515 * The classic Mersenne Twister. 1516 * 1517 * Reference: 1518 * M. Matsumoto and T. Nishimura, Mersenne Twister: A 623-Dimensionally 1519 * Equidistributed Uniform Pseudo-Random Number Generator, ACM Transactions 1520 * on Modeling and Computer Simulation, Vol. 8, No. 1, January 1998, pp 3-30. 1521 */ 1522 typedef mersenne_twister_engine< 1523 uint_fast32_t, 1524 32, 624, 397, 31, 1525 0x9908b0dfUL, 11, 1526 0xffffffffUL, 7, 1527 0x9d2c5680UL, 15, 1528 0xefc60000UL, 18, 1812433253UL> mt19937; 1529 1530 /** 1531 * An alternative Mersenne Twister. 1532 */ 1533 typedef mersenne_twister_engine< 1534 uint_fast64_t, 1535 64, 312, 156, 31, 1536 0xb5026f5aa96619e9ULL, 29, 1537 0x5555555555555555ULL, 17, 1538 0x71d67fffeda60000ULL, 37, 1539 0xfff7eee000000000ULL, 43, 1540 6364136223846793005ULL> mt19937_64; 1541 1542 typedef subtract_with_carry_engine<uint_fast32_t, 24, 10, 24> 1543 ranlux24_base; 1544 1545 typedef subtract_with_carry_engine<uint_fast64_t, 48, 5, 12> 1546 ranlux48_base; 1547 1548 typedef discard_block_engine<ranlux24_base, 223, 23> ranlux24; 1549 1550 typedef discard_block_engine<ranlux48_base, 389, 11> ranlux48; 1551 1552 typedef shuffle_order_engine<minstd_rand0, 256> knuth_b; 1553 1554 typedef minstd_rand0 default_random_engine; 1555 1556 /** 1557 * A standard interface to a platform-specific non-deterministic 1558 * random number generator (if any are available). 1559 */ 1560 class random_device 1561 { 1562 public: 1563 /** The type of the generated random value. */ 1564 typedef unsigned int result_type; 1565 1566 // constructors, destructors and member functions 1567 1568 #ifdef _GLIBCXX_USE_RANDOM_TR1 1569 1570 explicit 1571 random_device(const std::string& __token = "default") 1572 { 1573 _M_init(__token); 1574 } 1575 1576 ~random_device() 1577 { _M_fini(); } 1578 1579 #else 1580 1581 explicit 1582 random_device(const std::string& __token = "mt19937") 1583 { _M_init_pretr1(__token); } 1584 1585 public: 1586 1587 #endif 1588 1589 static constexpr result_type 1590 min() 1591 { return std::numeric_limits<result_type>::min(); } 1592 1593 static constexpr result_type 1594 max() 1595 { return std::numeric_limits<result_type>::max(); } 1596 1597 double 1598 entropy() const noexcept 1599 { 1600 #ifdef _GLIBCXX_USE_RANDOM_TR1 1601 return this->_M_getentropy(); 1602 #else 1603 return 0.0; 1604 #endif 1605 } 1606 1607 result_type 1608 operator()() 1609 { 1610 #ifdef _GLIBCXX_USE_RANDOM_TR1 1611 return this->_M_getval(); 1612 #else 1613 return this->_M_getval_pretr1(); 1614 #endif 1615 } 1616 1617 // No copy functions. 1618 random_device(const random_device&) = delete; 1619 void operator=(const random_device&) = delete; 1620 1621 private: 1622 1623 void _M_init(const std::string& __token); 1624 void _M_init_pretr1(const std::string& __token); 1625 void _M_fini(); 1626 1627 result_type _M_getval(); 1628 result_type _M_getval_pretr1(); 1629 double _M_getentropy() const noexcept; 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