libcxx/include/__cxx03/__random/mersenne_twister_engine.h

   1 //===----------------------------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #ifndef _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H
  10 #define _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H
  11
  12 #include <__cxx03/__algorithm/equal.h>
  13 #include <__cxx03/__algorithm/min.h>
  14 #include <__cxx03/__config>
  15 #include <__cxx03/__random/is_seed_sequence.h>
  16 #include <__cxx03/cstddef>
  17 #include <__cxx03/cstdint>
  18 #include <__cxx03/iosfwd>
  19 #include <__cxx03/limits>
  20
  21 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
  22 #  pragma GCC system_header
  23 #endif
  24
  25 _LIBCPP_PUSH_MACROS
  26 #include <__cxx03/__undef_macros>
  27
  28 _LIBCPP_BEGIN_NAMESPACE_STD
  29
  30 template <class _UIntType,
  31           size_t __w,
  32           size_t __n,
  33           size_t __m,
  34           size_t __r,
  35           _UIntType __a,
  36           size_t __u,
  37           _UIntType __d,
  38           size_t __s,
  39           _UIntType __b,
  40           size_t __t,
  41           _UIntType __c,
  42           size_t __l,
  43           _UIntType __f>
  44 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine;
  45
  46 template <class _UInt,
  47           size_t _Wp,
  48           size_t _Np,
  49           size_t _Mp,
  50           size_t _Rp,
  51           _UInt _Ap,
  52           size_t _Up,
  53           _UInt _Dp,
  54           size_t _Sp,
  55           _UInt _Bp,
  56           size_t _Tp,
  57           _UInt _Cp,
  58           size_t _Lp,
  59           _UInt _Fp>
  60 _LIBCPP_HIDE_FROM_ABI bool
  61 operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
  62            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
  63
  64 template <class _UInt,
  65           size_t _Wp,
  66           size_t _Np,
  67           size_t _Mp,
  68           size_t _Rp,
  69           _UInt _Ap,
  70           size_t _Up,
  71           _UInt _Dp,
  72           size_t _Sp,
  73           _UInt _Bp,
  74           size_t _Tp,
  75           _UInt _Cp,
  76           size_t _Lp,
  77           _UInt _Fp>
  78 _LIBCPP_HIDE_FROM_ABI bool
  79 operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
  80            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
  81
  82 template <class _CharT,
  83           class _Traits,
  84           class _UInt,
  85           size_t _Wp,
  86           size_t _Np,
  87           size_t _Mp,
  88           size_t _Rp,
  89           _UInt _Ap,
  90           size_t _Up,
  91           _UInt _Dp,
  92           size_t _Sp,
  93           _UInt _Bp,
  94           size_t _Tp,
  95           _UInt _Cp,
  96           size_t _Lp,
  97           _UInt _Fp>
  98 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
  99 operator<<(basic_ostream<_CharT, _Traits>& __os,
 100            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 101
 102 template <class _CharT,
 103           class _Traits,
 104           class _UInt,
 105           size_t _Wp,
 106           size_t _Np,
 107           size_t _Mp,
 108           size_t _Rp,
 109           _UInt _Ap,
 110           size_t _Up,
 111           _UInt _Dp,
 112           size_t _Sp,
 113           _UInt _Bp,
 114           size_t _Tp,
 115           _UInt _Cp,
 116           size_t _Lp,
 117           _UInt _Fp>
 118 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 119 operator>>(basic_istream<_CharT, _Traits>& __is,
 120            mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 121
 122 template <class _UIntType,
 123           size_t __w,
 124           size_t __n,
 125           size_t __m,
 126           size_t __r,
 127           _UIntType __a,
 128           size_t __u,
 129           _UIntType __d,
 130           size_t __s,
 131           _UIntType __b,
 132           size_t __t,
 133           _UIntType __c,
 134           size_t __l,
 135           _UIntType __f>
 136 class _LIBCPP_TEMPLATE_VIS mersenne_twister_engine {
 137 public:
 138   // types
 139   typedef _UIntType result_type;
 140
 141 private:
 142   result_type __x_[__n];
 143   size_t __i_;
 144
 145   static_assert(0 < __m, "mersenne_twister_engine invalid parameters");
 146   static_assert(__m <= __n, "mersenne_twister_engine invalid parameters");
 147   static _LIBCPP_CONSTEXPR const result_type _Dt = numeric_limits<result_type>::digits;
 148   static_assert(__w <= _Dt, "mersenne_twister_engine invalid parameters");
 149   static_assert(2 <= __w, "mersenne_twister_engine invalid parameters");
 150   static_assert(__r <= __w, "mersenne_twister_engine invalid parameters");
 151   static_assert(__u <= __w, "mersenne_twister_engine invalid parameters");
 152   static_assert(__s <= __w, "mersenne_twister_engine invalid parameters");
 153   static_assert(__t <= __w, "mersenne_twister_engine invalid parameters");
 154   static_assert(__l <= __w, "mersenne_twister_engine invalid parameters");
 155
 156 public:
 157   static _LIBCPP_CONSTEXPR const result_type _Min = 0;
 158   static _LIBCPP_CONSTEXPR const result_type _Max =
 159       __w == _Dt ? result_type(~0) : (result_type(1) << __w) - result_type(1);
 160   static_assert(_Min < _Max, "mersenne_twister_engine invalid parameters");
 161   static_assert(__a <= _Max, "mersenne_twister_engine invalid parameters");
 162   static_assert(__b <= _Max, "mersenne_twister_engine invalid parameters");
 163   static_assert(__c <= _Max, "mersenne_twister_engine invalid parameters");
 164   static_assert(__d <= _Max, "mersenne_twister_engine invalid parameters");
 165   static_assert(__f <= _Max, "mersenne_twister_engine invalid parameters");
 166
 167   // engine characteristics
 168   static _LIBCPP_CONSTEXPR const size_t word_size                      = __w;
 169   static _LIBCPP_CONSTEXPR const size_t state_size                     = __n;
 170   static _LIBCPP_CONSTEXPR const size_t shift_size                     = __m;
 171   static _LIBCPP_CONSTEXPR const size_t mask_bits                      = __r;
 172   static _LIBCPP_CONSTEXPR const result_type xor_mask                  = __a;
 173   static _LIBCPP_CONSTEXPR const size_t tempering_u                    = __u;
 174   static _LIBCPP_CONSTEXPR const result_type tempering_d               = __d;
 175   static _LIBCPP_CONSTEXPR const size_t tempering_s                    = __s;
 176   static _LIBCPP_CONSTEXPR const result_type tempering_b               = __b;
 177   static _LIBCPP_CONSTEXPR const size_t tempering_t                    = __t;
 178   static _LIBCPP_CONSTEXPR const result_type tempering_c               = __c;
 179   static _LIBCPP_CONSTEXPR const size_t tempering_l                    = __l;
 180   static _LIBCPP_CONSTEXPR const result_type initialization_multiplier = __f;
 181   _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type min() { return _Min; }
 182   _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR result_type max() { return _Max; }
 183   static _LIBCPP_CONSTEXPR const result_type default_seed = 5489u;
 184
 185   // constructors and seeding functions
 186 #ifndef _LIBCPP_CXX03_LANG
 187   _LIBCPP_HIDE_FROM_ABI mersenne_twister_engine() : mersenne_twister_engine(default_seed) {}
 188   _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(result_type __sd) { seed(__sd); }
 189 #else
 190   _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(result_type __sd = default_seed) { seed(__sd); }
 191 #endif
 192   template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0>
 193   _LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(_Sseq& __q) {
 194     seed(__q);
 195   }
 196   _LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed);
 197   template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0>
 198   _LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
 199     __seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());
 200   }
 201
 202   // generating functions
 203   _LIBCPP_HIDE_FROM_ABI result_type operator()();
 204   _LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
 205     for (; __z; --__z)
 206       operator()();
 207   }
 208
 209   template <class _UInt,
 210             size_t _Wp,
 211             size_t _Np,
 212             size_t _Mp,
 213             size_t _Rp,
 214             _UInt _Ap,
 215             size_t _Up,
 216             _UInt _Dp,
 217             size_t _Sp,
 218             _UInt _Bp,
 219             size_t _Tp,
 220             _UInt _Cp,
 221             size_t _Lp,
 222             _UInt _Fp>
 223   friend bool operator==(
 224       const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
 225       const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
 226
 227   template <class _UInt,
 228             size_t _Wp,
 229             size_t _Np,
 230             size_t _Mp,
 231             size_t _Rp,
 232             _UInt _Ap,
 233             size_t _Up,
 234             _UInt _Dp,
 235             size_t _Sp,
 236             _UInt _Bp,
 237             size_t _Tp,
 238             _UInt _Cp,
 239             size_t _Lp,
 240             _UInt _Fp>
 241   friend bool operator!=(
 242       const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
 243       const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
 244
 245   template <class _CharT,
 246             class _Traits,
 247             class _UInt,
 248             size_t _Wp,
 249             size_t _Np,
 250             size_t _Mp,
 251             size_t _Rp,
 252             _UInt _Ap,
 253             size_t _Up,
 254             _UInt _Dp,
 255             size_t _Sp,
 256             _UInt _Bp,
 257             size_t _Tp,
 258             _UInt _Cp,
 259             size_t _Lp,
 260             _UInt _Fp>
 261   friend basic_ostream<_CharT, _Traits>& operator<<(
 262       basic_ostream<_CharT, _Traits>& __os,
 263       const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 264
 265   template <class _CharT,
 266             class _Traits,
 267             class _UInt,
 268             size_t _Wp,
 269             size_t _Np,
 270             size_t _Mp,
 271             size_t _Rp,
 272             _UInt _Ap,
 273             size_t _Up,
 274             _UInt _Dp,
 275             size_t _Sp,
 276             _UInt _Bp,
 277             size_t _Tp,
 278             _UInt _Cp,
 279             size_t _Lp,
 280             _UInt _Fp>
 281   friend basic_istream<_CharT, _Traits>&
 282   operator>>(basic_istream<_CharT, _Traits>& __is,
 283              mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x);
 284
 285 private:
 286   template <class _Sseq>
 287   _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);
 288   template <class _Sseq>
 289   _LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);
 290
 291   template <size_t __count,
 292             __enable_if_t<__count< __w, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type __x) {
 293     return (__x << __count) & _Max;
 294   }
 295
 296   template <size_t __count, __enable_if_t<(__count >= __w), int> = 0>
 297   _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type) {
 298     return result_type(0);
 299   }
 300
 301   template <size_t __count,
 302             __enable_if_t<__count< _Dt, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __rshift(result_type __x) {
 303     return __x >> __count;
 304   }
 305
 306   template <size_t __count, __enable_if_t<(__count >= _Dt), int> = 0>
 307   _LIBCPP_HIDE_FROM_ABI static result_type __rshift(result_type) {
 308     return result_type(0);
 309   }
 310 };
 311
 312 template <class _UIntType,
 313           size_t __w,
 314           size_t __n,
 315           size_t __m,
 316           size_t __r,
 317           _UIntType __a,
 318           size_t __u,
 319           _UIntType __d,
 320           size_t __s,
 321           _UIntType __b,
 322           size_t __t,
 323           _UIntType __c,
 324           size_t __l,
 325           _UIntType __f>
 326 _LIBCPP_CONSTEXPR const size_t
 327     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::word_size;
 328
 329 template <class _UIntType,
 330           size_t __w,
 331           size_t __n,
 332           size_t __m,
 333           size_t __r,
 334           _UIntType __a,
 335           size_t __u,
 336           _UIntType __d,
 337           size_t __s,
 338           _UIntType __b,
 339           size_t __t,
 340           _UIntType __c,
 341           size_t __l,
 342           _UIntType __f>
 343 _LIBCPP_CONSTEXPR const size_t
 344     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::state_size;
 345
 346 template <class _UIntType,
 347           size_t __w,
 348           size_t __n,
 349           size_t __m,
 350           size_t __r,
 351           _UIntType __a,
 352           size_t __u,
 353           _UIntType __d,
 354           size_t __s,
 355           _UIntType __b,
 356           size_t __t,
 357           _UIntType __c,
 358           size_t __l,
 359           _UIntType __f>
 360 _LIBCPP_CONSTEXPR const size_t
 361     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::shift_size;
 362
 363 template <class _UIntType,
 364           size_t __w,
 365           size_t __n,
 366           size_t __m,
 367           size_t __r,
 368           _UIntType __a,
 369           size_t __u,
 370           _UIntType __d,
 371           size_t __s,
 372           _UIntType __b,
 373           size_t __t,
 374           _UIntType __c,
 375           size_t __l,
 376           _UIntType __f>
 377 _LIBCPP_CONSTEXPR const size_t
 378     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::mask_bits;
 379
 380 template <class _UIntType,
 381           size_t __w,
 382           size_t __n,
 383           size_t __m,
 384           size_t __r,
 385           _UIntType __a,
 386           size_t __u,
 387           _UIntType __d,
 388           size_t __s,
 389           _UIntType __b,
 390           size_t __t,
 391           _UIntType __c,
 392           size_t __l,
 393           _UIntType __f>
 394 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
 395     _UIntType,
 396     __w,
 397     __n,
 398     __m,
 399     __r,
 400     __a,
 401     __u,
 402     __d,
 403     __s,
 404     __b,
 405     __t,
 406     __c,
 407     __l,
 408     __f>::result_type
 409     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::xor_mask;
 410
 411 template <class _UIntType,
 412           size_t __w,
 413           size_t __n,
 414           size_t __m,
 415           size_t __r,
 416           _UIntType __a,
 417           size_t __u,
 418           _UIntType __d,
 419           size_t __s,
 420           _UIntType __b,
 421           size_t __t,
 422           _UIntType __c,
 423           size_t __l,
 424           _UIntType __f>
 425 _LIBCPP_CONSTEXPR const size_t
 426     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_u;
 427
 428 template <class _UIntType,
 429           size_t __w,
 430           size_t __n,
 431           size_t __m,
 432           size_t __r,
 433           _UIntType __a,
 434           size_t __u,
 435           _UIntType __d,
 436           size_t __s,
 437           _UIntType __b,
 438           size_t __t,
 439           _UIntType __c,
 440           size_t __l,
 441           _UIntType __f>
 442 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
 443     _UIntType,
 444     __w,
 445     __n,
 446     __m,
 447     __r,
 448     __a,
 449     __u,
 450     __d,
 451     __s,
 452     __b,
 453     __t,
 454     __c,
 455     __l,
 456     __f>::result_type
 457     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_d;
 458
 459 template <class _UIntType,
 460           size_t __w,
 461           size_t __n,
 462           size_t __m,
 463           size_t __r,
 464           _UIntType __a,
 465           size_t __u,
 466           _UIntType __d,
 467           size_t __s,
 468           _UIntType __b,
 469           size_t __t,
 470           _UIntType __c,
 471           size_t __l,
 472           _UIntType __f>
 473 _LIBCPP_CONSTEXPR const size_t
 474     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_s;
 475
 476 template <class _UIntType,
 477           size_t __w,
 478           size_t __n,
 479           size_t __m,
 480           size_t __r,
 481           _UIntType __a,
 482           size_t __u,
 483           _UIntType __d,
 484           size_t __s,
 485           _UIntType __b,
 486           size_t __t,
 487           _UIntType __c,
 488           size_t __l,
 489           _UIntType __f>
 490 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
 491     _UIntType,
 492     __w,
 493     __n,
 494     __m,
 495     __r,
 496     __a,
 497     __u,
 498     __d,
 499     __s,
 500     __b,
 501     __t,
 502     __c,
 503     __l,
 504     __f>::result_type
 505     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_b;
 506
 507 template <class _UIntType,
 508           size_t __w,
 509           size_t __n,
 510           size_t __m,
 511           size_t __r,
 512           _UIntType __a,
 513           size_t __u,
 514           _UIntType __d,
 515           size_t __s,
 516           _UIntType __b,
 517           size_t __t,
 518           _UIntType __c,
 519           size_t __l,
 520           _UIntType __f>
 521 _LIBCPP_CONSTEXPR const size_t
 522     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_t;
 523
 524 template <class _UIntType,
 525           size_t __w,
 526           size_t __n,
 527           size_t __m,
 528           size_t __r,
 529           _UIntType __a,
 530           size_t __u,
 531           _UIntType __d,
 532           size_t __s,
 533           _UIntType __b,
 534           size_t __t,
 535           _UIntType __c,
 536           size_t __l,
 537           _UIntType __f>
 538 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
 539     _UIntType,
 540     __w,
 541     __n,
 542     __m,
 543     __r,
 544     __a,
 545     __u,
 546     __d,
 547     __s,
 548     __b,
 549     __t,
 550     __c,
 551     __l,
 552     __f>::result_type
 553     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_c;
 554
 555 template <class _UIntType,
 556           size_t __w,
 557           size_t __n,
 558           size_t __m,
 559           size_t __r,
 560           _UIntType __a,
 561           size_t __u,
 562           _UIntType __d,
 563           size_t __s,
 564           _UIntType __b,
 565           size_t __t,
 566           _UIntType __c,
 567           size_t __l,
 568           _UIntType __f>
 569 _LIBCPP_CONSTEXPR const size_t
 570     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::tempering_l;
 571
 572 template <class _UIntType,
 573           size_t __w,
 574           size_t __n,
 575           size_t __m,
 576           size_t __r,
 577           _UIntType __a,
 578           size_t __u,
 579           _UIntType __d,
 580           size_t __s,
 581           _UIntType __b,
 582           size_t __t,
 583           _UIntType __c,
 584           size_t __l,
 585           _UIntType __f>
 586 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
 587     _UIntType,
 588     __w,
 589     __n,
 590     __m,
 591     __r,
 592     __a,
 593     __u,
 594     __d,
 595     __s,
 596     __b,
 597     __t,
 598     __c,
 599     __l,
 600     __f>::result_type
 601     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::
 602         initialization_multiplier;
 603
 604 template <class _UIntType,
 605           size_t __w,
 606           size_t __n,
 607           size_t __m,
 608           size_t __r,
 609           _UIntType __a,
 610           size_t __u,
 611           _UIntType __d,
 612           size_t __s,
 613           _UIntType __b,
 614           size_t __t,
 615           _UIntType __c,
 616           size_t __l,
 617           _UIntType __f>
 618 _LIBCPP_CONSTEXPR const typename mersenne_twister_engine<
 619     _UIntType,
 620     __w,
 621     __n,
 622     __m,
 623     __r,
 624     __a,
 625     __u,
 626     __d,
 627     __s,
 628     __b,
 629     __t,
 630     __c,
 631     __l,
 632     __f>::result_type
 633     mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::default_seed;
 634
 635 template <class _UIntType,
 636           size_t __w,
 637           size_t __n,
 638           size_t __m,
 639           size_t __r,
 640           _UIntType __a,
 641           size_t __u,
 642           _UIntType __d,
 643           size_t __s,
 644           _UIntType __b,
 645           size_t __t,
 646           _UIntType __c,
 647           size_t __l,
 648           _UIntType __f>
 649 void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::seed(
 650     result_type __sd) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { // __w >= 2
 651   __x_[0] = __sd & _Max;
 652   for (size_t __i = 1; __i < __n; ++__i)
 653     __x_[__i] = (__f * (__x_[__i - 1] ^ __rshift<__w - 2>(__x_[__i - 1])) + __i) & _Max;
 654   __i_ = 0;
 655 }
 656
 657 template <class _UIntType,
 658           size_t __w,
 659           size_t __n,
 660           size_t __m,
 661           size_t __r,
 662           _UIntType __a,
 663           size_t __u,
 664           _UIntType __d,
 665           size_t __s,
 666           _UIntType __b,
 667           size_t __t,
 668           _UIntType __c,
 669           size_t __l,
 670           _UIntType __f>
 671 template <class _Sseq>
 672 void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed(
 673     _Sseq& __q, integral_constant<unsigned, 1>) {
 674   const unsigned __k = 1;
 675   uint32_t __ar[__n * __k];
 676   __q.generate(__ar, __ar + __n * __k);
 677   for (size_t __i = 0; __i < __n; ++__i)
 678     __x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
 679   const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
 680   __i_                     = 0;
 681   if ((__x_[0] & ~__mask) == 0) {
 682     for (size_t __i = 1; __i < __n; ++__i)
 683       if (__x_[__i] != 0)
 684         return;
 685     __x_[0] = result_type(1) << (__w - 1);
 686   }
 687 }
 688
 689 template <class _UIntType,
 690           size_t __w,
 691           size_t __n,
 692           size_t __m,
 693           size_t __r,
 694           _UIntType __a,
 695           size_t __u,
 696           _UIntType __d,
 697           size_t __s,
 698           _UIntType __b,
 699           size_t __t,
 700           _UIntType __c,
 701           size_t __l,
 702           _UIntType __f>
 703 template <class _Sseq>
 704 void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed(
 705     _Sseq& __q, integral_constant<unsigned, 2>) {
 706   const unsigned __k = 2;
 707   uint32_t __ar[__n * __k];
 708   __q.generate(__ar, __ar + __n * __k);
 709   for (size_t __i = 0; __i < __n; ++__i)
 710     __x_[__i] = static_cast<result_type>((__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
 711   const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
 712   __i_                     = 0;
 713   if ((__x_[0] & ~__mask) == 0) {
 714     for (size_t __i = 1; __i < __n; ++__i)
 715       if (__x_[__i] != 0)
 716         return;
 717     __x_[0] = result_type(1) << (__w - 1);
 718   }
 719 }
 720
 721 template <class _UIntType,
 722           size_t __w,
 723           size_t __n,
 724           size_t __m,
 725           size_t __r,
 726           _UIntType __a,
 727           size_t __u,
 728           _UIntType __d,
 729           size_t __s,
 730           _UIntType __b,
 731           size_t __t,
 732           _UIntType __c,
 733           size_t __l,
 734           _UIntType __f>
 735 _UIntType
 736 mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::operator()() {
 737   const size_t __j         = (__i_ + 1) % __n;
 738   const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
 739   const result_type __yp   = (__x_[__i_] & ~__mask) | (__x_[__j] & __mask);
 740   const size_t __k         = (__i_ + __m) % __n;
 741   __x_[__i_]               = __x_[__k] ^ __rshift<1>(__yp) ^ (__a * (__yp & 1));
 742   result_type __z          = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
 743   __i_                     = __j;
 744   __z ^= __lshift<__s>(__z) & __b;
 745   __z ^= __lshift<__t>(__z) & __c;
 746   return __z ^ __rshift<__l>(__z);
 747 }
 748
 749 template <class _UInt,
 750           size_t _Wp,
 751           size_t _Np,
 752           size_t _Mp,
 753           size_t _Rp,
 754           _UInt _Ap,
 755           size_t _Up,
 756           _UInt _Dp,
 757           size_t _Sp,
 758           _UInt _Bp,
 759           size_t _Tp,
 760           _UInt _Cp,
 761           size_t _Lp,
 762           _UInt _Fp>
 763 _LIBCPP_HIDE_FROM_ABI bool
 764 operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
 765            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y) {
 766   if (__x.__i_ == __y.__i_)
 767     return std::equal(__x.__x_, __x.__x_ + _Np, __y.__x_);
 768   if (__x.__i_ == 0 || __y.__i_ == 0) {
 769     size_t __j = std::min(_Np - __x.__i_, _Np - __y.__i_);
 770     if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j, __y.__x_ + __y.__i_))
 771       return false;
 772     if (__x.__i_ == 0)
 773       return std::equal(__x.__x_ + __j, __x.__x_ + _Np, __y.__x_);
 774     return std::equal(__x.__x_, __x.__x_ + (_Np - __j), __y.__x_ + __j);
 775   }
 776   if (__x.__i_ < __y.__i_) {
 777     size_t __j = _Np - __y.__i_;
 778     if (!std::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j), __y.__x_ + __y.__i_))
 779       return false;
 780     if (!std::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _Np, __y.__x_))
 781       return false;
 782     return std::equal(__x.__x_, __x.__x_ + __x.__i_, __y.__x_ + (_Np - (__x.__i_ + __j)));
 783   }
 784   size_t __j = _Np - __x.__i_;
 785   if (!std::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j), __x.__x_ + __x.__i_))
 786     return false;
 787   if (!std::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _Np, __x.__x_))
 788     return false;
 789   return std::equal(__y.__x_, __y.__x_ + __y.__i_, __x.__x_ + (_Np - (__y.__i_ + __j)));
 790 }
 791
 792 template <class _UInt,
 793           size_t _Wp,
 794           size_t _Np,
 795           size_t _Mp,
 796           size_t _Rp,
 797           _UInt _Ap,
 798           size_t _Up,
 799           _UInt _Dp,
 800           size_t _Sp,
 801           _UInt _Bp,
 802           size_t _Tp,
 803           _UInt _Cp,
 804           size_t _Lp,
 805           _UInt _Fp>
 806 inline _LIBCPP_HIDE_FROM_ABI bool
 807 operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
 808            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y) {
 809   return !(__x == __y);
 810 }
 811
 812 template <class _CharT,
 813           class _Traits,
 814           class _UInt,
 815           size_t _Wp,
 816           size_t _Np,
 817           size_t _Mp,
 818           size_t _Rp,
 819           _UInt _Ap,
 820           size_t _Up,
 821           _UInt _Dp,
 822           size_t _Sp,
 823           _UInt _Bp,
 824           size_t _Tp,
 825           _UInt _Cp,
 826           size_t _Lp,
 827           _UInt _Fp>
 828 _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
 829 operator<<(basic_ostream<_CharT, _Traits>& __os,
 830            const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x) {
 831   __save_flags<_CharT, _Traits> __lx(__os);
 832   typedef basic_ostream<_CharT, _Traits> _Ostream;
 833   __os.flags(_Ostream::dec | _Ostream::left);
 834   _CharT __sp = __os.widen(' ');
 835   __os.fill(__sp);
 836   __os << __x.__x_[__x.__i_];
 837   for (size_t __j = __x.__i_ + 1; __j < _Np; ++__j)
 838     __os << __sp << __x.__x_[__j];
 839   for (size_t __j = 0; __j < __x.__i_; ++__j)
 840     __os << __sp << __x.__x_[__j];
 841   return __os;
 842 }
 843
 844 template <class _CharT,
 845           class _Traits,
 846           class _UInt,
 847           size_t _Wp,
 848           size_t _Np,
 849           size_t _Mp,
 850           size_t _Rp,
 851           _UInt _Ap,
 852           size_t _Up,
 853           _UInt _Dp,
 854           size_t _Sp,
 855           _UInt _Bp,
 856           size_t _Tp,
 857           _UInt _Cp,
 858           size_t _Lp,
 859           _UInt _Fp>
 860 _LIBCPP_HIDE_FROM_ABI basic_istream<_CharT, _Traits>&
 861 operator>>(basic_istream<_CharT, _Traits>& __is,
 862            mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x) {
 863   __save_flags<_CharT, _Traits> __lx(__is);
 864   typedef basic_istream<_CharT, _Traits> _Istream;
 865   __is.flags(_Istream::dec | _Istream::skipws);
 866   _UInt __t[_Np];
 867   for (size_t __i = 0; __i < _Np; ++__i)
 868     __is >> __t[__i];
 869   if (!__is.fail()) {
 870     for (size_t __i = 0; __i < _Np; ++__i)
 871       __x.__x_[__i] = __t[__i];
 872     __x.__i_ = 0;
 873   }
 874   return __is;
 875 }
 876
 877 typedef mersenne_twister_engine<
 878     uint_fast32_t,
 879     32,
 880     624,
 881     397,
 882     31,
 883     0x9908b0df,
 884     11,
 885     0xffffffff,
 886     7,
 887     0x9d2c5680,
 888     15,
 889     0xefc60000,
 890     18,
 891     1812433253>
 892     mt19937;
 893 typedef mersenne_twister_engine<
 894     uint_fast64_t,
 895     64,
 896     312,
 897     156,
 898     31,
 899     0xb5026f5aa96619e9ULL,
 900     29,
 901     0x5555555555555555ULL,
 902     17,
 903     0x71d67fffeda60000ULL,
 904     37,
 905     0xfff7eee000000000ULL,
 906     43,
 907     6364136223846793005ULL>
 908     mt19937_64;
 909
 910 _LIBCPP_END_NAMESPACE_STD
 911
 912 _LIBCPP_POP_MACROS
 913
 914 #endif // _LIBCPP___RANDOM_MERSENNE_TWISTER_ENGINE_H