1a2,13
> * Copyright (c) 2014 ARM Limited
> * All rights reserved
> *
> * The license below extends only to copyright in the software and shall
> * not be construed as granting a license to any other intellectual
> * property including but not limited to intellectual property relating
> * to a hardware implementation of the functionality of the software
> * licensed hereunder. You may use the software subject to the license
> * terms below provided that you ensure that this notice is replicated
> * unmodified and in its entirety in all distributions of the software,
> * modified or unmodified, in source code or in binary form.
> *
29a42
> * Andreas Hansson
33,36c46
< * Mersenne Twister random number generator has a period of
< * 2^19937-1.
< *
< * The actual math is in its own file to keep the license clear.
---
> * Mersenne twister random number generator.
42c52
< #include <ios>
---
> #include <random>
43a54
> #include <type_traits>
51,56d61
< protected:
< static const int N = 624;
< static const int M = 397;
< static const uint32_t MATRIX_A = (uint32_t)0x9908b0df;
< static const uint32_t UPPER_MASK = (uint32_t)0x80000000;
< static const uint32_t LOWER_MASK = (uint32_t)0x7fffffff;
58,59c63
< uint32_t mt[N];
< int mti;
---
> private:
61,63c65
< uint32_t genrand();
< uint32_t genrand(uint32_t max);
< uint64_t genrand(uint64_t max);
---
> std::mt19937_64 gen;
65,186d66
< void
< _random(int8_t &value)
< {
< value = genrand() & (int8_t)-1;
< }
<
< void
< _random(int16_t &value)
< {
< value = genrand() & (int16_t)-1;
< }
<
< void
< _random(int32_t &value)
< {
< value = (int32_t)genrand();
< }
<
< void
< _random(int64_t &value)
< {
< value = (int64_t)genrand() << 32 | (int64_t)genrand();
< }
<
< void
< _random(uint8_t &value)
< {
< value = genrand() & (uint8_t)-1;
< }
<
< void
< _random(uint16_t &value)
< {
< value = genrand() & (uint16_t)-1;
< }
<
< void
< _random(uint32_t &value)
< {
< value = genrand();
< }
<
< void
< _random(uint64_t &value)
< {
< value = (uint64_t)genrand() << 32 | (uint64_t)genrand();
< }
<
< // [0,1]
< void
< _random(float &value)
< {
< // ieee floats have 23 bits of mantissa
< value = (genrand() >> 9) / 8388608.0;
< }
<
< // [0,1]
< void
< _random(double &value)
< {
< double number = genrand() * 2097152.0 + (genrand() >> 11);
< value = number / 9007199254740992.0;
< }
<
<
< // Range based versions of the random number generator
< int8_t
< _random(int8_t min, int8_t max)
< {
< uint32_t diff = max - min;
< return static_cast<int8_t>(min + genrand(diff));
< }
<
< int16_t
< _random(int16_t min, int16_t max)
< {
< uint32_t diff = max - min;
< return static_cast<int16_t>(min + genrand(diff));
< }
<
< int32_t
< _random(int32_t min, int32_t max)
< {
< uint32_t diff = max - min;
< return static_cast<int32_t>(min + genrand(diff));
< }
<
< int64_t
< _random(int64_t min, int64_t max)
< {
< uint64_t diff = max - min;
< return static_cast<int64_t>(min + genrand(diff));
< }
<
< uint8_t
< _random(uint8_t min, uint8_t max)
< {
< uint32_t diff = max - min;
< return static_cast<uint8_t>(min + genrand(diff));
< }
<
< uint16_t
< _random(uint16_t min, uint16_t max)
< {
< uint32_t diff = max - min;
< return static_cast<uint16_t>(min + genrand(diff));
< }
<
< uint32_t
< _random(uint32_t min, uint32_t max)
< {
< uint32_t diff = max - min;
< return static_cast<uint32_t>(min + genrand(diff));
< }
<
< uint64_t
< _random(uint64_t min, uint64_t max)
< {
< uint64_t diff = max - min;
< return static_cast<uint64_t>(min + genrand(diff));
< }
<
187a68
>
190d70
< Random(uint32_t init_key[], int key_length);
194d73
< void init(uint32_t init_key[], int key_length);
195a75,78
> /**
> * Use the SFINAE idiom to choose an implementation based on
> * whether the type is integral or floating point.
> */
197c80
< T
---
> typename std::enable_if<std::is_integral<T>::value, T>::type
200,202c83,85
< T value;
< _random(value);
< return value;
---
> // [0, max_value] for integer types
> std::uniform_int_distribution<T> dist;
> return dist(gen);
206,207c89,90
< T
< random(T min, T max)
---
> typename std::enable_if<std::is_floating_point<T>::value, T>::type
> random()
209c92,94
< return _random(min, max);
---
> // [0, 1) for real types
> std::uniform_real_distribution<T> dist;
> return dist(gen);
212,214c97,99
< // [0,1]
< double
< gen_real1()
---
> template <typename T>
> typename std::enable_if<std::is_integral<T>::value, T>::type
> random(T min, T max)
216c101,102
< return genrand() / 4294967296.0;
---
> std::uniform_int_distribution<T> dist(min, max);
> return dist(gen);
219,236c105,106
< // [0,1)
< double
< gen_real2()
< {
< return genrand() / 4294967295.0;
< }
<
< // (0,1)
< double
< gen_real3()
< {
< return ((double)genrand() + 0.5) / 4294967296.0;
< }
<
< public:
< void serialize(const std::string &base, std::ostream &os);
< void unserialize(const std::string &base, Checkpoint *cp,
< const std::string &section);
---
> void serialize(std::ostream &os);
> void unserialize(Checkpoint *cp, const std::string &section);