[Boost-commit] svn:boost r63217 - in trunk: boost/random boost/random/detail libs/random/test

Subject: [Boost-commit] svn:boost r63217 - in trunk: boost/random boost/random/detail libs/random/test
From: steven_at_[hidden]
Date: 2010-06-21 22:30:10

Author: steven_watanabe
Date: 2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
New Revision: 63217
URL: http://svn.boost.org/trac/boost/changeset/63217

Log:
Sync mersenne_twister with C++0x.
Added:
   trunk/boost/random/seed_seq.hpp   (contents, props changed)
   trunk/libs/random/test/test_seed_seq.cpp   (contents, props changed)
Text files modified: 
   trunk/boost/random/detail/seed.hpp         |    27 +                                       
   trunk/boost/random/linear_congruential.hpp |     9                                         
   trunk/boost/random/mersenne_twister.hpp    |   571 ++++++++++++++++++++++----------------- 
   trunk/libs/random/test/Jamfile.v2          |     3                                         
   trunk/libs/random/test/instantiate.cpp     |     9                                         
   trunk/libs/random/test/validate.cpp        |     7                                         
   6 files changed, 371 insertions(+), 255 deletions(-)

Modified: trunk/boost/random/detail/seed.hpp
==============================================================================
--- trunk/boost/random/detail/seed.hpp	(original)
+++ trunk/boost/random/detail/seed.hpp	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -43,12 +43,19 @@
     template<class Generator>                                       \
     void seed(Generator& gen, typename ::boost::random::detail::disable_seed<Generator>::type* = 0)
 
+#define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq)    \
+    template<class SeedSeq>                                             \
+    explicit Self(SeedSeq& seq, typename ::boost::random::detail::disable_constructor<Self, SeedSeq>::type* = 0)
+
+#define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq)   \
+    template<class SeedSeq>                                     \
+    void seed(SeedSeq& seq, typename ::boost::random::detail::disable_seed<SeedSeq>::type* = 0)
+
 #define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x)  \
     explicit Self(const T& x)
 
 #define BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(Self, T, x) \
     void seed(const T& x)
-
 }
 }
 }
@@ -76,6 +83,24 @@
     template<class Generator>\
     void boost_random_seed_impl(Generator& gen, ::boost::mpl::false_)
 
+#define BOOST_RANDOM_DETAIL_SEED_SEQ_CONSTRUCTOR(Self, SeedSeq, seq)    \
+    Self(Self& other) { *this = other; }                                \
+    Self(const Self& other) { *this = other; }                          \
+    template<class SeedSeq>                                             \
+    explicit Self(SeedSeq& seq) {                                       \
+        boost_random_constructor_impl(seq, ::boost::is_arithmetic<SeedSeq>());\
+    }                                                                   \
+    template<class SeedSeq>                                             \
+    void boost_random_constructor_impl(SeedSeq& seq, ::boost::mpl::false_)
+
+#define BOOST_RANDOM_DETAIL_SEED_SEQ_SEED(Self, SeedSeq, seq)           \
+    template<class SeedSeq>                                             \
+    void seed(SeedSeq& seq) {                                           \
+        boost_random_seed_impl(seq, ::boost::is_arithmetic<SeedSeq>()); \
+    }                                                                   \
+    template<class SeedSeq>                                             \
+    void boost_random_seed_impl(SeedSeq& seq, ::boost::mpl::false_)
+
 #define BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(Self, T, x)  \
     explicit Self(const T& x) { boost_random_constructor_impl(x, ::boost::mpl::true_()); }\
     void boost_random_constructor_impl(const T& x, ::boost::mpl::true_)

Modified: trunk/boost/random/linear_congruential.hpp
==============================================================================
--- trunk/boost/random/linear_congruential.hpp	(original)
+++ trunk/boost/random/linear_congruential.hpp	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -160,6 +160,15 @@
     _x = const_mod<IntType, m>::mult_add(a, _x, c);
     return _x;
   }
+  
+  /** Fills a range with random values */
+  template<class Iter>
+  void generate(Iter first, Iter last)
+  {
+    for(; first != last; ++first) {
+      *first = (*this)();
+    }
+  }
 
   static bool validation(IntType x) { return val == x; }
 

Modified: trunk/boost/random/mersenne_twister.hpp
==============================================================================
--- trunk/boost/random/mersenne_twister.hpp	(original)
+++ trunk/boost/random/mersenne_twister.hpp	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -1,6 +1,7 @@
 /* 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)
@@ -16,16 +17,10 @@
 #ifndef BOOST_RANDOM_MERSENNE_TWISTER_HPP
 #define BOOST_RANDOM_MERSENNE_TWISTER_HPP
 
-#include <iostream>
-#include <algorithm>     // std::copy
+#include <iosfwd>
 #include <stdexcept>
 #include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/integer_traits.hpp>
 #include <boost/cstdint.hpp>
-#include <boost/random/linear_congruential.hpp>
-#include <boost/detail/workaround.hpp>
 #include <boost/random/detail/config.hpp>
 #include <boost/random/detail/ptr_helper.hpp>
 #include <boost/random/detail/seed.hpp>
@@ -34,7 +29,7 @@
 namespace random {
 
 /**
- * Instantiations of class template mersenne_twister model a
+ * Instantiations of class template mersenne_twister_engine model a
  * \pseudo_random_number_generator. It uses the algorithm described in
  *
  *  @blockquote
@@ -61,277 +56,330 @@
  * its state array. For example, \mt11213b requires about 1408 bytes and
  * \mt19937 requires about 2496 bytes.
  */
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-class mersenne_twister
+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(int, word_size = w);
-  BOOST_STATIC_CONSTANT(int, state_size = n);
-  BOOST_STATIC_CONSTANT(int, shift_size = m);
-  BOOST_STATIC_CONSTANT(int, mask_bits = r);
-  BOOST_STATIC_CONSTANT(UIntType, parameter_a = a);
-  BOOST_STATIC_CONSTANT(int, output_u = u);
-  BOOST_STATIC_CONSTANT(int, output_s = s);
-  BOOST_STATIC_CONSTANT(UIntType, output_b = b);
-  BOOST_STATIC_CONSTANT(int, output_t = t);
-  BOOST_STATIC_CONSTANT(UIntType, output_c = c);
-  BOOST_STATIC_CONSTANT(int, output_l = l);
-
-  BOOST_STATIC_CONSTANT(bool, has_fixed_range = false);
+    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);
   
-  /**
-   * Constructs a @c mersenne_twister and calls @c seed().
-   */
-  mersenne_twister() { seed(); }
-
-  /**
-   * Constructs a @c mersenne_twister and calls @c seed(value).
-   */
-  BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(mersenne_twister, UIntType, value)
-  { seed(value); }
-  template<class It> mersenne_twister(It& first, It last) { seed(first,last); }
-
-  /**
-   * Constructs a mersenne_twister and calls @c seed(gen).
-   *
-   * @xmlnote
-   * The copy constructor will always be preferred over
-   * the templated constructor.
-   * @endxmlnote
-   */
-  BOOST_RANDOM_DETAIL_GENERATOR_CONSTRUCTOR(mersenne_twister, Generator, gen)
-  { seed(gen); }
-
-  // compiler-generated copy ctor and assignment operator are fine
-
-  /** Calls @c seed(result_type(5489)). */
-  void seed() { seed(UIntType(5489)); }
-
-  /**
-   * Sets the state x(0) to v mod 2w. Then, iteratively,
-   * sets x(i) to (i + 1812433253 * (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, 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 = ~0u;
-    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] = (1812433253UL * (x[i-1] ^ (x[i-1] >> (w-2))) + i) & mask;
-    }
-  }
-
-  /**
-   * Sets the state of this mersenne_twister to the values
-   * returned by n invocations of gen.
-   *
-   * Complexity: Exactly n invocations of gen.
-   */
-  BOOST_RANDOM_DETAIL_GENERATOR_SEED(mersenne_twister, Generator, gen)
-  {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    BOOST_STATIC_ASSERT(!std::numeric_limits<result_type>::is_signed);
-#endif
-    // I could have used std::generate_n, but it takes "gen" by value
-    for(int j = 0; j < n; j++)
-      x[j] = gen();
-    i = n;
-  }
-
-  template<class It>
-  void seed(It& first, It last)
-  {
-    int j;
-    for(j = 0; j < n && first != last; ++j, ++first)
-      x[j] = *first;
-    i = n;
-    if(first == last && j < n)
-      throw std::invalid_argument("mersenne_twister::seed");
-  }
+    // 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)
+    {
+        boost::uint_least32_t storage[((w+31)/32) * n];
+        seq.generate(&storage[0], &storage[0] + ((w+31)/32) * n);
+        for(std::size_t j = 0; j < n; j++) {
+            UIntType val = 0;
+            for(std::size_t k = 0; k < (w+31)/32; ++k) {
+                val += storage[(w+31)/32*j + k] << 32*k;
+            }
+            x[j] = val;
+        }
+        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; i < 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)
+    {
+        std::size_t j;
+        for(j = 0; j < n && first != last; ++j, ++first)
+            x[j] = *first;
+        i = n;
+        if(first == last && j < n)
+            throw std::invalid_argument("mersenne_twister_engine::seed");
+    }
   
-  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return 0; }
-  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const
-  {
-    // avoid "left shift count >= with of type" warning
-    result_type res = 0;
-    for(int j = 0; j < w; ++j)
-      res |= (1u << j);
-    return res;
-  }
+    /** 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 ()
+    {
+        // avoid "left shift count >= width of type" warning
+        result_type res = 0;
+        for(std::size_t j = 0; j < w; ++j)
+            res |= (static_cast<result_type>(1) << j);
+        return res;
+    }
+    
+    /** Produces the next value of the generator. */
+    result_type operator()();
 
-  result_type operator()();
-  static bool validation(result_type v) { return val == v; }
+    /** Fills a range with random values */
+    template<class Iter>
+    void generate(Iter first, Iter last)
+    {
+        for(; first != last; ++first) {
+            *first = (*this)();
+        }
+    }
 
-#ifndef BOOST_NO_OPERATORS_IN_NAMESPACE
+#ifndef BOOST_NO_LONG_LONG
+    /**
+     * 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::ulong_long_type z)
+    {
+        for(boost::ulong_long_type j = 0; j < z; ++j) {
+            (*this)();
+        }
+    }
+#endif
 
 #ifndef BOOST_RANDOM_NO_STREAM_OPERATORS
-  template<class CharT, class Traits>
-  friend std::basic_ostream<CharT,Traits>&
-  operator<<(std::basic_ostream<CharT,Traits>& os, const mersenne_twister& mt)
-  {
-    for(int j = 0; j < mt.state_size; ++j)
-      os << mt.compute(j) << " ";
-    return os;
-  }
-
-  template<class CharT, class Traits>
-  friend std::basic_istream<CharT,Traits>&
-  operator>>(std::basic_istream<CharT,Traits>& is, mersenne_twister& mt)
-  {
-    for(int 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;
-  }
+    /** 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)
+    {
+        for(std::size_t j = 0; j < mt.state_size; ++j)
+            os << mt.compute(j) << " ";
+        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
 
-  friend bool operator==(const mersenne_twister& x, const mersenne_twister& y)
-  {
-    for(int j = 0; j < state_size; ++j)
-      if(x.compute(j) != y.compute(j))
-        return false;
-    return true;
-  }
-
-  friend bool operator!=(const mersenne_twister& x, const mersenne_twister& y)
-  { return !(x == y); }
-#else
-  // Use a member function; Streamable concept not supported.
-  bool operator==(const mersenne_twister& rhs) const
-  {
-    for(int j = 0; j < state_size; ++j)
-      if(compute(j) != rhs.compute(j))
-        return false;
-    return true;
-  }
-
-  bool operator!=(const mersenne_twister& rhs) const
-  { return !(*this == rhs); }
-#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)
+    {
+        for(std::size_t j = 0; j < state_size; ++j)
+            if(x.compute(j) != y.compute(j))
+                return false;
+        return true;
+    }
+    
+    /**
+     * 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 hide_private_members
-  // returns x(i-n+index), where index is in 0..n-1
-  UIntType compute(unsigned int index) const
-  {
-    // equivalent to (i-n+index) % 2n, but doesn't produce negative numbers
-    return x[ (i + n + index) % (2*n) ];
-  }
-  void twist(int block);
-  /// \endcond
-
-  // state representation: next output is o(x(i))
-  //   x[0]  ... x[k] x[k+1] ... x[n-1]     x[n]     ... x[2*n-1]   represents
-  //  x(i-k) ... x(i) x(i+1) ... x(i-k+n-1) x(i-k-n) ... x[i(i-k-1)]
-  // The goal is to always have x(i-n) ... x(i-1) available for
-  // operator== and save/restore.
+    /// \cond hide_private_members
+    // returns x(i-n+index), where index is in 0..n-1
+    UIntType compute(unsigned int index) const
+    {
+        // equivalent to (i-n+index) % 2n, but doesn't produce negative numbers
+        return x[ (i + n + index) % (2*n) ];
+    }
+    void twist(int block);
+    /// \endcond
 
-  UIntType x[2*n]; 
-  int i;
+    // state representation: next output is o(x(i))
+    //   x[0]  ... x[k] x[k+1] ... x[n-1]     x[n]     ... x[2*n-1]   represents
+    //  x(i-k) ... x(i) x(i+1) ... x(i-k+n-1) x(i-k-n) ... x[i(i-k-1)]
+    // The goal is to always have x(i-n) ... x(i-1) available for
+    // operator== and save/restore.
+
+    UIntType x[2*n]; 
+    std::size_t i;
 };
 
 #ifndef BOOST_NO_INCLASS_MEMBER_INITIALIZATION
 //  A definition is required even for integral static constants
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const bool mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::has_fixed_range;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::state_size;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::shift_size;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::mask_bits;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const UIntType mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::parameter_a;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_u;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_s;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const UIntType mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_b;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_t;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const UIntType mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_c;
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-const int mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::output_l;
+#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
 
 /// \cond hide_private_members
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-void mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::twist(int block)
+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(int block)
 {
-  const UIntType upper_mask = (~0u) << r;
-  const UIntType lower_mask = ~upper_mask;
+    const UIntType upper_mask = (~static_cast<UIntType>(0)) << r;
+    const UIntType lower_mask = ~upper_mask;
 
-  if(block == 0) {
-    for(int j = n; j < 2*n; j++) {
-      UIntType y = (x[j-n] & upper_mask) | (x[j-(n-1)] & lower_mask);
-      x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
-    }
-  } else if (block == 1) {
-    // split loop to avoid costly modulo operations
-    {  // extra scope for MSVC brokenness w.r.t. for scope
-      for(int j = 0; j < n-m; j++) {
-        UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
-        x[j] = x[j+n+m] ^ (y >> 1) ^ (y&1 ? a : 0);
-      }
-    }
+    if(block == 0) {
+        for(std::size_t j = n; j < 2*n; j++) {
+            UIntType y = (x[j-n] & upper_mask) | (x[j-(n-1)] & lower_mask);
+            x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
+        }
+    } else if (block == 1) {
+        // 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; j++) {
+                UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
+                x[j] = x[j+n+m] ^ (y >> 1) ^ (y&1 ? a : 0);
+            }
+        }
     
-    for(int j = n-m; j < n-1; j++) {
-      UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
-      x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
-    }
-    // last iteration
-    UIntType y = (x[2*n-1] & upper_mask) | (x[0] & lower_mask);
-    x[n-1] = x[m-1] ^ (y >> 1) ^ (y&1 ? a : 0);
-    i = 0;
-  }
+        for(std::size_t j = n-m; j < n-1; j++) {
+            UIntType y = (x[j+n] & upper_mask) | (x[j+n+1] & lower_mask);
+            x[j] = x[j-(n-m)] ^ (y >> 1) ^ (y&1 ? a : 0);
+        }
+        // last iteration
+        UIntType y = (x[2*n-1] & upper_mask) | (x[0] & lower_mask);
+        x[n-1] = x[m-1] ^ (y >> 1) ^ (y&1 ? a : 0);
+        i = 0;
+    }
 }
 /// \endcond
 
-template<class UIntType, int w, int n, int m, int r, UIntType a, int u,
-  int s, UIntType b, int t, UIntType c, int l, UIntType val>
-inline typename mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::result_type
-mersenne_twister<UIntType,w,n,m,r,a,u,s,b,t,c,l,val>::operator()()
+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(0);
-  else if(i >= 2*n)
-    twist(1);
-  // Step 4
-  UIntType z = x[i];
-  ++i;
-  z ^= (z >> u);
-  z ^= ((z << s) & b);
-  z ^= ((z << t) & c);
-  z ^= (z >> l);
-  return z;
+    if(i == n)
+        twist(0);
+    else if(i >= 2*n)
+        twist(1);
+    // Step 4
+    UIntType z = x[i];
+    ++i;
+    z ^= ((z >> u) & d);
+    z ^= ((z << s) & b);
+    z ^= ((z << t) & c);
+    z ^= (z >> l);
+    return z;
 }
 
-} // namespace random
-
 /**
  * The specializations \mt11213b and \mt19937 are from
  *
@@ -343,8 +391,8 @@
  *  Generation, Vol. 8, No. 1, January 1998, pp. 3-30. 
  *  @endblockquote
  */
-typedef random::mersenne_twister<uint32_t,32,351,175,19,0xccab8ee7,11,
-  7,0x31b6ab00,15,0xffe50000,17, 0xa37d3c92> mt11213b;
+typedef random::mersenne_twister_engine<uint_fast32_t,32,351,175,19,0xccab8ee7,
+    11,0xffffffff,7,0x31b6ab00,15,0xffe50000,17,1812433253> mt11213b;
 
 /**
  * The specializations \mt11213b and \mt19937 are from
@@ -357,11 +405,26 @@
  *  Generation, Vol. 8, No. 1, January 1998, pp. 3-30. 
  *  @endblockquote
  */
-typedef random::mersenne_twister<uint32_t,32,624,397,31,0x9908b0df,11,
-  7,0x9d2c5680,15,0xefc60000,18, 3346425566U> mt19937;
+typedef random::mersenne_twister_engine<uint_fast32_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 random::mersenne_twister_engine<uint_fast64_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
+
+} // 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_HPP

Added: trunk/boost/random/seed_seq.hpp
==============================================================================
--- (empty file)
+++ trunk/boost/random/seed_seq.hpp	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -0,0 +1,100 @@
+/* boost random/seed_seq.hpp header file
+ *
+ * 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$
+ *
+ */
+
+#ifndef BOOST_RANDOM_SEED_SEQ_HPP
+#define BOOST_RANDOM_SEED_SEQ_HPP
+
+#include <boost/config.hpp>
+#include <boost/cstdint.hpp>
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <cstddef>
+#include <vector>
+#include <algorithm>
+#include <iterator>
+
+#ifndef BOOST_NO_INITIALIZER_LISTS
+#include <initializer_list>
+#endif
+
+namespace boost {
+namespace random {
+
+class seed_seq {
+public:
+    typedef boost::uint_least32_t result_type;
+
+    seed_seq() {}
+#ifndef BOOST_NO_INITIALIZER_LISTS
+    template<class T>
+    seed_seq(const std::initializer_list<T>& il) : v(il.begin(), il.end()) {}
+#endif
+    template<class Iter>
+    seed_seq(Iter first, Iter last) : v(first, last) {}
+    template<class Range>
+    explicit seed_seq(const Range& range)
+      : v(boost::begin(range), boost::end(range)) {}
+
+    template<class Iter>
+    void generate(Iter first, Iter last) const
+    {
+        typedef typename std::iterator_traits<Iter>::value_type value_type;
+        std::fill(first, last, static_cast<value_type>(0x8b8b8b8bu));
+        std::size_t s = v.size();
+        std::size_t n = last - first;
+        std::size_t t =
+            (n >= 623) ? 11 :
+            (n >=  68) ?  7 :
+            (n >=  39) ?  5 :
+            (n >=   7) ?  3 :
+            (n - 1)/2;
+        std::size_t p = (n - t) / 2;
+        std::size_t q = p + t;
+        std::size_t m = (std::max)(s+1, n);
+        value_type mask = 0xffffffffu;
+        for(std::size_t k = 0; k < m; ++k) {
+            value_type r1 =
+                *(first + k%n) ^ *(first + (k+p)%n) ^ *(first + (k+n-1)%n);
+            r1 = r1 ^ (r1 >> 27);
+            r1 = (r1 * 1664525u) & mask;
+            value_type r2 = r1 +
+                ((k == 0) ? s :
+                 (k <= s) ? k % n + v[k - 1] :
+                 (k % n));
+            *(first + (k+p)%n) = (*(first + (k+p)%n) + r1) & mask;
+            *(first + (k+q)%n) = (*(first + (k+q)%n) + r2) & mask;
+            *(first + k%n) = r2;
+        }
+        for(std::size_t k = m; k < m + n; ++k) {
+            value_type r3 =
+                (*(first + k%n) + *(first + (k+p)%n) + *(first + (k+n-1)%n))
+                & mask;
+            r3 = r3 ^ (r3 >> 27);
+            r3 = (r3 * 1566083941u) & mask;
+            value_type r4 = r3 - k%m;
+            *(first + (k+p)%n) ^= r4;
+            *(first + (k+q)%n) ^= r3;
+            *(first + k%n) = r4;
+        }
+    }
+    std::size_t size() const { return v.size(); }
+    template<class Iter>
+    void param(Iter out) { std::copy(v.begin(), v.end(), out); }
+private:
+    std::vector<result_type> v;
+};
+
+}
+}
+
+#endif

Modified: trunk/libs/random/test/Jamfile.v2
==============================================================================
--- trunk/libs/random/test/Jamfile.v2	(original)
+++ trunk/libs/random/test/Jamfile.v2	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -25,6 +25,7 @@
     hellekalek1995
     mt11213b
     mt19937
+    mt19937_64
     lagged_fibonacci
     lagged_fibonacci607
     ranlux3
@@ -41,6 +42,8 @@
     run instantiate.cpp : : : <define>BOOST_RANDOM_URNG_TEST=$(urng) : test_$(urng) ;
 }
 
+run test_seed_seq.cpp /boost//unit_test_framework ;
+
 run test_binomial.cpp ;
 run test_binomial_distribution.cpp /boost//unit_test_framework ;
 run test_poisson.cpp ;

Modified: trunk/libs/random/test/instantiate.cpp
==============================================================================
--- trunk/libs/random/test/instantiate.cpp	(original)
+++ trunk/libs/random/test/instantiate.cpp	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -8,10 +8,19 @@
  * $Id$
  */
 
+#include <boost/config.hpp>
+
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300
 #pragma warning( disable : 4786 )
 #endif
 
+#ifdef BOOST_MSVC
+// conversion warnings.  These are unavoidable, since we're
+// testing all possible implicit conversions.
+#pragma warning( disable : 4244 )
+#pragma warning( disable : 4305 )
+#endif
+
 #include <iostream>
 #include <sstream>
 #include <string>

Added: trunk/libs/random/test/test_seed_seq.cpp
==============================================================================
--- (empty file)
+++ trunk/libs/random/test/test_seed_seq.cpp	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -0,0 +1,113 @@
+/* boost test_seed_seq.cpp
+ *
+ * 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)
+ *
+ * $Id$
+ */
+
+#include <boost/random/seed_seq.hpp>
+#include <boost/assign/list_of.hpp>
+#include <boost/config.hpp>
+#include <vector>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+using boost::assign::list_of;
+
+BOOST_AUTO_TEST_CASE(test_seed_seq) {
+    boost::uint32_t expected_param[4] = { 2, 3, 4, 0xdeadbeaf };
+    boost::uint32_t param[4] = { 2, 3, 4, 0xdeadbeaf };
+    boost::uint32_t store32[10];
+    boost::uint64_t store64[10];
+    boost::uint32_t expected[10] = {
+        2571534471u,
+        852093106u,
+        3994144234u,
+        904246505u,
+        3404579686u,
+        1508446734u,
+        3679033230u,
+        2550178480u,
+        4205639301u,
+        268720383u
+    };
+    std::fill_n(&store32[0], 10, 0);
+    std::fill_n(&store64[0], 10, 0);
+    boost::random::seed_seq seq;
+    seq.generate(&store32[0], &store32[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store32[0], &store32[0] + 10, &expected[0], &expected[0] + 10);
+    seq.generate(&store64[0], &store64[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store64[0], &store64[0] + 10, &expected[0], &expected[0] + 10);
+    BOOST_CHECK_EQUAL(seq.size(), 0u);
+    seq.param(&param[0]);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
+
+    boost::uint32_t expected_r[10] = {
+        249299179u,
+        1602610063u,
+        745496312u,
+        3444440002u,
+        1462959439u,
+        4120764957u,
+        2551678045u,
+        2909251680u,
+        3652199668u,
+        1330108271u
+    };
+
+    std::vector<int> data = list_of(2)(3)(4);
+    
+    std::fill_n(&store32[0], 10, 0);
+    std::fill_n(&store64[0], 10, 0);
+    std::fill_n(&param[0], 3, 0);
+    boost::random::seed_seq seq_r(data);
+    seq_r.generate(&store32[0], &store32[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store32[0], &store32[0] + 10, &expected_r[0], &expected_r[0] + 10);
+    seq_r.generate(&store64[0], &store64[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10);
+    BOOST_CHECK_EQUAL(seq_r.size(), 3u);
+    seq_r.param(&param[0]);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
+    
+    std::fill_n(&store32[0], 10, 0);
+    std::fill_n(&store64[0], 10, 0);
+    std::fill_n(&param[0], 3, 0);
+    boost::random::seed_seq seq_it(data.begin(), data.end());
+    seq_it.generate(&store32[0], &store32[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store32[0], &store32[0] + 10, &expected_r[0], &expected_r[0] + 10);
+    seq_it.generate(&store64[0], &store64[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10);
+    BOOST_CHECK_EQUAL(seq_it.size(), 3u);
+    seq_it.param(&param[0]);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
+    
+#ifndef BOOST_NO_INITIALIZER_LISTS
+    std::fill_n(&store32[0], 10, 0);
+    std::fill_n(&store64[0], 10, 0);
+    std::fill_n(&param[0], 3, 0);
+    boost::random::seed_seq seq_il = {2, 3, 4};
+    seq_il.generate(&store32[0], &store32[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store32[0], &store32[0] + 10, &expected_r[0], &expected_r[0] + 10);
+    seq_il.generate(&store64[0], &store64[0] + 10);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &store64[0], &store64[0] + 10, &expected_r[0], &expected_r[0] + 10);
+    BOOST_CHECK_EQUAL(seq_il.size(), 3u);
+    seq_il.param(&param[0]);
+    BOOST_CHECK_EQUAL_COLLECTIONS(
+        &param[0], &param[0] + 4, &expected_param[0], &expected_param[0] + 4);
+#endif
+}

Modified: trunk/libs/random/test/validate.cpp
==============================================================================
--- trunk/libs/random/test/validate.cpp	(original)
+++ trunk/libs/random/test/validate.cpp	2010-06-21 22:30:09 EDT (Mon, 21 Jun 2010)
@@ -49,6 +49,10 @@
 // validation by experiment from mt19937.c
 bool check_(unsigned long x, const boost::mt19937&) { return x == 4123659995U; }
 
+#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
+bool check_(boost::uint64_t x, const boost::mt19937_64&) { return x == UINT64_C(9981545732273789042); }
+#endif
+
 // validation values from the publications
 bool check_(int x, const boost::minstd_rand0&) { return x == 1043618065; }
 
@@ -113,6 +117,9 @@
   validate("ecuyer combined", ecuyer1988());
   validate("mt11213b", mt11213b());
   validate("mt19937", mt19937());
+#if !defined(BOOST_NO_INT64_T) && !defined(BOOST_NO_INTEGRAL_INT64_T)
+  validate("mt19937_64", mt19937_64());
+#endif
   validate("kreutzer1986", kreutzer1986());
   validate("ranlux3", ranlux3());
   validate("ranlux4", ranlux4());