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