683 lines
24 KiB
C++
683 lines
24 KiB
C++
|
/* boost random/mersenne_twister.hpp header file
|
||
|
|
*
|
||
|
|
* Copyright Jens Maurer 2000-2001
|
||
|
|
* Copyright Steven Watanabe 2010
|
||
|
|
* Distributed under the Boost Software License, Version 1.0. (See
|
||
|
|
* accompanying file LICENSE_1_0.txt or copy at
|
||
|
|
* http://www.boost.org/LICENSE_1_0.txt)
|
||
|
|
*
|
||
|
|
* See http://www.boost.org for most recent version including documentation.
|
||
|
|
*
|
||
|
|
* $Id$
|
||
|
|
*
|
||
|
|
* Revision history
|
||
|
|
* 2013-10-14 fixed some warnings with Wshadow (mgaunard)
|
||
|
|
* 2001-02-18 moved to individual header files
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef BOOST_RANDOM_MERSENNE_TWISTER_HPP
|
||
|
|
#define BOOST_RANDOM_MERSENNE_TWISTER_HPP
|
||
|
|
|
||
|
|
#include <iosfwd>
|
||
|
|
#include <istream>
|
||
|
|
#include <stdexcept>
|
||
|
|
#include <boost/config.hpp>
|
||
|
|
#include <boost/cstdint.hpp>
|
||
|
|
#include <boost/integer/integer_mask.hpp>
|
||
|
|
#include <boost/random/detail/config.hpp>
|
||
|
|
#include <boost/random/detail/ptr_helper.hpp>
|
||
|
|
#include <boost/random/detail/seed.hpp>
|
||
|
|
#include <boost/random/detail/seed_impl.hpp>
|
||
|
|
#include <boost/random/detail/generator_seed_seq.hpp>
|
||
|
|
#include <boost/random/detail/polynomial.hpp>
|
||
|
|
|
||
|
|
#include <boost/random/detail/disable_warnings.hpp>
|
||
|
|
|
||
|
|
namespace boost {
|
||
|
|
namespace random {
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Instantiations of class template mersenne_twister_engine model a
|
||
|
|
* \pseudo_random_number_generator. It uses the algorithm described in
|
||
|
|
*
|
||
|
|
* @blockquote
|
||
|
|
* "Mersenne Twister: A 623-dimensionally equidistributed uniform
|
||
|
|
* pseudo-random number generator", Makoto Matsumoto and Takuji Nishimura,
|
||
|
|
* ACM Transactions on Modeling and Computer Simulation: Special Issue on
|
||
|
|
* Uniform Random Number Generation, Vol. 8, No. 1, January 1998, pp. 3-30.
|
||
|
|
* @endblockquote
|
||
|
|
*
|
||
|
|
* @xmlnote
|
||
|
|
* The boost variant has been implemented from scratch and does not
|
||
|
|
* derive from or use mt19937.c provided on the above WWW site. However, it
|
||
|
|
* was verified that both produce identical output.
|
||
|
|
* @endxmlnote
|
||
|
|
*
|
||
|
|
* The seeding from an integer was changed in April 2005 to address a
|
||
|
|
* <a href="http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html">weakness</a>.
|
||
|
|
*
|
||
|
|
* The quality of the generator crucially depends on the choice of the
|
||
|
|
* parameters. User code should employ one of the sensibly parameterized
|
||
|
|
* generators such as \mt19937 instead.
|
||
|
|
*
|
||
|
|
* The generator requires considerable amounts of memory for the storage of
|
||
|
|
* its state array. For example, \mt11213b requires about 1408 bytes and
|
||
|
|
* \mt19937 requires about 2496 bytes.
|
||
|
|
*/
|
||
|
|
template<class UIntType,
|
||
|
|
std::size_t w, std::size_t n, std::size_t m, std::size_t r,
|
||
|
|
UIntType a, std::size_t u, UIntType d, std::size_t s,
|
||
|
|
UIntType b, std::size_t t,
|
||
|
|
UIntType c, std::size_t l, UIntType f>
|
||
|
|
class mersenne_twister_engine
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
typedef UIntType result_type;
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, word_size = w);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, state_size = n);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, shift_size = m);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, mask_bits = r);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, xor_mask = a);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, tempering_u = u);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, tempering_d = d);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, tempering_s = s);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, tempering_b = b);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, tempering_t = t);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, tempering_c = c);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, tempering_l = l);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, initialization_multiplier = f);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, default_seed = 5489u);
|
||
|
|
|
||
|
|
// backwards compatibility
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, parameter_a = a);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, output_u = u);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, output_s = s);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, output_b = b);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, output_t = t);
|
||
|
|
BOOST_STATIC_CONSTANT(UIntType, output_c = c);
|
||
|
|
BOOST_STATIC_CONSTANT(std::size_t, output_l = l);
|
||
|
|
|
||
|
|
// old Boost.Random concept requirements
|
||
|
|
BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
|
||
|
|
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a @c mersenne_twister_engine and calls @c seed().
|
||
|
|
*/
|
||
|
|
mersenne_twister_engine() { seed(); }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a @c mersenne_twister_engine and calls @c seed(value).
|
||
|
|
*/
|
||
|
|
BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(mersenne_twister_engine,
|
||
|
|
UIntType, value)
|
||
|
|
{ seed(value); }
|
||
|
|
template<class It> mersenne_twister_engine(It& first, It last)
|
||
|
|
{ seed(first,last); }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Constructs a mersenne_twister_engine and calls @c seed(gen).
|
||
|
|
*
|
||
|
|
* @xmlnote
|
||
|
|
* The copy constructor will always be preferred over
|
||
|
|
* the templated constructor.
|
||
|
|
* @endxmlnote
|
||
|
|
*/
|
||
|
|
BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(mersenne_twister_engine,
|
||
|
|
SeedSeq, seq)
|
||
|
|
{ seed(seq); }
|
||
|
|
|
||
|
|
// compiler-generated copy ctor and assignment operator are fine
|
||
|
|
|
||
|
|
/** Calls @c seed(default_seed). */
|
||
|
|
void seed() { seed(default_seed); }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Sets the state x(0) to v mod 2w. Then, iteratively,
|
||
|
|
* sets x(i) to
|
||
|
|
* (i + f * (x(i-1) xor (x(i-1) rshift w-2))) mod 2<sup>w</sup>
|
||
|
|
* for i = 1 .. n-1. x(n) is the first value to be returned by operator().
|
||
|
|
*/
|
||
|
|
BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(mersenne_twister_engine, UIntType, value)
|
||
|
|
{
|
||
|
|
// New seeding algorithm from
|
||
|
|
// http://www.math.sci.hiroshima-u.ac.jp/~m-mat/MT/MT2002/emt19937ar.html
|
||
|
|
// In the previous versions, MSBs of the seed affected only MSBs of the
|
||
|
|
// state x[].
|
||
|
|
const UIntType mask = (max)();
|
||
|
|
x[0] = value & mask;
|
||
|
|
for (i = 1; i < n; i++) {
|
||
|
|
// See Knuth "The Art of Computer Programming"
|
||
|
|
// Vol. 2, 3rd ed., page 106
|
||
|
|
x[i] = (f * (x[i-1] ^ (x[i-1] >> (w-2))) + i) & mask;
|
||
|
|
}
|
||
|
|
|
||
|
|
normalize_state();
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Seeds a mersenne_twister_engine using values produced by seq.generate().
|
||
|
|
*/
|
||
|
|
BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(mersenne_twister_engine, SeeqSeq, seq)
|
||
|
|
{
|
||
|
|
detail::seed_array_int<w>(seq, x);
|
||
|
|
i = n;
|
||
|
|
|
||
|
|
normalize_state();
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Sets the state of the generator using values from an iterator range. */
|
||
|
|
template<class It>
|
||
|
|
void seed(It& first, It last)
|
||
|
|
{
|
||
|
|
detail::fill_array_int<w>(first, last, x);
|
||
|
|
i = n;
|
||
|
|
|
||
|
|
normalize_state();
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Returns the smallest value that the generator can produce. */
|
||
|
|
static result_type min BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||
|
|
{ return 0; }
|
||
|
|
/** Returns the largest value that the generator can produce. */
|
||
|
|
static result_type max BOOST_PREVENT_MACRO_SUBSTITUTION ()
|
||
|
|
{ return boost::low_bits_mask_t<w>::sig_bits; }
|
||
|
|
|
||
|
|
/** Produces the next value of the generator. */
|
||
|
|
result_type operator()();
|
||
|
|
|
||
|
|
/** Fills a range with random values */
|
||
|
|
template<class Iter>
|
||
|
|
void generate(Iter first, Iter last)
|
||
|
|
{ detail::generate_from_int(*this, first, last); }
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Advances the state of the generator by @c z steps. Equivalent to
|
||
|
|
*
|
||
|
|
* @code
|
||
|
|
* for(unsigned long long i = 0; i < z; ++i) {
|
||
|
|
* gen();
|
||
|
|
* }
|
||
|
|
* @endcode
|
||
|
|
*/
|
||
|
|
void discard(boost::uintmax_t z)
|
||
|
|
{
|
||
|
|
#ifndef BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD
|
||
|
|
#define BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD 10000000
|
||
|
|
#endif
|
||
|
|
if(z > BOOST_RANDOM_MERSENNE_TWISTER_DISCARD_THRESHOLD) {
|
||
|
|
discard_many(z);
|
||
|
|
} else {
|
||
|
|
for(boost::uintmax_t j = 0; j < z; ++j) {
|
||
|
|
(*this)();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
#ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
|
||
|
|
/** Writes a mersenne_twister_engine to a @c std::ostream */
|
||
|
|
template<class CharT, class Traits>
|
||
|
|
friend std::basic_ostream<CharT,Traits>&
|
||
|
|
operator<<(std::basic_ostream<CharT,Traits>& os,
|
||
|
|
const mersenne_twister_engine& mt)
|
||
|
|
{
|
||
|
|
mt.print(os);
|
||
|
|
return os;
|
||
|
|
}
|
||
|
|
|
||
|
|
/** Reads a mersenne_twister_engine from a @c std::istream */
|
||
|
|
template<class CharT, class Traits>
|
||
|
|
friend std::basic_istream<CharT,Traits>&
|
||
|
|
operator>>(std::basic_istream<CharT,Traits>& is,
|
||
|
|
mersenne_twister_engine& mt)
|
||
|
|
{
|
||
|
|
for(std::size_t j = 0; j < mt.state_size; ++j)
|
||
|
|
is >> mt.x[j] >> std::ws;
|
||
|
|
// MSVC (up to 7.1) and Borland (up to 5.64) don't handle the template
|
||
|
|
// value parameter "n" available from the class template scope, so use
|
||
|
|
// the static constant with the same value
|
||
|
|
mt.i = mt.state_size;
|
||
|
|
return is;
|
||
|
|
}
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if the two generators are in the same state,
|
||
|
|
* and will thus produce identical sequences.
|
||
|
|
*/
|
||
|
|
friend bool operator==(const mersenne_twister_engine& x_,
|
||
|
|
const mersenne_twister_engine& y_)
|
||
|
|
{
|
||
|
|
if(x_.i < y_.i) return x_.equal_imp(y_);
|
||
|
|
else return y_.equal_imp(x_);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Returns true if the two generators are in different states.
|
||
|
|
*/
|
||
|
|
friend bool operator!=(const mersenne_twister_engine& x_,
|
||
|
|
const mersenne_twister_engine& y_)
|
||
|
|
{ return !(x_ == y_); }
|
||
|
|
|
||
|
|
private:
|
||
|
|
/// \cond show_private
|
||
|
|
|
||
|
|
void twist();
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Does the work of operator==. This is in a member function
|
||
|
|
* for portability. Some compilers, such as msvc 7.1 and
|
||
|
|
* Sun CC 5.10 can't access template parameters or static
|
||
|
|
* members of the class from inline friend functions.
|
||
|
|
*
|
||
|
|
* requires i <= other.i
|
||
|
|
*/
|
||
|
|
bool equal_imp(const mersenne_twister_engine& other) const
|
||
|
|
{
|
||
|
|
UIntType back[n];
|
||
|
|
std::size_t offset = other.i - i;
|
||
|
|
for(std::size_t j = 0; j + offset < n; ++j)
|
||
|
|
if(x[j] != other.x[j+offset])
|
||
|
|
return false;
|
||
|
|
rewind(&back[n-1], offset);
|
||
|
|
for(std::size_t j = 0; j < offset; ++j)
|
||
|
|
if(back[j + n - offset] != other.x[j])
|
||
|
|
return false;
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Does the work of operator<<. This is in a member function
|
||
|
|
* for portability.
|
||
|
|
*/
|
||
|
|
template<class CharT, class Traits>
|
||
|
|
void print(std::basic_ostream<CharT, Traits>& os) const
|
||
|
|
{
|
||
|
|
UIntType data[n];
|
||
|
|
for(std::size_t j = 0; j < i; ++j) {
|
||
|
|
data[j + n - i] = x[j];
|
||
|
|
}
|
||
|
|
if(i != n) {
|
||
|
|
rewind(&data[n - i - 1], n - i);
|
||
|
|
}
|
||
|
|
os << data[0];
|
||
|
|
for(std::size_t j = 1; j < n; ++j) {
|
||
|
|
os << ' ' << data[j];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Copies z elements of the state preceding x[0] into
|
||
|
|
* the array whose last element is last.
|
||
|
|
*/
|
||
|
|
void rewind(UIntType* last, std::size_t z) const
|
||
|
|
{
|
||
|
|
const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
|
||
|
|
const UIntType lower_mask = ~upper_mask;
|
||
|
|
UIntType y0 = x[m-1] ^ x[n-1];
|
||
|
|
if(y0 & (static_cast<UIntType>(1) << (w-1))) {
|
||
|
|
y0 = ((y0 ^ a) << 1) | 1;
|
||
|
|
} else {
|
||
|
|
y0 = y0 << 1;
|
||
|
|
}
|
||
|
|
for(std::size_t sz = 0; sz < z; ++sz) {
|
||
|
|
UIntType y1 =
|
||
|
|
rewind_find(last, sz, m-1) ^ rewind_find(last, sz, n-1);
|
||
|
|
if(y1 & (static_cast<UIntType>(1) << (w-1))) {
|
||
|
|
y1 = ((y1 ^ a) << 1) | 1;
|
||
|
|
} else {
|
||
|
|
y1 = y1 << 1;
|
||
|
|
}
|
||
|
|
*(last - sz) = (y0 & upper_mask) | (y1 & lower_mask);
|
||
|
|
y0 = y1;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Converts an arbitrary array into a valid generator state.
|
||
|
|
* First we normalize x[0], so that it contains the same
|
||
|
|
* value we would get by running the generator forwards
|
||
|
|
* and then in reverse. (The low order r bits are redundant).
|
||
|
|
* Then, if the state consists of all zeros, we set the
|
||
|
|
* high order bit of x[0] to 1. This function only needs to
|
||
|
|
* be called by seed, since the state transform preserves
|
||
|
|
* this relationship.
|
||
|
|
*/
|
||
|
|
void normalize_state()
|
||
|
|
{
|
||
|
|
const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
|
||
|
|
const UIntType lower_mask = ~upper_mask;
|
||
|
|
UIntType y0 = x[m-1] ^ x[n-1];
|
||
|
|
if(y0 & (static_cast<UIntType>(1) << (w-1))) {
|
||
|
|
y0 = ((y0 ^ a) << 1) | 1;
|
||
|
|
} else {
|
||
|
|
y0 = y0 << 1;
|
||
|
|
}
|
||
|
|
x[0] = (x[0] & upper_mask) | (y0 & lower_mask);
|
||
|
|
|
||
|
|
// fix up the state if it's all zeroes.
|
||
|
|
for(std::size_t j = 0; j < n; ++j) {
|
||
|
|
if(x[j] != 0) return;
|
||
|
|
}
|
||
|
|
x[0] = static_cast<UIntType>(1) << (w-1);
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Given a pointer to the last element of the rewind array,
|
||
|
|
* and the current size of the rewind array, finds an element
|
||
|
|
* relative to the next available slot in the rewind array.
|
||
|
|
*/
|
||
|
|
UIntType
|
||
|
|
rewind_find(UIntType* last, std::size_t size, std::size_t j) const
|
||
|
|
{
|
||
|
|
std::size_t index = (j + n - size + n - 1) % n;
|
||
|
|
if(index < n - size) {
|
||
|
|
return x[index];
|
||
|
|
} else {
|
||
|
|
return *(last - (n - 1 - index));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* Optimized algorithm for large jumps.
|
||
|
|
*
|
||
|
|
* Hiroshi Haramoto, Makoto Matsumoto, and Pierre L'Ecuyer. 2008.
|
||
|
|
* A Fast Jump Ahead Algorithm for Linear Recurrences in a Polynomial
|
||
|
|
* Space. In Proceedings of the 5th international conference on
|
||
|
|
* Sequences and Their Applications (SETA '08).
|
||
|
|
* DOI=10.1007/978-3-540-85912-3_26
|
||
|
|
*/
|
||
|
|
void discard_many(boost::uintmax_t z)
|
||
|
|
{
|
||
|
|
// Compute the minimal polynomial, phi(t)
|
||
|
|
// This depends only on the transition function,
|
||
|
|
// which is constant. The characteristic
|
||
|
|
// polynomial is the same as the minimal
|
||
|
|
// polynomial for a maximum period generator
|
||
|
|
// (which should be all specializations of
|
||
|
|
// mersenne_twister.) Even if it weren't,
|
||
|
|
// the characteristic polynomial is guaranteed
|
||
|
|
// to be a multiple of the minimal polynomial,
|
||
|
|
// which is good enough.
|
||
|
|
detail::polynomial phi = get_characteristic_polynomial();
|
||
|
|
|
||
|
|
// calculate g(t) = t^z % phi(t)
|
||
|
|
detail::polynomial g = mod_pow_x(z, phi);
|
||
|
|
|
||
|
|
// h(s_0, t) = \sum_{i=0}^{2k-1}o(s_i)t^{2k-i-1}
|
||
|
|
detail::polynomial h;
|
||
|
|
const std::size_t num_bits = w*n - r;
|
||
|
|
for(std::size_t j = 0; j < num_bits * 2; ++j) {
|
||
|
|
// Yes, we're advancing the generator state
|
||
|
|
// here, but it doesn't matter because
|
||
|
|
// we're going to overwrite it completely
|
||
|
|
// in reconstruct_state.
|
||
|
|
if(i >= n) twist();
|
||
|
|
h[2*num_bits - j - 1] = x[i++] & UIntType(1);
|
||
|
|
}
|
||
|
|
// g(t)h(s_0, t)
|
||
|
|
detail::polynomial gh = g * h;
|
||
|
|
detail::polynomial result;
|
||
|
|
for(std::size_t j = 0; j <= num_bits; ++j) {
|
||
|
|
result[j] = gh[2*num_bits - j - 1];
|
||
|
|
}
|
||
|
|
reconstruct_state(result);
|
||
|
|
}
|
||
|
|
static detail::polynomial get_characteristic_polynomial()
|
||
|
|
{
|
||
|
|
const std::size_t num_bits = w*n - r;
|
||
|
|
detail::polynomial helper;
|
||
|
|
helper[num_bits - 1] = 1;
|
||
|
|
mersenne_twister_engine tmp;
|
||
|
|
tmp.reconstruct_state(helper);
|
||
|
|
// Skip the first num_bits elements, since we
|
||
|
|
// already know what they are.
|
||
|
|
for(std::size_t j = 0; j < num_bits; ++j) {
|
||
|
|
if(tmp.i >= n) tmp.twist();
|
||
|
|
if(j == num_bits - 1)
|
||
|
|
assert((tmp.x[tmp.i] & 1) == 1);
|
||
|
|
else
|
||
|
|
assert((tmp.x[tmp.i] & 1) == 0);
|
||
|
|
++tmp.i;
|
||
|
|
}
|
||
|
|
detail::polynomial phi;
|
||
|
|
phi[num_bits] = 1;
|
||
|
|
detail::polynomial next_bits = tmp.as_polynomial(num_bits);
|
||
|
|
for(std::size_t j = 0; j < num_bits; ++j) {
|
||
|
|
int val = next_bits[j] ^ phi[num_bits-j-1];
|
||
|
|
phi[num_bits-j-1] = val;
|
||
|
|
if(val) {
|
||
|
|
for(std::size_t k = j + 1; k < num_bits; ++k) {
|
||
|
|
phi[num_bits-k-1] ^= next_bits[k-j-1];
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return phi;
|
||
|
|
}
|
||
|
|
detail::polynomial as_polynomial(std::size_t size) {
|
||
|
|
detail::polynomial result;
|
||
|
|
for(std::size_t j = 0; j < size; ++j) {
|
||
|
|
if(i >= n) twist();
|
||
|
|
result[j] = x[i++] & UIntType(1);
|
||
|
|
}
|
||
|
|
return result;
|
||
|
|
}
|
||
|
|
void reconstruct_state(const detail::polynomial& p)
|
||
|
|
{
|
||
|
|
const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
|
||
|
|
const UIntType lower_mask = ~upper_mask;
|
||
|
|
const std::size_t num_bits = w*n - r;
|
||
|
|
for(std::size_t j = num_bits - n + 1; j <= num_bits; ++j)
|
||
|
|
x[j % n] = p[j];
|
||
|
|
|
||
|
|
UIntType y0 = 0;
|
||
|
|
for(std::size_t j = num_bits + 1; j >= n - 1; --j) {
|
||
|
|
UIntType y1 = x[j % n] ^ x[(j + m) % n];
|
||
|
|
if(p[j - n + 1])
|
||
|
|
y1 = (y1 ^ a) << UIntType(1) | UIntType(1);
|
||
|
|
else
|
||
|
|
y1 = y1 << UIntType(1);
|
||
|
|
x[(j + 1) % n] = (y0 & upper_mask) | (y1 & lower_mask);
|
||
|
|
y0 = y1;
|
||
|
|
}
|
||
|
|
i = 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
/// \endcond
|
||
|
|
|
||
|
|
// state representation: next output is o(x(i))
|
||
|
|
// x[0] ... x[k] x[k+1] ... x[n-1] represents
|
||
|
|
// x(i-k) ... x(i) x(i+1) ... x(i-k+n-1)
|
||
|
|
|
||
|
|
UIntType x[n];
|
||
|
|
std::size_t i;
|
||
|
|
};
|
||
|
|
|
||
|
|
/// \cond show_private
|
||
|
|
|
||
|
|
#ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
|
||
|
|
// A definition is required even for integral static constants
|
||
|
|
#define BOOST_RANDOM_MT_DEFINE_CONSTANT(type, name) \
|
||
|
|
template<class UIntType, std::size_t w, std::size_t n, std::size_t m, \
|
||
|
|
std::size_t r, UIntType a, std::size_t u, UIntType d, std::size_t s, \
|
||
|
|
UIntType b, std::size_t t, UIntType c, std::size_t l, UIntType f> \
|
||
|
|
const type mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::name
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, word_size);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, state_size);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, shift_size);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, mask_bits);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, xor_mask);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_u);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_d);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_s);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_b);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_t);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, tempering_c);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, tempering_l);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, initialization_multiplier);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, default_seed);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, parameter_a);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_u );
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_s);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, output_b);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_t);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(UIntType, output_c);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(std::size_t, output_l);
|
||
|
|
BOOST_RANDOM_MT_DEFINE_CONSTANT(bool, has_fixed_range);
|
||
|
|
#undef BOOST_RANDOM_MT_DEFINE_CONSTANT
|
||
|
|
#endif
|
||
|
|
|
||
|
|
template<class UIntType,
|
||
|
|
std::size_t w, std::size_t n, std::size_t m, std::size_t r,
|
||
|
|
UIntType a, std::size_t u, UIntType d, std::size_t s,
|
||
|
|
UIntType b, std::size_t t,
|
||
|
|
UIntType c, std::size_t l, UIntType f>
|
||
|
|
void
|
||
|
|
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::twist()
|
||
|
|
{
|
||
|
|
const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
|
||
|
|
const UIntType lower_mask = ~upper_mask;
|
||
|
|
|
||
|
|
const std::size_t unroll_factor = 6;
|
||
|
|
const std::size_t unroll_extra1 = (n-m) % unroll_factor;
|
||
|
|
const std::size_t unroll_extra2 = (m-1) % unroll_factor;
|
||
|
|
|
||
|
|
// split loop to avoid costly modulo operations
|
||
|
|
{ // extra scope for MSVC brokenness w.r.t. for scope
|
||
|
|
for(std::size_t j = 0; j < n-m-unroll_extra1; j++) {
|
||
|
|
UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
|
||
|
|
x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
{
|
||
|
|
for(std::size_t j = n-m-unroll_extra1; j < n-m; j++) {
|
||
|
|
UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
|
||
|
|
x[j] = x[j+m] ^ (y >> 1) ^ ((x[j+1]&1) * a);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
{
|
||
|
|
for(std::size_t j = n-m; j < n-1-unroll_extra2; j++) {
|
||
|
|
UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
|
||
|
|
x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
{
|
||
|
|
for(std::size_t j = n-1-unroll_extra2; j < n-1; j++) {
|
||
|
|
UIntType y = (x[j] & upper_mask) | (x[j+1] & lower_mask);
|
||
|
|
x[j] = x[j-(n-m)] ^ (y >> 1) ^ ((x[j+1]&1) * a);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// last iteration
|
||
|
|
UIntType y = (x[n-1] & upper_mask) | (x[0] & lower_mask);
|
||
|
|
x[n-1] = x[m-1] ^ (y >> 1) ^ ((x[0]&1) * a);
|
||
|
|
i = 0;
|
||
|
|
}
|
||
|
|
/// \endcond
|
||
|
|
|
||
|
|
template<class UIntType,
|
||
|
|
std::size_t w, std::size_t n, std::size_t m, std::size_t r,
|
||
|
|
UIntType a, std::size_t u, UIntType d, std::size_t s,
|
||
|
|
UIntType b, std::size_t t,
|
||
|
|
UIntType c, std::size_t l, UIntType f>
|
||
|
|
inline typename
|
||
|
|
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::result_type
|
||
|
|
mersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::operator()()
|
||
|
|
{
|
||
|
|
if(i == n)
|
||
|
|
twist();
|
||
|
|
// Step 4
|
||
|
|
UIntType z = x[i];
|
||
|
|
++i;
|
||
|
|
z ^= ((z >> u) & d);
|
||
|
|
z ^= ((z << s) & b);
|
||
|
|
z ^= ((z << t) & c);
|
||
|
|
z ^= (z >> l);
|
||
|
|
return z;
|
||
|
|
}
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The specializations \mt11213b and \mt19937 are from
|
||
|
|
*
|
||
|
|
* @blockquote
|
||
|
|
* "Mersenne Twister: A 623-dimensionally equidistributed
|
||
|
|
* uniform pseudo-random number generator", Makoto Matsumoto
|
||
|
|
* and Takuji Nishimura, ACM Transactions on Modeling and
|
||
|
|
* Computer Simulation: Special Issue on Uniform Random Number
|
||
|
|
* Generation, Vol. 8, No. 1, January 1998, pp. 3-30.
|
||
|
|
* @endblockquote
|
||
|
|
*/
|
||
|
|
typedef mersenne_twister_engine<uint32_t,32,351,175,19,0xccab8ee7,
|
||
|
|
11,0xffffffff,7,0x31b6ab00,15,0xffe50000,17,1812433253> mt11213b;
|
||
|
|
|
||
|
|
/**
|
||
|
|
* The specializations \mt11213b and \mt19937 are from
|
||
|
|
*
|
||
|
|
* @blockquote
|
||
|
|
* "Mersenne Twister: A 623-dimensionally equidistributed
|
||
|
|
* uniform pseudo-random number generator", Makoto Matsumoto
|
||
|
|
* and Takuji Nishimura, ACM Transactions on Modeling and
|
||
|
|
* Computer Simulation: Special Issue on Uniform Random Number
|
||
|
|
* Generation, Vol. 8, No. 1, January 1998, pp. 3-30.
|
||
|
|
* @endblockquote
|
||
|
|
*/
|
||
|
|
typedef mersenne_twister_engine<uint32_t,32,624,397,31,0x9908b0df,
|
||
|
|
11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253> mt19937;
|
||
|
|
|
||
|
|
#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
|
||
|
|
typedef mersenne_twister_engine<uint64_t,64,312,156,31,
|
||
|
|
UINT64_C(0xb5026f5aa96619e9),29,UINT64_C(0x5555555555555555),17,
|
||
|
|
UINT64_C(0x71d67fffeda60000),37,UINT64_C(0xfff7eee000000000),43,
|
||
|
|
UINT64_C(6364136223846793005)> mt19937_64;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
/// \cond show_deprecated
|
||
|
|
|
||
|
|
template<class UIntType,
|
||
|
|
int w, int n, int m, int r,
|
||
|
|
UIntType a, int u, std::size_t s,
|
||
|
|
UIntType b, int t,
|
||
|
|
UIntType c, int l, UIntType v>
|
||
|
|
class mersenne_twister :
|
||
|
|
public mersenne_twister_engine<UIntType,
|
||
|
|
w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253>
|
||
|
|
{
|
||
|
|
typedef mersenne_twister_engine<UIntType,
|
||
|
|
w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, 1812433253> base_type;
|
||
|
|
public:
|
||
|
|
mersenne_twister() {}
|
||
|
|
BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(mersenne_twister, Gen, gen)
|
||
|
|
{ seed(gen); }
|
||
|
|
BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(mersenne_twister, UIntType, val)
|
||
|
|
{ seed(val); }
|
||
|
|
template<class It>
|
||
|
|
mersenne_twister(It& first, It last) : base_type(first, last) {}
|
||
|
|
void seed() { base_type::seed(); }
|
||
|
|
BOOST_RANDOM_DETAIL_GENERATOR_SEED(mersenne_twister, Gen, gen)
|
||
|
|
{
|
||
|
|
detail::generator_seed_seq<Gen> seq(gen);
|
||
|
|
base_type::seed(seq);
|
||
|
|
}
|
||
|
|
BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(mersenne_twister, UIntType, val)
|
||
|
|
{ base_type::seed(val); }
|
||
|
|
template<class It>
|
||
|
|
void seed(It& first, It last) { base_type::seed(first, last); }
|
||
|
|
};
|
||
|
|
|
||
|
|
/// \endcond
|
||
|
|
|
||
|
|
} // namespace random
|
||
|
|
|
||
|
|
using random::mt11213b;
|
||
|
|
using random::mt19937;
|
||
|
|
using random::mt19937_64;
|
||
|
|
|
||
|
|
} // namespace boost
|
||
|
|
|
||
|
|
BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt11213b)
|
||
|
|
BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937)
|
||
|
|
BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937_64)
|
||
|
|
|
||
|
|
#include <boost/random/detail/enable_warnings.hpp>
|
||
|
|
|
||
|
|
#endif // BOOST_RANDOM_MERSENNE_TWISTER_HPP
|