无法解析的外部符号 _gsl_rng_mt19937,该怎么处理 - C++当前位置:& &&&无法解析的外部符号 _gsl_rng_mt19937,该怎么处理无法解析的外部符号 _gsl_rng_mt19937,该怎么处理&&网友分享于：&&浏览：143次无法解析的外部符号 _gsl_rng_mt19937xform.obj : error LNK2001: 无法解析的外部符号 _gsl_rng_mt19937在工程的属性的VC++目录和链接器都已经准备填好了库的路径和lib,但是还是出现这样的问题 请问这到底是怎么回事？------解决方案--------------------
http://blog.csdn.net/shaolon/article/details/5611911
12345678910
12345678910
12345678910 上一篇：下一篇：文章评论相关解决方案 12345678910 Copyright & &&版权所有mt19937是什么鬼？_ASP.NET技巧_动态网站制作指南
mt19937是什么鬼？
来源：人气：73
今天看一个C++的例子，突然看到这个mt19937，起先还以为是什么地方搞错了，怎么会有这个怪的名称呢？这个名称是mt1937? 代表1937年？心里一开始有这个疑问。代码如下：std::random_
std::mt19937 gen(rd());
std::uniform_int_distribution&& dist(-10, 10);
std::vector&int&
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,0x9d2cxefc2433253&
mt19937;这个算法在C++里简单地实现如下：#include &stdint.h&
// Define MT19937 constants (32-bit RNG)
// Assumes W = 32 (omitting this)
A = 0x9908B0DF,
// Assumes D = 0xFFFFFFFF (omitting this)
B = 0x9D2C5680,
C = 0xEFC60000,
MASK_LOWER = (1ull && R) - 1,
MASK_UPPER = (1ull && R)
static uint32_t
static uint16_
// Re-init with a given seed
void Initialize(const uint32_t
for ( i = 1; i & N; i++ )
mt[i] = (F * (mt[i - 1] ^ (mt[i - 1] && 30)) + i);
index = N;
static void Twist()
for ( i = 0; i & N; i++ )
x = (mt[i] & MASK_UPPER) + (mt[(i + 1) % N] & MASK_LOWER);
xA = x && 1;
if ( x & 0x1 )
mt[i] = mt[(i + M) % N] ^ xA;
index = 0;
// Obtain a 32-bit random number
uint32_t ExtractU32()
if ( index &= N )
y = mt[i];
index = i + 1;
y ^= (mt[i] && U);
y ^= (y && S) & B;
y ^= (y && T) & C;
y ^= (y && L);
}相关网站：/Chset/archive//72330.htmlboost库的实现：/* boost random/mersenne_twister.hpp header file
* Copyright Jens Maurer
* 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 -10-09 23:13:31Z steven_watanabe $
* Revision history
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
* The boost variant has been implemented from scratch and does not
* derive from or use mt19937.c ovided 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
typedef UIntType result_
BOOST_STATIC_CONSTANT(std::size_t, _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 tor 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 &
for (i = 1; i & 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) &
* 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);
// 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 & ++j) {
if(x[j] != 0)
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);
// 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 & ++j) {
if(x[j] != 0)
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_ }
/** 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
* for(unsigned long long i = 0; i & ++i) {
* @endcode
void discard(boost::uintmax_t z)
for(boost::uintmax_t j = 0; j & ++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);
/** 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_ ++j)
is && mt.x[j] && std::
// 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_
* 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); }
/// \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
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 -
for(std::size_t j = 0; j + offset & ++j)
if(x[j] != other.x[j+offset])
rewind(&back[n-1], offset);
for(std::size_t j = 0; j & ++j)
if(back[j + n - offset] != other.x[j])
* 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 & ++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 & ++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)) &&
const UIntType lower_mask = ~upper_
UIntType y0 = x[m-1] ^ x[n-1];
if(y0 & (static_cast&UIntType&(1) && (w-1))) {
y0 = ((y0 ^ a) && 1) | 1;
y0 = y0 && 1;
for(std::size_t sz = 0; sz & ++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;
y1 = y1 && 1;
*(last - sz) = (y0 & upper_mask) | (y1 & lower_mask);
* 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.
rewind_find(UIntType* last, std::size_t size, std::size_t j) const
std::size_t index = (j + n - size + n - 1) %
if(index & n - size) {
return x[index];
return *(last - (n - 1 - index));
/// \endcond
// state representation: next output is o(x(i))
... 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_
/// \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
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&
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)) &&
const UIntType lower_mask = ~upper_
const std::size_t unroll_factor = 6;
const std::size_t unroll_extra1 = (n-m) % unroll_
const std::size_t unroll_extra2 = (m-1) % unroll_
// 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);
/// \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)
UIntType z = x[i];
z ^= ((z && u) & d);
z ^= ((z && s) & b);
z ^= ((z && t) & c);
z ^= (z && l);
* 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,0xffe2433253& 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,0x9d2cxefc2433253& 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(0xb619e9),29,UINT64_C(0x5555),17,
UINT64_C(0x71d67fffeda60000),37,UINT64_C(0xfff7eee),43,
UINT64_C(6793005)& mt19937_64;
/// \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, &
typedef mersenne_twister_engine&UIntType,
w, n, m, r, a, u, ~(UIntType)0, s, b, t, c, l, & base_
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)
#endif // BOOST_RANDOM_MERSENNE_TWISTER_HPP1. C++标准库从入门到精通&http://edu.csdn.net/course/detail/33242.跟老菜鸟学C++http://edu.csdn.net/course/detail/29013. 跟老菜鸟学pythonhttp://edu.csdn.net/course/detail/25924. 在VC2015里学会使用tinyxml库http://edu.csdn.net/course/detail/25905. 在Windows下SVN的版本管理与实战&&http://edu.csdn.net/course/detail/25796.Visual Studio 2015开发C++程序的基本使用&http://edu.csdn.net/course/detail/25707.在VC2015里使用protobuf协议http://edu.csdn.net/course/detail/25828.在VC2015里学会使用http://edu.csdn.net/course/detail/2672
优质网站模板