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