mt19937是什么鬼

分享一下我老师大神的人工智能教程！零基础，通俗易懂！http://blog.csdn.net/jiangjunshow

也欢迎大家转载本篇文章。分享知识，造福人民，实现我们中华民族伟大复兴！

今天看一个C++的例子，突然看到这个mt19937，起先还以为是什么地方搞错了，怎么会有这个怪的名称呢？这个名称是mt1937? 代表1937年？心里一开始有这个疑问。代码如下：

std::random_device rd;  std::mt19937 gen(rd());  std::uniform_int_distribution<> dist(-10, 10);  std::vector<int> v;  generate_n(back_inserter(v), 20, bind(dist, gen));  std::cout << "Before sort: ";  copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));  selection_sort(v.begin(), v.end());  std::cout << "\nAfter sort: ";  copy(v.begin(), v.end(), std::ostream_iterator<int>(std::cout, " "));  std::cout << '\n';

后来通过查看MSDN以及网络相关的文章，才了解到这个是最新的计算随机数的算法。

Mersenne Twister算法译为马特赛特旋转演算法，是伪随机数发生器之一，其主要作用是生成伪随机数。此算法是Makoto Matsumoto （松本）和Takuji Nishimura （西村）于1997年开发的，基于有限二进制字段上的矩阵线性再生。可以快速产生高质量的伪随机数，修正了古老随机数产生算法的很多缺陷。Mersenne Twister这个名字来自周期长度通常取Mersenne质数这样一个事实。常见的有两个变种Mersenne Twister MT19937和Mersenne Twister MT19937-64。
Mersenne Twister算法的原理：Mersenne Twister算法是利用线性反馈移位寄存器(LFSR)产生随机数的，LFSR的反馈函数是寄存器中某些位的简单异或，这些位也称之为抽头序列。一个n位的LFSR能够在重复之前产生2^n-1位长的伪随机序列。只有具有一定抽头序列的LFSR才能通过所有2^n-1个内部状态，产生2^n - 1位长的伪随机序列，这个输出的序列就称之为m序列。为了使LFSR成为最大周期的LFSR，由抽头序列加上常数1形成的多项式必须是本原多项式。一个n阶本原多项式是不可约多项式，它能整除x^(2*n-1)+1而不能整除x^d+1，其中d能整除2^n-1。例如(32,7,5,3,2,1,0)是指本原多项式x^32+x^7+x^5+x^3+x^2+x+1，把它转化为最大周期LFSR就是在LFSR的第32，7，5，2，1位抽头。利用上述两种方法产生周期为m的伪随机序列后，只需要将产生的伪随机序列除以序列的周期，就可以得到(0，1)上均匀分布的伪随机序列了。
Mersenne Twister有以下优点：随机性好，在计算机上容易实现，占用内存较少(mt19937的C程式码执行仅需624个字的工作区域)，与其它已使用的伪随机数发生器相比，产生随机数的速度快、周期长，可达到2^19937-1，且具有623维均匀分布的性质，对于一般的应用来说，足够大了，序列关联比较小，能通过很多随机性测试。
马特赛特旋转演算法产生一个伪随机数，一般为MtRand()。

从这段话里可以看到它是2的19937次方，所以它的名称就来源这里。

在STL标准库定义如下：

typedef mersenne_twister_engine<uint_fast32_t,  32,624,397,31,0x9908b0df,11,0xffffffff,7,0x9d2c5680,15,0xefc60000,18,1812433253>  mt19937;

这个算法在C++里简单地实现如下：

#include <stdint.h>// Define MT19937 constants (32-bit RNG)enum{    // Assumes W = 32 (omitting this)    N = 624,    M = 397,    R = 31,    A = 0x9908B0DF,    F = 1812433253,    U = 11,    // Assumes D = 0xFFFFFFFF (omitting this)    S = 7,    B = 0x9D2C5680,    T = 15,    C = 0xEFC60000,    L = 18,    MASK_LOWER = (1ull << R) - 1,    MASK_UPPER = (1ull << R)};static uint32_t  mt[N];static uint16_t  index;// Re-init with a given seedvoid Initialize(const uint32_t  seed){    uint32_t  i;    mt[0] = seed;    for ( i = 1; i < N; i++ )    {        mt[i] = (F * (mt[i - 1] ^ (mt[i - 1] >> 30)) + i);    }    index = N;}static void Twist(){    uint32_t  i, x, xA;    for ( i = 0; i < N; i++ )    {        x = (mt[i] & MASK_UPPER) + (mt[(i + 1) % N] & MASK_LOWER);        xA = x >> 1;        if ( x & 0x1 )            xA ^= A;        mt[i] = mt[(i + M) % N] ^ xA;    }    index = 0;}// Obtain a 32-bit random numberuint32_t ExtractU32(){    uint32_t  y;    int       i = index;    if ( index >= N )    {        Twist();        i = index;    }    y = mt[i];    index = i + 1;    y ^= (mt[i] >> U);    y ^= (y << S) & B;    y ^= (y << T) & C;    y ^= (y >> L);    return y;}

boost库的实现：

/* 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: mersenne_twister.hpp 74867 2011-10-09 23:13:31Z steven_watanabe $ * * Revision history *  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>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;        }    }        /**     * 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;        // fix up the state if it's all zeroes.        if((x[0] & (~static_cast<UIntType>(0) << r)) == 0) {            for(std::size_t j = 1; j < n; ++j) {                if(x[j] != 0) return;            }            x[0] = static_cast<UIntType>(1) << (w-1);        }    }    /** 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;        // fix up the state if it's all zeroes.        if((x[0] & (~static_cast<UIntType>(0) << r)) == 0) {            for(std::size_t j = 1; j < n; ++j) {                if(x[j] != 0) return;            }            x[0] = static_cast<UIntType>(1) << (w-1);        }    }      /** 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)    {        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;        }    }    /**     * 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));        }    }    /// \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>::nameBOOST_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#endiftemplate<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>voidmersenne_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;}/// \endcondtemplate<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 typenamemersenne_twister_engine<UIntType,w,n,m,r,a,u,d,s,b,t,c,l,f>::result_typemersenne_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_deprecatedtemplate<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 randomusing random::mt11213b;using random::mt19937;using random::mt19937_64;} // namespace boostBOOST_RANDOM_PTR_HELPER_SPEC(boost::mt11213b)BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937)BOOST_RANDOM_PTR_HELPER_SPEC(boost::mt19937_64)#endif // BOOST_RANDOM_MERSENNE_TWISTER_HPP