00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055 #include "RandomLib/Random.hpp"
00056
00057 #include <fstream>
00058 #include <ctime>
00059 #include <sstream>
00060 #include <iomanip>
00061 #if !WINDOWS
00062 #include <sys/time.h>
00063 #include <unistd.h>
00064 #else
00065 #include <windows.h>
00066 #include <winbase.h>
00067 #include <process.h>
00068 #define getpid _getpid
00069 #define gmtime_r(t,g) gmtime_s(g,t)
00070 #endif
00071
00072 #if WINDOWS || defined(__CYGWIN__)
00073 #define strtoull strtoul
00074 #endif
00075
00076 #define RANDOM_CPP "$Id: Random.cpp 6505 2009-01-12 03:34:23Z ckarney $"
00077
00078 RCSID_DECL(RANDOM_CPP);
00079 RCSID_DECL(RANDOMTYPE_HPP);
00080 RCSID_DECL(RANDOMSEED_HPP);
00081 RCSID_DECL(RANDOMENGINE_HPP);
00082 RCSID_DECL(RANDOMMIXER_HPP);
00083 RCSID_DECL(RANDOMALGORITHM_HPP);
00084 RCSID_DECL(RANDOMPOWER2_HPP);
00085 RCSID_DECL(RANDOMCANONICAL_HPP);
00086
00087 namespace RandomLib {
00088
00089
00090
00091 template<>
00092 void Random_u32::Write32(std::ostream& os, bool bin, int& cnt,
00093 Random_u32::type x)
00094 throw(std::ios::failure) {
00095 if (bin) {
00096 unsigned char buf[4];
00097
00098 buf[3] = (unsigned char)(x);
00099 buf[2] = (unsigned char)(x >>= 8);
00100 buf[1] = (unsigned char)(x >>= 8);
00101 buf[0] = (unsigned char)(x >>= 8);
00102 os.write(reinterpret_cast<const char *>(buf), 4);
00103 } else {
00104 const int longsperline = 72/9;
00105
00106
00107 std::ostringstream str;
00108
00109 if (cnt > 0)
00110
00111 str << (cnt % longsperline ? ' ' : '\n');
00112 str << std::hex << x;
00113 os << str.str();
00114 ++cnt;
00115 }
00116 }
00117
00118 template<>
00119 void Random_u32::Read32(std::istream& is, bool bin, Random_u32::type& x)
00120 throw(std::ios::failure) {
00121 if (bin) {
00122 unsigned char buf[4];
00123 is.read(reinterpret_cast<char *>(buf), 4);
00124
00125 x = Random_u32::type(buf[0]) << 24 | Random_u32::type(buf[1]) << 16 |
00126 Random_u32::type(buf[2]) << 8 | Random_u32::type(buf[3]);
00127 } else {
00128 std::string s;
00129 is >> std::ws >> s;
00130
00131
00132 std::istringstream str(s);
00133 str >> std::hex >> x;
00134 }
00135 x &= Random_u32::mask;
00136 }
00137
00138 template<>
00139 void Random_u64::Write32(std::ostream& os, bool bin, int& cnt,
00140 Random_u64::type x)
00141 throw(std::ios::failure) {
00142 Random_u32::Write32(os, bin, cnt, Random_u32::cast(x >> 32));
00143 Random_u32::Write32(os, bin, cnt, Random_u32::cast(x ));
00144 }
00145
00146 template<>
00147 void Random_u64::Read32(std::istream& is, bool bin, Random_u64::type& x)
00148 throw(std::ios::failure) {
00149 Random_u32::type t;
00150 Random_u32::Read32(is, bin, t);
00151 x = Random_u64::type(t) << 32;
00152 Random_u32::Read32(is, bin, t);
00153 x |= Random_u64::type(t);
00154 }
00155
00156
00157
00158 RandomSeed::seed_type RandomSeed::SeedWord() {
00159
00160
00161 STATIC_ASSERT(std::numeric_limits<seed_type>::radix == 2 &&
00162 !std::numeric_limits<seed_type>::is_signed &&
00163 std::numeric_limits<seed_type>::digits >= 32,
00164 "seed_type is a bad type");
00165 u32::type t = 0;
00166
00167
00168 {
00169 std::ifstream f("/dev/urandom", std::ios::binary | std::ios::in);
00170 if (f.good()) {
00171
00172 f.read(reinterpret_cast<char *>(&t), sizeof(t));
00173 }
00174 }
00175 std::vector<seed_type> v = SeedVector();
00176 for (size_t i = v.size(); i--;)
00177 u32::CheckSum(v[i], t);
00178 return seed_t::cast(t);
00179 }
00180
00181 std::vector<RandomSeed::seed_type> RandomSeed::SeedVector() {
00182 std::vector<seed_type> v;
00183 {
00184
00185 #if !WINDOWS
00186 timeval tv;
00187 if (gettimeofday(&tv, 0) == 0)
00188 v.push_back(seed_t::cast(tv.tv_usec));
00189 #else
00190 LARGE_INTEGER taux;
00191 if (QueryPerformanceCounter((LARGE_INTEGER *)&taux)) {
00192 v.push_back(seed_t::cast(taux.LowPart));
00193 v.push_back(seed_t::cast(taux.HighPart));
00194 }
00195 #endif
00196 }
00197
00198 const time_t tim = std::time(0);
00199 v.push_back(seed_t::cast(seed_type(tim)));
00200
00201 v.push_back(seed_t::cast(getpid()));
00202 #if !WINDOWS
00203
00204 v.push_back(seed_t::cast(gethostid()));
00205 #endif
00206 {
00207
00208 tm gt;
00209 gmtime_r(&tim, >);
00210 v.push_back((seed_type(1900) + seed_t::cast(gt.tm_year)));
00211 }
00212 std::transform(v.begin(), v.end(), v.begin(), seed_t::cast<seed_type>);
00213 return v;
00214 }
00215
00216 std::vector<RandomSeed::seed_type>
00217 RandomSeed::StringToVector(const std::string& s)
00218 throw(std::bad_alloc) {
00219 std::vector<seed_type> v(0);
00220 const char* c = s.c_str();
00221 char* q;
00222 std::string::size_type p = 0;
00223 while (true) {
00224 p = s.find_first_of("0123456789", p);
00225 if (p == std::string::npos)
00226 break;
00227 v.push_back(seed_t::cast(std::strtoull(c + p, &q, 0)));
00228 p = q - c;
00229 }
00230 return v;
00231 }
00232
00233
00234
00235 template<class Algorithm, class Mixer>
00236 void RandomEngine<Algorithm, Mixer>::Init() throw() {
00237
00238
00239 STATIC_ASSERT(std::numeric_limits<typename mixer_t::type>::radix == 2 &&
00240 !std::numeric_limits<typename mixer_t::type>::is_signed &&
00241 std::numeric_limits<typename mixer_t::type>::digits >=
00242 int(mixer_t::width),
00243 "mixer_type is a bad type");
00244
00245 STATIC_ASSERT(std::numeric_limits<result_type>::radix == 2 &&
00246 !std::numeric_limits<result_type>::is_signed &&
00247 std::numeric_limits<result_type>::digits >= width,
00248 "engine_type is a bad type");
00249
00250 STATIC_ASSERT(mixer_t::width == 32 || mixer_t::width == 64,
00251 "Mixer width must be 32 or 64");
00252
00253 STATIC_ASSERT(width == 32 || width == 64,
00254 "Algorithm width must be 32 or 64");
00255
00256
00257 STATIC_ASSERT(!(mixer_t::width == width) ||
00258 sizeof(_stateu) == sizeof(_state),
00259 "Same bit-widths but different storage");
00260
00261
00262
00263 STATIC_ASSERT(!(mixer_t::width < width) ||
00264 sizeof(_stateu) >= sizeof(_state),
00265 "Narrow data type uses less storage");
00266
00267 STATIC_ASSERT(!(mixer_t::width > width) ||
00268 sizeof(_stateu) <= sizeof(_state),
00269 "Narrow data type uses less storage");
00270
00271
00272
00273 STATIC_ASSERT(sizeof(_statev) == sizeof(_state),
00274 "Storage mismatch with internal engine data type");
00275
00276
00277 Mixer::SeedToState(_seed, _stateu, NU);
00278
00279
00280 if (mixer_t::width < width) {
00281 for (size_t i = 0; i < N; ++i)
00282
00283 _state[i] = result_type(_stateu[2*i]) |
00284 result_type(_stateu[2*i + 1]) <<
00285 (mixer_t::width < width ? mixer_t::width : 0);
00286 } else if (mixer_t::width > width) {
00287 for (size_t i = N; i--;)
00288
00289 _state[i] = result_t::cast(_stateu[i>>1] >> width * (i&1u));
00290 }
00291
00292 Algorithm::NormalizeState(_state);
00293
00294 _rounds = -1;
00295 _ptr = N;
00296 }
00297
00298 template<class Algorithm, class Mixer> Random_u32::type
00299 RandomEngine<Algorithm, Mixer>::Check(u64::type v, u32::type e,
00300 u32::type m) const
00301 throw(std::out_of_range) {
00302 if (v != version)
00303 throw std::out_of_range(Name() + ": Unknown version");
00304 if (e != Algorithm::version)
00305 throw std::out_of_range(Name() + ": Algorithm mismatch");
00306 if (m != Mixer::version)
00307 throw std::out_of_range(Name() + ": Mixer mismatch");
00308 u32::type check = 0;
00309 u64::CheckSum(v, check);
00310 u32::CheckSum(e, check);
00311 u32::CheckSum(m, check);
00312 u32::CheckSum(u32::type(_seed.size()), check);
00313 for (std::vector<seed_type>::const_iterator n = _seed.begin();
00314 n != _seed.end(); ++n) {
00315 if (*n != seed_t::cast(*n))
00316 throw std::out_of_range(Name() + ": Illegal seed value");
00317 u32::CheckSum(u32::type(*n), check);
00318 }
00319 u32::CheckSum(_ptr, check);
00320 if (_stride == 0 || _stride > UNINIT/2)
00321 throw std::out_of_range(Name() + ": Invalid stride");
00322 u32::CheckSum(_stride, check);
00323 if (_ptr != UNINIT) {
00324 if (_ptr >= N + _stride)
00325 throw std::out_of_range(Name() + ": Invalid pointer");
00326 u64::CheckSum(_rounds, check);
00327 Algorithm::CheckState(_state, check);
00328 }
00329 return check;
00330 }
00331
00332 template<typename Algorithm, typename Mixer>
00333 RandomEngine<Algorithm, Mixer>::RandomEngine(std::istream& is, bool bin)
00334 throw(std::ios::failure, std::out_of_range, std::bad_alloc) {
00335 u64::type versionr;
00336 u32::type versione, versionm, t;
00337 u64::Read32(is, bin, versionr);
00338 u32::Read32(is, bin, versione);
00339 u32::Read32(is, bin, versionm);
00340 u32::Read32(is, bin, t);
00341 _seed.resize(size_t(t));
00342 for (std::vector<seed_type>::iterator n = _seed.begin();
00343 n != _seed.end(); ++n) {
00344 u32::Read32(is, bin, t);
00345 *n = seed_type(t);
00346 }
00347 u32::Read32(is, bin, t);
00348
00349 _ptr = unsigned(t);
00350 u32::Read32(is, bin, t);
00351 _stride = unsigned(t);
00352 if (_ptr != UNINIT) {
00353 u64::type p;
00354 u64::Read32(is, bin, p);
00355 _rounds = (long long)(p);
00356
00357 _rounds <<= 63 - std::numeric_limits<long long>::digits;
00358 _rounds >>= 63 - std::numeric_limits<long long>::digits;
00359 for (unsigned i = 0; i < N; ++i)
00360 result_t::Read32(is, bin, _state[i]);
00361 }
00362 u32::Read32(is, bin, t);
00363 if (t != Check(versionr, versione, versionm))
00364 throw std::out_of_range(Name() + ": Checksum failure");
00365 }
00366
00367 template<typename Algorithm, typename Mixer>
00368 void RandomEngine<Algorithm, Mixer>::Save(std::ostream& os,
00369 bool bin) const
00370 throw(std::ios::failure) {
00371 u32::type check = Check(version, Algorithm::version, Mixer::version);
00372 int c = 0;
00373 u64::Write32(os, bin, c, version);
00374 u32::Write32(os, bin, c, Algorithm::version);
00375 u32::Write32(os, bin, c, Mixer::version);
00376 u32::Write32(os, bin, c, u32::type(_seed.size()));
00377 for (std::vector<seed_type>::const_iterator n = _seed.begin();
00378 n != _seed.end(); ++n)
00379 u32::Write32(os, bin, c, u32::type(*n));
00380 u32::Write32(os, bin, c, _ptr);
00381 u32::Write32(os, bin, c, _stride);
00382 if (_ptr != UNINIT) {
00383 u64::Write32(os, bin, c, u64::type(_rounds));
00384 for (unsigned i = 0; i < N; ++i)
00385 result_t::Write32(os, bin, c, _state[i]);
00386 }
00387 u32::Write32(os, bin, c, check);
00388 }
00389
00390 template<typename Algorithm, typename Mixer>
00391 void RandomEngine<Algorithm, Mixer>::StepCount(long long n) throw() {
00392
00393 if (_ptr == UNINIT)
00394 Init();
00395 const long long ncount = n + Count();
00396 long long nrounds = ncount / N;
00397 int nptr = int(ncount - nrounds * N);
00398
00399
00400
00401 if (nptr < 0) {
00402 --nrounds;
00403 nptr += N;
00404 } else if (nptr == 0 && nrounds > _rounds) {
00405 nptr = N;
00406 --nrounds;
00407 }
00408 if (nrounds != _rounds)
00409 Algorithm::Transition(nrounds - _rounds, _statev);
00410 _rounds = nrounds;
00411 _ptr = nptr;
00412 }
00413
00414 template<typename Algorithm, typename Mixer>
00415 void RandomEngine<Algorithm, Mixer>::SelfTest() {
00416 RandomEngine g(std::vector<seed_type>(0));
00417 g.SetCount(10000-1);
00418 result_type x = g();
00419 if (SelfTestResult(0) && x != SelfTestResult(1))
00420 throw std::out_of_range(Name() + ": Incorrect result with seed " +
00421 g.SeedString());
00422 seed_type s[] = {0x1234U, 0x5678U, 0x9abcU, 0xdef0U};
00423
00424 g.Reseed(s, s+4);
00425 g.StepCount(-20000);
00426 std::string save;
00427 {
00428 std::ostringstream stream;
00429 stream << g << std::endl;
00430 save = stream.str();
00431 }
00432 g.Reset();
00433 {
00434 std::istringstream stream(save);
00435 stream >> g;
00436 }
00437 g.SetCount(10000);
00438 {
00439 std::ostringstream stream;
00440 g.Save(stream, true);
00441 save = stream.str();
00442 }
00443 {
00444 std::istringstream stream(save);
00445 RandomEngine h(std::vector<seed_type>(0));
00446 h.Load(stream, true);
00447 h.SetCount(1000000-1);
00448 x = h();
00449 if (SelfTestResult(0) && x != SelfTestResult(2))
00450 throw std::out_of_range(Name() + ": Incorrect result with seed " +
00451 h.SeedString());
00452 g.SetCount(1000000);
00453 if (h != g)
00454 throw std::out_of_range(Name() + ": Comparison failure");
00455 }
00456 }
00457
00458 template<> Random_u32::type
00459 RandomEngine<MT19937<Random_u32>, MixerMT0<Random_u32> >::
00460 SelfTestResult(unsigned i)
00461 throw() {
00462 return i == 0 ? 1 :
00463 i == 1 ? 4123659995UL : 3016432305UL;
00464 }
00465
00466 template<> Random_u64::type
00467 RandomEngine<MT19937<Random_u64>, MixerMT0<Random_u64> >::
00468 SelfTestResult(unsigned i)
00469 throw() {
00470 return i == 0 ? 1 :
00471 i == 1 ? 9981545732273789042ULL : 1384037754719008581ULL;
00472 }
00473
00474 template<> Random_u32::type
00475 RandomEngine<MT19937<Random_u32>, MixerMT1<Random_u32> >::
00476 SelfTestResult(unsigned i)
00477 throw() {
00478 return i == 0 ? 1 :
00479 i == 1 ? 4123659995UL : 2924523180UL;
00480 }
00481
00482 template<> Random_u64::type
00483 RandomEngine<MT19937<Random_u64>, MixerMT1<Random_u64> >::
00484 SelfTestResult(unsigned i)
00485 throw() {
00486 return i == 0 ? 1 :
00487 i == 1 ? 9981545732273789042ULL : 5481486777409645478ULL;
00488 }
00489
00490 template<> Random_u32::type
00491 RandomEngine<MT19937<Random_u32>, MixerSFMT>::
00492 SelfTestResult(unsigned i)
00493 throw() {
00494 return i == 0 ? 1 :
00495 i == 1 ? 666528879UL : 2183745132UL;
00496 }
00497
00498 template<> Random_u64::type
00499 RandomEngine<MT19937<Random_u64>, MixerSFMT>::
00500 SelfTestResult(unsigned i)
00501 throw() {
00502 return i == 0 ? 1 :
00503 i == 1 ? 12176471137395770412ULL : 66914054428611861ULL;
00504 }
00505
00506 template<> Random_u32::type
00507 RandomEngine<SFMT19937<Random_u32>, MixerSFMT>::
00508 SelfTestResult(unsigned i)
00509 throw() {
00510 return i == 0 ? 1 :
00511 i == 1 ? 2695024307UL : 782200760UL;
00512 }
00513
00514 template<> Random_u64::type
00515 RandomEngine<SFMT19937<Random_u64>, MixerSFMT>::
00516 SelfTestResult(unsigned i)
00517 throw() {
00518 return i == 0 ? 1 :
00519 i == 1 ? 1464461649847485149ULL : 5050640804923595109ULL;
00520 }
00521
00522
00523
00524 template<class RandomType> void MixerMT0<RandomType>::
00525 SeedToState(const std::vector<RandomSeed::seed_type>& seed,
00526 mixer_type state[], unsigned n) throw() {
00527
00528
00529
00530 const unsigned s = unsigned(seed.size());
00531 const unsigned w = mixer_t::width;
00532
00533 mixer_type r = s ? a1 : a0;
00534 state[0] = r;
00535 for (unsigned k = 1; k < n; ++k) {
00536 r = b * (r ^ r >> w - 2) + k;
00537 r &= mask;
00538 state[k] = r;
00539 }
00540 if (s > 0) {
00541 const unsigned m = mixer_t::width / 32,
00542 s2 = (s + m - 1)/m;
00543 unsigned i1 = 1;
00544 r = state[0];
00545 for (unsigned k = (n > s2 ? n : s2), j = 0;
00546 k; --k, i1 = i1 == n - 1 ? 1 : i1 + 1,
00547 j = j == s2 - 1 ? 0 : j + 1 ) {
00548 r = state[i1] ^ c * (r ^ r >> w - 2);
00549 r += j + mixer_type(seed[m * j]) +
00550 (m == 1 || 2 * j + 1 == s ? mixer_type(0) :
00551 mixer_type(seed[m * j + 1]) << w - 32);
00552 r &= mask;
00553 state[i1] = r;
00554 }
00555 for (unsigned k = n - 1; k; --k,
00556 i1 = i1 == n - 1 ? 1 : i1 + 1) {
00557 r = state[i1] ^ d * (r ^ r >> w - 2);
00558 r -= i1;
00559 r &= mask;
00560 state[i1] = r;
00561 }
00562 state[0] = typename mixer_t::type(1) << w - 1;
00563 }
00564 }
00565
00566 template<class RandomType> void MixerMT1<RandomType>::
00567 SeedToState(const std::vector<RandomSeed::seed_type>& seed,
00568 mixer_type state[], unsigned n) throw() {
00569
00570
00571
00572
00573
00574 const unsigned s = unsigned(seed.size());
00575 const unsigned w = mixer_t::width;
00576
00577 mixer_type r = (a + s) & mask;
00578 state[0] = r;
00579 for (unsigned k = 1; k < n; ++k) {
00580 r = b * (r ^ r >> w - 2) + k;
00581 r &= mask;
00582 state[k] = r;
00583 }
00584 if (s > 0) {
00585 const unsigned m = mixer_t::width / 32,
00586 s2 = (s + m - 1)/m;
00587 unsigned i1 = 0;
00588 for (unsigned k = (n > s2 ? n : s2), j = 0;
00589 k; --k, i1 = i1 == n - 1 ? 0 : i1 + 1,
00590 j = j == s2 - 1 ? 0 : j + 1 ) {
00591 r = state[i1] ^ c * (r ^ r >> w - 2);
00592 r += j + mixer_type(seed[m * j]) +
00593 (m == 1 || 2 * j + 1 == s ? mixer_type(0) :
00594 mixer_type(seed[m * j + 1]) << w - 32);
00595 r &= mask;
00596 state[i1] = r;
00597 }
00598 for (unsigned k = n; k; --k,
00599 i1 = i1 == n - 1 ? 0 : i1 + 1) {
00600 r = state[i1] ^ d * (r ^ r >> w - 2);
00601 r -= i1;
00602 r &= mask;
00603 state[i1] = r;
00604 }
00605 }
00606 }
00607
00608 void MixerSFMT::SeedToState(const std::vector<RandomSeed::seed_type>& seed,
00609 mixer_type state[], unsigned n)
00610 throw() {
00611
00612
00613
00614 if (n == 0)
00615 return;
00616
00617 const unsigned s = unsigned(seed.size()),
00618
00619
00620
00621 lag = n >= 623 ? 11 : (n >= 68 ? 7 : (n >= 39 ? 5 :
00622 (n >= 7 ? 3 : (n - 1)/2))),
00623
00624 count = s + 1 > n ? s + 1 : n;
00625
00626 std::fill(state, state + n, mixer_type(a));
00627 const unsigned w = mixer_t::width;
00628
00629 unsigned i = 0, k = (n - lag) / 2, l = k + lag;
00630 mixer_type r = state[n - 1];
00631 for (unsigned j = 0; j < count; ++j,
00632 i = i == n - 1 ? 0 : i + 1,
00633 k = k == n - 1 ? 0 : k + 1,
00634 l = l == n - 1 ? 0 : l + 1) {
00635
00636
00637
00638
00639 r ^= state[i] ^ state[k];
00640 r &= mask;
00641 r = b * (r ^ r >> (w - 5));
00642 state[k] += r;
00643 r += i + (j > s ? 0 : (j ? mixer_type(seed[j - 1]) : s));
00644 state[l] += r;
00645 state[i] = r;
00646 }
00647
00648 for (unsigned j = n; j; --j,
00649 i = i == n - 1 ? 0 : i + 1,
00650 k = k == n - 1 ? 0 : k + 1,
00651 l = l == n - 1 ? 0 : l + 1) {
00652
00653
00654
00655 r += state[i] + state[k];
00656 r &= mask;
00657 r = c * (r ^ r >> (w - 5));
00658 r &= mask;
00659 state[k] ^= r;
00660 r -= i;
00661 r &= mask;
00662 state[l] ^= r;
00663 state[i] = r;
00664 }
00665 }
00666
00667
00668
00669
00670
00671 #define MT19937_STEP(I, J, K) statev[I] = statev[K] ^ \
00672 (statev[J] & engine_type(1) ? magic : engine_type(0)) ^ \
00673 ((statev[I] & upper) | (statev[J] & lower)) >> 1
00674
00675
00676
00677
00678
00679
00680
00681
00682 #define MT19937_REVSTEP(I, J, K) { \
00683 engine_type q = statev[J] ^ statev[K], s = q >> (width - 1); \
00684 q = (q ^ (s ? magic : engine_type(0))) << 1 | s; \
00685 statev[I] = (p & upper) | (q & lower); \
00686 p = q; \
00687 }
00688
00689 template<class RandomType>
00690 void MT19937<RandomType>::Transition(long long count, internal_type statev[])
00691 throw() {
00692 if (count > 0)
00693 for (; count; --count) {
00694
00695 unsigned i = 0;
00696 for (; i < N - M; ++i) MT19937_STEP(i, i + 1, i + M );
00697 for (; i < N - 1; ++i) MT19937_STEP(i, i + 1, i + M - N);
00698 MT19937_STEP(N - 1, 0, M - 1);
00699 }
00700 else if (count < 0)
00701 for (; count; ++count) {
00702
00703 engine_type p = statev[0];
00704
00705 MT19937_REVSTEP(0, N - 1, M - 1);
00706 unsigned i = N - 1;
00707 for (; i > N - M; --i) MT19937_REVSTEP(i, i - 1, i + M - 1 - N);
00708 for (; i ; --i) MT19937_REVSTEP(i, i - 1, i + M - 1 );
00709 MT19937_REVSTEP(0, N - 1, M - 1);
00710 }
00711 }
00712
00713 #undef MT19937_STEP
00714 #undef MT19937_REVSTEP
00715
00716 template<class RandomType>
00717 void MT19937<RandomType>::NormalizeState(engine_type state[]) throw () {
00718
00719
00720
00721 state[0] &= upper;
00722 unsigned i = 0;
00723 while (i < N && state[i] == 0)
00724 ++i;
00725 if (i >= N)
00726 state[0] = engine_type(1) << (width - 1);
00727
00728
00729
00730
00731
00732 engine_type q = state[N - 1] ^ state[M - 1], s = q >> (width - 1);
00733 q = (q ^ (s ? magic : engine_type(0))) << 1 | s;
00734 state[0] = (state[0] & upper) | (q & lower);
00735 }
00736
00737 template<class RandomType>
00738 void MT19937<RandomType>::CheckState(const engine_type state[],
00739 Random_u32::type& check)
00740 throw(std::out_of_range) {
00741 engine_type x = 0;
00742 Random_u32::type c = check;
00743 for (unsigned i = 0; i < N; ++i) {
00744 engine_t::CheckSum(state[i], c);
00745 x |= state[i];
00746 }
00747 if (x == 0)
00748 throw std::out_of_range("MT19937: All-zero state");
00749
00750
00751
00752
00753 engine_type q = state[N - 1] ^ state[M - 1], s = q >> (width - 1);
00754 q = (q ^ (s ? magic : engine_type(0))) << 1 | s;
00755 if ((q ^ state[0]) & lower)
00756 throw std::out_of_range("MT19937: Invalid state");
00757
00758 check = c;
00759 }
00760
00761 #if HAVE_SSE2
00762
00763
00764
00765
00766
00767
00768
00769
00770
00771
00772
00773
00774
00775
00776
00777
00778
00779
00780
00781
00782
00783
00784
00785
00786
00787
00788
00789
00790
00791
00792
00793
00794 #define SFMT19937_STEP128(I, J) { \
00795 internal_type x = _mm_load_si128(statev + I), \
00796 y = _mm_srli_epi32(statev[J], 11), \
00797 z = _mm_srli_si128(s, 1); \
00798 s = _mm_slli_epi32(r, 18); \
00799 z = _mm_xor_si128(z, x); \
00800 x = _mm_slli_si128(x, 1); \
00801 z = _mm_xor_si128(z, s); \
00802 y = _mm_and_si128(y, m); \
00803 z = _mm_xor_si128(z, x); \
00804 s = r; \
00805 r = _mm_xor_si128(z, y); \
00806 _mm_store_si128(statev + I, r); \
00807 }
00808
00809
00810
00811
00812
00813
00814
00815
00816
00817
00818
00819
00820
00821
00822
00823
00824
00825
00826
00827
00828
00829
00830
00831
00832
00833
00834 #define SFMT19937_REVSTEP128(I, J, K, L) { \
00835 internal_type x = _mm_load_si128(statev + I), \
00836 y = _mm_srli_epi32(statev[J], 11), \
00837 z = _mm_slli_epi32(statev[L], 18); \
00838 y = _mm_and_si128(y, m); \
00839 x = _mm_xor_si128(x, _mm_srli_si128(statev[K], 1)); \
00840 x = _mm_xor_si128(x, z); \
00841 x = _mm_xor_si128(x, y); \
00842 x = _mm_xor_si128(_mm_slli_si128(x, 8), x); \
00843 x = _mm_xor_si128(_mm_slli_si128(x, 4), x); \
00844 x = _mm_xor_si128(_mm_slli_si128(x, 2), x); \
00845 x = _mm_xor_si128(_mm_slli_si128(x, 1), x); \
00846 _mm_store_si128(statev + I, x); \
00847 }
00848
00849 template<class RandomType>
00850 void SFMT19937<RandomType>::Transition(long long count, internal_type statev[])
00851 throw() {
00852 const internal_type m = _mm_set_epi32(magic3, magic2, magic1, magic0);
00853 if (count > 0) {
00854 internal_type s = _mm_load_si128(statev + N128 - 2),
00855 r = _mm_load_si128(statev + N128 - 1);
00856 for (; count; --count) {
00857 unsigned i = 0;
00858 for (; i + M128 < N128; ++i) SFMT19937_STEP128(i, i + M128 );
00859 for (; i < N128 ; ++i) SFMT19937_STEP128(i, i + M128 - N128);
00860 }
00861 } else if (count < 0)
00862 for (; count; ++count) {
00863 unsigned i = N128;
00864 for (; i + M128 > N128;) {
00865 --i; SFMT19937_REVSTEP128(i, i + M128 - N128, i - 2, i - 1);
00866 }
00867 for (; i > 2;) {
00868 --i; SFMT19937_REVSTEP128(i, i + M128, i - 2, i - 1);
00869 }
00870 SFMT19937_REVSTEP128(1, M128 + 1, N128 - 1, 0 );
00871 SFMT19937_REVSTEP128(0, M128 , N128 - 2, N128 - 1);
00872 }
00873 }
00874
00875 #undef SFMT19937_STEP128
00876 #undef SFMT19937_REVSTEP128
00877
00878 #elif HAVE_ALTIVEC
00879
00880
00881
00882
00883
00884
00885
00886
00887
00888 #define ALTIVEC_PERM(X, P) vec_perm(X, P, P)
00889
00890 #define SFMT19937_STEP128(I, J) { \
00891 internal_type x = statev[I], \
00892 z = vec_xor(vec_xor(ALTIVEC_PERM(s, right1), x), \
00893 vec_sl(r, bitleft)); \
00894 s = r; \
00895 r = vec_xor(z, \
00896 vec_xor(ALTIVEC_PERM(x, left1), \
00897 vec_and(vec_sr(statev[J], bitright), \
00898 magic))); \
00899 statev[I] = r; \
00900 }
00901
00902 #define SFMT19937_REVSTEP128(I, J, K, L) { \
00903 internal_type x = statev[I], \
00904 y = vec_sr(statev[J], bitright), \
00905 z = vec_sl(statev[L], bitleft); \
00906 y = vec_and(y, magic); \
00907 x = vec_xor(x, ALTIVEC_PERM(statev[K], right1)); \
00908 x = vec_xor(x, z); \
00909 x = vec_xor(x, y); \
00910 x = vec_xor(ALTIVEC_PERM(x, left8), x); \
00911 x = vec_xor(ALTIVEC_PERM(x, left4), x); \
00912 x = vec_xor(ALTIVEC_PERM(x, left2), x); \
00913 statev[I] = vec_xor(ALTIVEC_PERM(x, left1), x); \
00914 }
00915
00916 template<class RandomType>
00917 void SFMT19937<RandomType>::Transition(long long count, internal_type statev[])
00918 throw() {
00919 const internal_type magic = width == 32 ?
00920 (vector unsigned)(magic0, magic1, magic2, magic3) :
00921 (vector unsigned)(magic1, magic0, magic3, magic2),
00922 bitleft = (vector unsigned)(18, 18, 18, 18),
00923 bitright = (vector unsigned)(11, 11, 11, 11);
00924
00925
00926
00927
00928
00929
00930
00931
00932
00933
00934
00935
00936
00937
00938
00939
00940
00941
00942
00943
00944
00945
00946
00947
00948 const vector unsigned char left1 = width == 32 ?
00949 (vector unsigned char)(1,2,3,23, 5,6,7,0, 9,10,11,4, 13,14,15,8) :
00950 (vector unsigned char)(1,2,3,4,5,6,7,31, 9,10,11,12,13,14,15,0),
00951 right1 = width == 32 ?
00952 (vector unsigned char)(7,0,1,2, 11,4,5,6, 15,8,9,10, 17,12,13,14) :
00953 (vector unsigned char)(15,0,1,2,3,4,5,6, 17,8,9,10,11,12,13,14);
00954 if (count > 0) {
00955 internal_type s = statev[N128 - 2],
00956 r = statev[N128 - 1];
00957 for (; count; --count) {
00958 unsigned i = 0;
00959 for (; i + M128 < N128; ++i) SFMT19937_STEP128(i, i + M128 );
00960 for (; i < N128 ; ++i) SFMT19937_STEP128(i, i + M128 - N128);
00961 }
00962 } else if (count < 0) {
00963
00964 const vector unsigned char left2 = width == 32 ?
00965 (vector unsigned char)(2,3,22,22, 6,7,0,1, 10,11,4,5, 14,15,8,9) :
00966 (vector unsigned char)(2,3,4,5,6,7,30,30, 10,11,12,13,14,15,0,1),
00967 left4 = width == 32 ?
00968 (vector unsigned char)(20,20,20,20, 0,1,2,3, 4,5,6,7, 8,9,10,11) :
00969 (vector unsigned char)(4,5,6,7,28,28,28,28, 12,13,14,15,0,1,2,3),
00970 left8 = (vector unsigned char)(24,24,24,24,24,24,24,24,0,1,2,3,4,5,6,7);
00971 for (; count; ++count) {
00972 unsigned i = N128;
00973 for (; i + M128 > N128;) {
00974 --i; SFMT19937_REVSTEP128(i, i + M128 - N128, i - 2, i - 1);
00975 }
00976 for (; i > 2;) {
00977 --i; SFMT19937_REVSTEP128(i, i + M128, i - 2, i - 1);
00978 }
00979 SFMT19937_REVSTEP128(1, M128 + 1, N128 - 1, 0 );
00980 SFMT19937_REVSTEP128(0, M128 , N128 - 2, N128 - 1);
00981 }
00982 }
00983 }
00984
00985 #undef SFMT19937_STEP128
00986 #undef SFMT19937_REVSTEP128
00987 #undef ALTVEC_PERM
00988
00989 #else // neither HAVE_SSE2 or HAVE_ALTIVEC
00990
00991 #define SFMT19937_STEP32(I, J) { \
00992 internal_type t = statev[I] ^ statev[I] << 8 ^ \
00993 statev[J] >> 11 & magic0 ^ \
00994 (s0 >> 8 | s1 << 24) ^ r0 << 18; \
00995 s0 = r0; r0 = t & mask; \
00996 t = statev[I + 1] ^ \
00997 (statev[I + 1] << 8 | statev[I] >> 24) ^ \
00998 statev[J + 1] >> 11 & magic1 ^ \
00999 (s1 >> 8 | s2 << 24) ^ r1 << 18; \
01000 s1 = r1; r1 = t & mask; \
01001 t = statev[I + 2] ^ \
01002 (statev[I + 2] << 8 | statev[I + 1] >> 24) ^ \
01003 statev[J + 2] >> 11 & magic2 ^ \
01004 (s2 >> 8 | s3 << 24) ^ r2 << 18; \
01005 s2 = r2; r2 = t & mask; \
01006 t = statev[I + 3] ^ \
01007 (statev[I + 3] << 8 | statev[I + 2] >> 24) ^ \
01008 statev[J + 3] >> 11 & magic3 ^ s3 >> 8 ^ r3 << 18; \
01009 s3 = r3; r3 = t & mask; \
01010 statev[I ] = r0; statev[I + 1] = r1; \
01011 statev[I + 2] = r2; statev[I + 3] = r3; \
01012 }
01013
01014 #define SFMT19937_REVSTEP32(I, J, K, L) { \
01015 internal_type \
01016 t0 = (statev[I] ^ statev[J] >> 11 & magic0 ^ \
01017 (statev[K] >> 8 | statev[K + 1] << 24) ^ \
01018 statev[L] << 18) & mask, \
01019 t1 = (statev[I + 1] ^ \
01020 statev[J + 1] >> 11 & magic1 ^ \
01021 (statev[K + 1] >> 8 | statev[K + 2] << 24) ^ \
01022 statev[L + 1] << 18) & mask, \
01023 t2 = (statev[I + 2] ^ \
01024 statev[J + 2] >> 11 & magic2 ^ \
01025 (statev[K + 2] >> 8 | statev[K + 3] << 24) ^ \
01026 statev[L + 2] << 18) & mask, \
01027 t3 = (statev[I + 3] ^ \
01028 statev[J + 3] >> 11 & magic3 ^ \
01029 statev[K + 3] >> 8 ^ \
01030 statev[L + 3] << 18) & mask; \
01031 t3 ^= t1; t2 ^= t0; t3 ^= t2; t2 ^= t1; t1 ^= t0; \
01032 t3 ^= t2 >> 16 | t3 << 16 & mask; \
01033 t2 ^= t1 >> 16 | t2 << 16 & mask; \
01034 t1 ^= t0 >> 16 | t1 << 16 & mask; \
01035 t0 ^= t0 << 16 & mask; \
01036 statev[I ] = t0 ^ t0 << 8 & mask; \
01037 statev[I + 1] = t1 ^ (t0 >> 24 | t1 << 8 & mask); \
01038 statev[I + 2] = t2 ^ (t1 >> 24 | t2 << 8 & mask); \
01039 statev[I + 3] = t3 ^ (t2 >> 24 | t3 << 8 & mask); \
01040 }
01041
01042 template<>
01043 void SFMT19937<Random_u32>::Transition(long long count, internal_type statev[])
01044 throw() {
01045 if (count > 0) {
01046
01047 internal_type
01048 s0 = statev[N - 8], s1 = statev[N - 7],
01049 s2 = statev[N - 6], s3 = statev[N - 5],
01050 r0 = statev[N - 4], r1 = statev[N - 3],
01051 r2 = statev[N - 2], r3 = statev[N - 1];
01052 for (; count; --count) {
01053 unsigned i = 0;
01054 for (; i + M < N; i += R) SFMT19937_STEP32(i, i + M );
01055 for (; i < N ; i += R) SFMT19937_STEP32(i, i + M - N);
01056 }
01057 } else if (count < 0)
01058 for (; count; ++count) {
01059 unsigned i = N;
01060 for (; i + M > N;) {
01061 i -= R; SFMT19937_REVSTEP32(i, i + M - N, i - 2 * R, i - R);
01062 }
01063 for (; i > 2 * R;) {
01064 i -= R; SFMT19937_REVSTEP32(i, i + M , i - 2 * R, i - R);
01065 }
01066 SFMT19937_REVSTEP32(R, M + R, N - R, 0 );
01067 SFMT19937_REVSTEP32(0, M , N - 2 * R, N - R);
01068 }
01069 }
01070
01071 #undef SFMT19937_STEP32
01072 #undef SFMT19937_REVSTEP32
01073
01074 #define SFMT19937_STEP64(I, J) { \
01075 internal_type t = statev[I] ^ statev[I] << 8 ^ \
01076 statev[J] >> 11 & magic0 ^ \
01077 (s0 >> 8 | s1 << 56) ^ r0 << 18 & mask18; \
01078 s0 = r0; r0 = t & mask; \
01079 t = statev[I + 1] ^ \
01080 (statev[I + 1] << 8 | statev[I] >> 56) ^ \
01081 statev[J + 1] >> 11 & magic1 ^ \
01082 s1 >> 8 ^ r1 << 18 & mask18; \
01083 s1 = r1; r1 = t & mask; \
01084 statev[I] = r0; statev[I + 1] = r1; \
01085 }
01086
01087
01088
01089
01090
01091
01092 #define SFMT19937_REVSTEP64(I, J, K, L) { \
01093 internal_type \
01094 t0 = statev[I] ^ statev[J] >> 11 & magic0 ^ \
01095 (statev[K] >> 8 | statev[K + 1] << 56 & mask) \
01096 ^ statev[L] << 18 & mask18, \
01097 t1 = statev[I + 1] ^ statev[J + 1] >> 11 & magic1 ^ \
01098 statev[K + 1] >> 8 ^ statev[L + 1] << 18 & mask18; \
01099 t1 ^= t0; \
01100 t1 ^= t0 >> 32 ^ t1 << 32 & mask; \
01101 t0 ^= t0 << 32 & mask; \
01102 t1 ^= t0 >> 48 ^ t1 << 16 & mask; \
01103 t0 ^= t0 << 16 & mask; \
01104 statev[I ] = t0 ^ t0 << 8 & mask; \
01105 statev[I + 1] = t1 ^ t0 >> 56 ^ t1 << 8 & mask; \
01106 }
01107
01108 template<>
01109 void SFMT19937<Random_u64>::Transition(long long count, internal_type statev[])
01110 throw() {
01111
01112 if (count > 0) {
01113 internal_type
01114 s0 = statev[N - 4], s1 = statev[N - 3],
01115 r0 = statev[N - 2], r1 = statev[N - 1];
01116 for (; count; --count) {
01117 unsigned i = 0;
01118 for (; i + M < N; i += R) SFMT19937_STEP64(i, i + M );
01119 for (; i < N ; i += R) SFMT19937_STEP64(i, i + M - N);
01120 }
01121 } else if (count < 0)
01122 for (; count; ++count) {
01123 unsigned i = N;
01124 for (; i + M > N;) {
01125 i -= R; SFMT19937_REVSTEP64(i, i + M - N, i - 2 * R, i - R);
01126 }
01127 for (; i > 2 * R;) {
01128 i -= R; SFMT19937_REVSTEP64(i, i + M , i - 2 * R, i - R);
01129 }
01130 SFMT19937_REVSTEP64(R, M + R, N - R, 0 );
01131 SFMT19937_REVSTEP64(0, M , N - 2 * R, N - R);
01132 }
01133 }
01134
01135 #undef SFMT19937_STEP64
01136 #undef SFMT19937_REVSTEP64
01137
01138 #endif // HAVE_SSE2
01139
01140 template<>
01141 void SFMT19937<Random_u32>::NormalizeState(engine_type state[]) throw () {
01142
01143 engine_type inner = (state[0] & PARITY0) ^ (state[1] & PARITY1) ^
01144 (state[2] & PARITY2) ^ (state[3] & PARITY3);
01145 for (unsigned s = 16; s; s >>= 1)
01146 inner ^= inner >> s;
01147 STATIC_ASSERT(PARITY_LSB < 32 && PARITY0 & 1u << PARITY_LSB,
01148 "inconsistent PARITY_LSB or PARITY0");
01149
01150 if ((inner & 1u) == 0)
01151
01152 state[PARITY_LSB >> 5] ^= engine_type(1u) << (PARITY_LSB & 31u);
01153 }
01154
01155 template<>
01156 void SFMT19937<Random_u64>::NormalizeState(engine_type state[]) throw () {
01157
01158 engine_type inner = (state[0] & PARITY0) ^ (state[1] & PARITY1);
01159 for (unsigned s = 32; s; s >>= 1)
01160 inner ^= inner >> s;
01161 STATIC_ASSERT(PARITY_LSB < 64 && PARITY0 & 1u << PARITY_LSB,
01162 "inconsistent PARITY_LSB or PARITY0");
01163
01164 if ((inner & 1u) == 0)
01165
01166 state[PARITY_LSB >> 6] ^= engine_type(1u) << (PARITY_LSB & 63u);
01167 }
01168
01169 template<class RandomType>
01170 void SFMT19937<RandomType>::CheckState(const engine_type state[],
01171 Random_u32::type& check)
01172 throw(std::out_of_range) {
01173 engine_type x = 0;
01174 Random_u32::type c = check;
01175 for (unsigned i = 0; i < N; ++i) {
01176 engine_t::CheckSum(state[i], c);
01177 x |= state[i];
01178 }
01179 if (x == 0)
01180 throw std::out_of_range("SFMT19937: All-zero state");
01181 check = c;
01182 }
01183
01184
01185
01186 #if RANDOM_POWERTABLE
01187
01188
01189
01190 const float RandomPower2::power2[maxpow - minpow + 1] = {
01191 #if RANDOM_LONGDOUBLEPREC > 64
01192
01193
01194 1/1329227995784915872903807060280344576.f,
01195 1/664613997892457936451903530140172288.f,
01196 1/332306998946228968225951765070086144.f,
01197 1/166153499473114484112975882535043072.f,
01198 1/83076749736557242056487941267521536.f,
01199 1/41538374868278621028243970633760768.f,
01200 1/20769187434139310514121985316880384.f,
01201 1/10384593717069655257060992658440192.f,
01202 1/5192296858534827628530496329220096.f,
01203 1/2596148429267413814265248164610048.f,
01204 1/1298074214633706907132624082305024.f,
01205 1/649037107316853453566312041152512.f,
01206 1/324518553658426726783156020576256.f,
01207 1/162259276829213363391578010288128.f,
01208 1/81129638414606681695789005144064.f,
01209 1/40564819207303340847894502572032.f,
01210 1/20282409603651670423947251286016.f,
01211 1/10141204801825835211973625643008.f,
01212 1/5070602400912917605986812821504.f,
01213 1/2535301200456458802993406410752.f,
01214 1/1267650600228229401496703205376.f,
01215 1/633825300114114700748351602688.f,
01216 1/316912650057057350374175801344.f,
01217 1/158456325028528675187087900672.f,
01218 1/79228162514264337593543950336.f,
01219 1/39614081257132168796771975168.f,
01220 1/19807040628566084398385987584.f,
01221 1/9903520314283042199192993792.f,
01222 1/4951760157141521099596496896.f,
01223 1/2475880078570760549798248448.f,
01224 1/1237940039285380274899124224.f,
01225 1/618970019642690137449562112.f,
01226 1/309485009821345068724781056.f,
01227 1/154742504910672534362390528.f,
01228 1/77371252455336267181195264.f,
01229 1/38685626227668133590597632.f,
01230 1/19342813113834066795298816.f,
01231 1/9671406556917033397649408.f,
01232 1/4835703278458516698824704.f,
01233 1/2417851639229258349412352.f,
01234 1/1208925819614629174706176.f,
01235 1/604462909807314587353088.f,
01236 1/302231454903657293676544.f,
01237 1/151115727451828646838272.f,
01238 1/75557863725914323419136.f,
01239 1/37778931862957161709568.f,
01240 1/18889465931478580854784.f,
01241 1/9444732965739290427392.f,
01242 1/4722366482869645213696.f,
01243 1/2361183241434822606848.f,
01244 1/1180591620717411303424.f,
01245 1/590295810358705651712.f,
01246 1/295147905179352825856.f,
01247 1/147573952589676412928.f,
01248 1/73786976294838206464.f,
01249 1/36893488147419103232.f,
01250 #endif
01251 1/18446744073709551616.f,
01252 1/9223372036854775808.f,
01253 1/4611686018427387904.f,
01254 1/2305843009213693952.f,
01255 1/1152921504606846976.f,
01256 1/576460752303423488.f,
01257 1/288230376151711744.f,
01258 1/144115188075855872.f,
01259 1/72057594037927936.f,
01260 1/36028797018963968.f,
01261 1/18014398509481984.f,
01262 1/9007199254740992.f,
01263 1/4503599627370496.f,
01264 1/2251799813685248.f,
01265 1/1125899906842624.f,
01266 1/562949953421312.f,
01267 1/281474976710656.f,
01268 1/140737488355328.f,
01269 1/70368744177664.f,
01270 1/35184372088832.f,
01271 1/17592186044416.f,
01272 1/8796093022208.f,
01273 1/4398046511104.f,
01274 1/2199023255552.f,
01275 1/1099511627776.f,
01276 1/549755813888.f,
01277 1/274877906944.f,
01278 1/137438953472.f,
01279 1/68719476736.f,
01280 1/34359738368.f,
01281 1/17179869184.f,
01282 1/8589934592.f,
01283 1/4294967296.f,
01284 1/2147483648.f,
01285 1/1073741824.f,
01286 1/536870912.f,
01287 1/268435456.f,
01288 1/134217728.f,
01289 1/67108864.f,
01290 1/33554432.f,
01291 1/16777216.f,
01292 1/8388608.f,
01293 1/4194304.f,
01294 1/2097152.f,
01295 1/1048576.f,
01296 1/524288.f,
01297 1/262144.f,
01298 1/131072.f,
01299 1/65536.f,
01300 1/32768.f,
01301 1/16384.f,
01302 1/8192.f,
01303 1/4096.f,
01304 1/2048.f,
01305 1/1024.f,
01306 1/512.f,
01307 1/256.f,
01308 1/128.f,
01309 1/64.f,
01310 1/32.f,
01311 1/16.f,
01312 1/8.f,
01313 1/4.f,
01314 1/2.f,
01315 1.f,
01316 2.f,
01317 4.f,
01318 8.f,
01319 16.f,
01320 32.f,
01321 64.f,
01322 128.f,
01323 256.f,
01324 512.f,
01325 1024.f,
01326 2048.f,
01327 4096.f,
01328 8192.f,
01329 16384.f,
01330 32768.f,
01331 65536.f,
01332 131072.f,
01333 262144.f,
01334 524288.f,
01335 1048576.f,
01336 2097152.f,
01337 4194304.f,
01338 8388608.f,
01339 16777216.f,
01340 33554432.f,
01341 67108864.f,
01342 134217728.f,
01343 268435456.f,
01344 536870912.f,
01345 1073741824.f,
01346 2147483648.f,
01347 4294967296.f,
01348 8589934592.f,
01349 17179869184.f,
01350 34359738368.f,
01351 68719476736.f,
01352 137438953472.f,
01353 274877906944.f,
01354 549755813888.f,
01355 1099511627776.f,
01356 2199023255552.f,
01357 4398046511104.f,
01358 8796093022208.f,
01359 17592186044416.f,
01360 35184372088832.f,
01361 70368744177664.f,
01362 140737488355328.f,
01363 281474976710656.f,
01364 562949953421312.f,
01365 1125899906842624.f,
01366 2251799813685248.f,
01367 4503599627370496.f,
01368 9007199254740992.f,
01369 18014398509481984.f,
01370 36028797018963968.f,
01371 72057594037927936.f,
01372 144115188075855872.f,
01373 288230376151711744.f,
01374 576460752303423488.f,
01375 1152921504606846976.f,
01376 2305843009213693952.f,
01377 4611686018427387904.f,
01378 9223372036854775808.f,
01379 18446744073709551616.f,
01380 };
01381 #endif
01382
01383
01384
01385
01386 #if RANDOM_LEGACY
01387 template class
01388 RandomEngine<MT19937<Random_u32>, MixerMT0<Random_u32> >;
01389 template class
01390 RandomEngine<MT19937<Random_u64>, MixerMT0<Random_u64> >;
01391 template class
01392 RandomEngine<MT19937<Random_u32>, MixerMT1<Random_u32> >;
01393 template class
01394 RandomEngine<MT19937<Random_u64>, MixerMT1<Random_u64> >;
01395 #endif
01396 template class RandomEngine< MT19937<Random_u32>, MixerSFMT>;
01397 template class RandomEngine< MT19937<Random_u64>, MixerSFMT>;
01398 template class RandomEngine<SFMT19937<Random_u32>, MixerSFMT>;
01399 template class RandomEngine<SFMT19937<Random_u64>, MixerSFMT>;
01400
01401
01402
01403 template<> RandomCanonical<MRandomGenerator32>
01404 RandomCanonical<MRandomGenerator32>::Global(std::vector<unsigned long>(0));
01405 template<> RandomCanonical<MRandomGenerator64>
01406 RandomCanonical<MRandomGenerator64>::Global(std::vector<unsigned long>(0));
01407 template<> RandomCanonical<SRandomGenerator32>
01408 RandomCanonical<SRandomGenerator32>::Global(std::vector<unsigned long>(0));
01409 template<> RandomCanonical<SRandomGenerator64>
01410 RandomCanonical<SRandomGenerator64>::Global(std::vector<unsigned long>(0));
01411
01412 }