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

Subject: [Boost-commit] svn:boost r68647 - in trunk: boost/random libs/random/test
From: steven_at_[hidden]
Date: 2011-02-05 00:54:23

Author: steven_watanabe
Date: 2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
New Revision: 68647
URL: http://svn.boost.org/trac/boost/changeset/68647

Log:
Update uniform_int and uniform_real.
Added:
   trunk/libs/random/test/test_old_uniform_int.cpp
      - copied, changed from r68627, /trunk/libs/random/test/test_uniform_int.cpp
   trunk/libs/random/test/test_old_uniform_int_distribution.cpp
      - copied, changed from r68627, /trunk/libs/random/test/test_uniform_int_distribution.cpp
   trunk/libs/random/test/test_old_uniform_real.cpp
      - copied, changed from r68627, /trunk/libs/random/test/test_uniform_real.cpp
   trunk/libs/random/test/test_old_uniform_real_distribution.cpp
      - copied, changed from r68627, /trunk/libs/random/test/test_uniform_real_distribution.cpp
Text files modified: 
   trunk/boost/random/uniform_int.hpp                            |   307 ++++++--------------------------------- 
   trunk/boost/random/uniform_real.hpp                           |   112 +++++--------                           
   trunk/libs/random/test/Jamfile.v2                             |     4                                         
   trunk/libs/random/test/test_old_uniform_int.cpp               |     7                                         
   trunk/libs/random/test/test_old_uniform_int_distribution.cpp  |    18 +-                                      
   trunk/libs/random/test/test_old_uniform_real.cpp              |     8                                         
   trunk/libs/random/test/test_old_uniform_real_distribution.cpp |     6                                         
   7 files changed, 113 insertions(+), 349 deletions(-)

Modified: trunk/boost/random/uniform_int.hpp
==============================================================================
--- trunk/boost/random/uniform_int.hpp	(original)
+++ trunk/boost/random/uniform_int.hpp	2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
@@ -18,14 +18,7 @@
 #define BOOST_RANDOM_UNIFORM_INT_HPP
 
 #include <cassert>
-#include <iostream>
-#include <boost/config.hpp>
-#include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/detail/workaround.hpp>
-#include <boost/random/detail/config.hpp>
-#include <boost/random/detail/signed_unsigned_tools.hpp>
-#include <boost/type_traits/make_unsigned.hpp>
+#include <boost/random/uniform_int_distribution.hpp>
 
 namespace boost {
 
@@ -35,264 +28,58 @@
  * distributed in the set of integer numbers {min, min+1, min+2, ..., max}.
  *
  * The template parameter IntType shall denote an integer-like value type.
+ *
+ * This class is deprecated.  Please use @c uniform_int_distribution in
+ * new code.
  */
 template<class IntType = int>
-class uniform_int
+class uniform_int : public random::uniform_int_distribution<IntType>
 {
+    typedef random::uniform_int_distribution<IntType> base_type;
 public:
-  typedef IntType input_type;
-  typedef IntType result_type;
 
-  /// \cond hide_private_members
-  typedef typename make_unsigned<result_type>::type range_type;
-  /// \endcond
-
-  /**
-   * Constructs a uniform_int object. @c min and @c max are
-   * the parameters of the distribution.
-   *
-   * Requires: min <= max
-   */
-  explicit uniform_int(IntType min_arg = 0, IntType max_arg = 9)
-    : _min(min_arg), _max(max_arg)
-  {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    // MSVC fails BOOST_STATIC_ASSERT with std::numeric_limits at class scope
-    BOOST_STATIC_ASSERT(std::numeric_limits<IntType>::is_integer);
-#endif
-    assert(min_arg <= max_arg);
-    init();
-  }
-
-  /**
-   * Returns: The "min" parameter of the distribution
-   */
-  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
-  /**
-   * Returns: The "max" parameter of the distribution
-   */
-  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
-  void reset() { }
-  
-  // can't have member function templates out-of-line due to MSVC bugs
-  template<class Engine>
-  result_type operator()(Engine& eng)
-  {
-      return generate(eng, _min, _max, _range);
-  }
-
-  template<class Engine>
-  result_type operator()(Engine& eng, result_type n)
-  {
-      assert(n > 0);
-
-      if (n == 1)
-      {
-        return 0;
-      }
-
-      return generate(eng, 0, n - 1, n - 1);
-  }
-
-#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 uniform_int& ud)
-  {
-    os << ud._min << " " << ud._max;
-    return os;
-  }
-
-  template<class CharT, class Traits>
-  friend std::basic_istream<CharT,Traits>&
-  operator>>(std::basic_istream<CharT,Traits>& is, uniform_int& ud)
-  {
-    is >> std::ws >> ud._min >> std::ws >> ud._max;
-    ud.init();
-    return is;
-  }
-#endif
-
-private:
-
-#ifdef BOOST_MSVC
-#pragma warning(push)
-// disable division by zero warning, since we can't
-// actually divide by zero.
-#pragma warning(disable:4723)
-#endif
-
-  /// \cond hide_private_members
-  template<class Engine>
-  static result_type generate(Engine& eng, result_type min_value, result_type /*max_value*/, range_type range)
-  {
-    typedef typename Engine::result_type base_result;
-    // ranges are always unsigned
-    typedef typename make_unsigned<base_result>::type base_unsigned;
-    const base_result bmin = (eng.min)();
-    const base_unsigned brange =
-      random::detail::subtract<base_result>()((eng.max)(), (eng.min)());
-
-    if(range == 0) {
-      return min_value;    
-    } else if(brange == range) {
-      // this will probably never happen in real life
-      // basically nothing to do; just take care we don't overflow / underflow
-      base_unsigned v = random::detail::subtract<base_result>()(eng(), bmin);
-      return random::detail::add<base_unsigned, result_type>()(v, min_value);
-    } else if(brange < range) {
-      // use rejection method to handle things like 0..3 --> 0..4
-      for(;;) {
-        // concatenate several invocations of the base RNG
-        // take extra care to avoid overflows
-
-        //  limit == floor((range+1)/(brange+1))
-        //  Therefore limit*(brange+1) <= range+1
-        range_type limit;
-        if(range == (std::numeric_limits<range_type>::max)()) {
-          limit = range/(range_type(brange)+1);
-          if(range % (range_type(brange)+1) == range_type(brange))
-            ++limit;
-        } else {
-          limit = (range+1)/(range_type(brange)+1);
-        }
-
-        // We consider "result" as expressed to base (brange+1):
-        // For every power of (brange+1), we determine a random factor
-        range_type result = range_type(0);
-        range_type mult = range_type(1);
-
-        // loop invariants:
-        //  result < mult
-        //  mult <= range
-        while(mult <= limit) {
-          // Postcondition: result <= range, thus no overflow
-          //
-          // limit*(brange+1)<=range+1                   def. of limit       (1)
-          // eng()-bmin<=brange                          eng() post.         (2)
-          // and mult<=limit.                            loop condition      (3)
-          // Therefore mult*(eng()-bmin+1)<=range+1      by (1),(2),(3)      (4)
-          // Therefore mult*(eng()-bmin)+mult<=range+1   rearranging (4)     (5)
-          // result<mult                                 loop invariant      (6)
-          // Therefore result+mult*(eng()-bmin)<range+1  by (5), (6)         (7)
-          //
-          // Postcondition: result < mult*(brange+1)
-          //
-          // result<mult                                 loop invariant      (1)
-          // eng()-bmin<=brange                          eng() post.         (2)
-          // Therefore result+mult*(eng()-bmin) <
-          //           mult+mult*(eng()-bmin)            by (1)              (3)
-          // Therefore result+(eng()-bmin)*mult <
-          //           mult+mult*brange                  by (2), (3)         (4)
-          // Therefore result+(eng()-bmin)*mult <
-          //           mult*(brange+1)                   by (4)
-          result += static_cast<range_type>(random::detail::subtract<base_result>()(eng(), bmin) * mult);
-
-          // equivalent to (mult * (brange+1)) == range+1, but avoids overflow.
-          if(mult * range_type(brange) == range - mult + 1) {
-              // The destination range is an integer power of
-              // the generator's range.
-              return(result);
-          }
-
-          // Postcondition: mult <= range
-          // 
-          // limit*(brange+1)<=range+1                   def. of limit       (1)
-          // mult<=limit                                 loop condition      (2)
-          // Therefore mult*(brange+1)<=range+1          by (1), (2)         (3)
-          // mult*(brange+1)!=range+1                    preceding if        (4)
-          // Therefore mult*(brange+1)<range+1           by (3), (4)         (5)
-          // 
-          // Postcondition: result < mult
-          //
-          // See the second postcondition on the change to result. 
-          mult *= range_type(brange)+range_type(1);
-        }
-        // loop postcondition: range/mult < brange+1
-        //
-        // mult > limit                                  loop condition      (1)
-        // Suppose range/mult >= brange+1                Assumption          (2)
-        // range >= mult*(brange+1)                      by (2)              (3)
-        // range+1 > mult*(brange+1)                     by (3)              (4)
-        // range+1 > (limit+1)*(brange+1)                by (1), (4)         (5)
-        // (range+1)/(brange+1) > limit+1                by (5)              (6)
-        // limit < floor((range+1)/(brange+1))           by (6)              (7)
-        // limit==floor((range+1)/(brange+1))            def. of limit       (8)
-        // not (2)                                       reductio            (9)
-        //
-        // loop postcondition: (range/mult)*mult+(mult-1) >= range
-        //
-        // (range/mult)*mult + range%mult == range       identity            (1)
-        // range%mult < mult                             def. of %           (2)
-        // (range/mult)*mult+mult > range                by (1), (2)         (3)
-        // (range/mult)*mult+(mult-1) >= range           by (3)              (4)
-        //
-        // Note that the maximum value of result at this point is (mult-1),
-        // so after this final step, we generate numbers that can be
-        // at least as large as range.  We have to really careful to avoid
-        // overflow in this final addition and in the rejection.  Anything
-        // that overflows is larger than range and can thus be rejected.
-
-        // range/mult < brange+1  -> no endless loop
-        range_type result_increment = uniform_int<range_type>(0, range/mult)(eng);
-        if((std::numeric_limits<range_type>::max)() / mult < result_increment) {
-          // The multiplcation would overflow.  Reject immediately.
-          continue;
-        }
-        result_increment *= mult;
-        // unsigned integers are guaranteed to wrap on overflow.
-        result += result_increment;
-        if(result < result_increment) {
-          // The addition overflowed.  Reject.
-          continue;
-        }
-        if(result > range) {
-          // Too big.  Reject.
-          continue;
-        }
-        return random::detail::add<range_type, result_type>()(result, min_value);
-      }
-    } else {                   // brange > range
-      base_unsigned bucket_size;
-      // it's safe to add 1 to range, as long as we cast it first,
-      // because we know that it is less than brange.  However,
-      // we do need to be careful not to cause overflow by adding 1
-      // to brange.
-      if(brange == (std::numeric_limits<base_unsigned>::max)()) {
-        bucket_size = brange / (static_cast<base_unsigned>(range)+1);
-        if(brange % (static_cast<base_unsigned>(range)+1) == static_cast<base_unsigned>(range)) {
-          ++bucket_size;
-        }
-      } else {
-        bucket_size = (brange+1) / (static_cast<base_unsigned>(range)+1);
-      }
-      for(;;) {
-        base_unsigned result =
-          random::detail::subtract<base_result>()(eng(), bmin);
-        result /= bucket_size;
-        // result and range are non-negative, and result is possibly larger
-        // than range, so the cast is safe
-        if(result <= static_cast<base_unsigned>(range))
-          return random::detail::add<base_unsigned, result_type>()(result, min_value);
-      }
+    class param_type : public base_type::param_type
+    {
+    public:
+        typedef uniform_int distribution_type;
+        /**
+         * Constructs the parameters of a uniform_int distribution.
+         *
+         * Requires: min <= max
+         */
+        explicit param_type(IntType min_arg = 0, IntType max_arg = 9)
+          : base_type::param_type(min_arg, max_arg)
+        {}
+    };
+
+    /**
+     * Constructs a uniform_int object. @c min and @c max are
+     * the parameters of the distribution.
+     *
+     * Requires: min <= max
+     */
+    explicit uniform_int(IntType min_arg = 0, IntType max_arg = 9)
+      : base_type(min_arg, max_arg)
+    {}
+
+    /** Constructs a uniform_int distribution from its parameters. */
+    explicit uniform_int(const param_type& parm)
+      : base_type(parm)
+    {}
+
+    /** Returns the parameters of the distribution */
+    param_type param() const { return param_type(this->a(), this->b()); }
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm) { this->base_type::param(parm); }
+
+    using base_type::operator();
+
+    template<class Engine>
+    IntType operator()(Engine& eng, IntType n)
+    {
+        assert(n > 0);
+        return (*this)(eng, param_type(0, n - 1));
     }
-  }
-
-#ifdef BOOST_MSVC
-#pragma warning(pop)
-#endif
-
-  void init()
-  {
-    _range = random::detail::subtract<result_type>()(_max, _min);
-  }
-
-  /// \endcond
-
-  // The result_type may be signed or unsigned, but the _range is always
-  // unsigned.
-  result_type _min, _max;
-  range_type _range;
 };
 
 } // namespace boost

Modified: trunk/boost/random/uniform_real.hpp
==============================================================================
--- trunk/boost/random/uniform_real.hpp	(original)
+++ trunk/boost/random/uniform_real.hpp	2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
@@ -18,89 +18,63 @@
 #define BOOST_RANDOM_UNIFORM_REAL_HPP
 
 #include <cassert>
-#include <iostream>
 #include <boost/config.hpp>
 #include <boost/limits.hpp>
-#include <boost/static_assert.hpp>
-#include <boost/random/detail/config.hpp>
+#include <boost/random/uniform_real_distribution.hpp>
 
 namespace boost {
 
 /**
  * The distribution function uniform_real models a random distribution.
  * On each invocation, it returns a random floating-point value uniformly
- * distributed in the range [min..max). The value is computed using
- * std::numeric_limits<RealType>::digits random binary digits, i.e.
- * the mantissa of the floating-point value is completely filled with
- * random bits.
+ * distributed in the range [min..max).
  *
- * Note: The current implementation is buggy, because it may not fill
- * all of the mantissa with random bits.
+ * This class is deprecated.  Please use @c uniform_real_distribution in
+ * new code.
  */
 template<class RealType = double>
-class uniform_real
+class uniform_real : public random::uniform_real_distribution<RealType>
 {
+    typedef random::uniform_real_distribution<RealType> base_type;
 public:
-  typedef RealType input_type;
-  typedef RealType result_type;
 
-  /**
-   * Constructs a uniform_real object. @c min and @c max are the
-   * parameters of the distribution.
-   *
-   * Requires: min <= max
-   */
-  explicit uniform_real(RealType min_arg = RealType(0.0),
-                        RealType max_arg = RealType(1.0))
-    : _min(min_arg), _max(max_arg)
-  {
-#ifndef BOOST_NO_LIMITS_COMPILE_TIME_CONSTANTS
-    BOOST_STATIC_ASSERT(!std::numeric_limits<RealType>::is_integer);
-#endif
-    assert(min_arg <= max_arg);
-  }
-
-  // compiler-generated copy ctor and assignment operator are fine
-
-  /**
-   * Returns: The "min" parameter of the distribution
-   */
-  result_type min BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _min; }
-  /**
-   * Returns: The "max" parameter of the distribution
-   */
-  result_type max BOOST_PREVENT_MACRO_SUBSTITUTION () const { return _max; }
-  void reset() { }
-
-  template<class Engine>
-  result_type operator()(Engine& eng) {
-    result_type numerator = static_cast<result_type>(eng() - eng.min BOOST_PREVENT_MACRO_SUBSTITUTION());
-    result_type divisor = static_cast<result_type>(eng.max BOOST_PREVENT_MACRO_SUBSTITUTION() - eng.min BOOST_PREVENT_MACRO_SUBSTITUTION());
-    assert(divisor > 0);
-    assert(numerator >= 0 && numerator <= divisor);
-    return numerator / divisor * (_max - _min) + _min;
-  }
-
-#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 uniform_real& ud)
-  {
-    os << ud._min << " " << ud._max;
-    return os;
-  }
-
-  template<class CharT, class Traits>
-  friend std::basic_istream<CharT,Traits>&
-  operator>>(std::basic_istream<CharT,Traits>& is, uniform_real& ud)
-  {
-    is >> std::ws >> ud._min >> std::ws >> ud._max;
-    return is;
-  }
-#endif
-
-private:
-  RealType _min, _max;
+    class param_type : public base_type::param_type
+    {
+    public:
+        typedef uniform_real distribution_type;
+        /**
+         * Constructs the parameters of a uniform_real distribution.
+         *
+         * Requires: min <= max
+         */
+        explicit param_type(RealType min_arg = RealType(0.0),
+                            RealType max_arg = RealType(1.0))
+          : base_type::param_type(min_arg, max_arg)
+        {}
+    };
+
+    /**
+     * Constructs a uniform_real object. @c min and @c max are the
+     * parameters of the distribution.
+     *
+     * Requires: min <= max
+     */
+    explicit uniform_real(RealType min_arg = RealType(0.0),
+                          RealType max_arg = RealType(1.0))
+      : base_type(min_arg, max_arg)
+    {
+        assert(min_arg <= max_arg);
+    }
+
+    /** Constructs a uniform_real distribution from its parameters. */
+    explicit uniform_real(const param_type& parm)
+      : base_type(parm)
+    {}
+
+    /** Returns the parameters of the distribution */
+    param_type param() const { return param_type(this->a(), this->b()); }
+    /** Sets the parameters of the distribution. */
+    void param(const param_type& parm) { this->base_type::param(parm); }
 };
 
 } // namespace boost

Modified: trunk/libs/random/test/Jamfile.v2
==============================================================================
--- trunk/libs/random/test/Jamfile.v2	(original)
+++ trunk/libs/random/test/Jamfile.v2	2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
@@ -92,6 +92,10 @@
 run test_uniform_on_sphere_distribution.cpp /boost//unit_test_framework ;
 run test_uniform_smallint.cpp ;
 run test_uniform_smallint_distribution.cpp /boost//unit_test_framework ;
+run test_old_uniform_real.cpp ;
+run test_old_uniform_real_distribution.cpp /boost//unit_test_framework ;
+run test_old_uniform_int.cpp ;
+run test_old_uniform_int_distribution.cpp /boost//unit_test_framework ;
 
 # run nondet_random_speed.cpp ;
 # run random_device.cpp ;

Copied: trunk/libs/random/test/test_old_uniform_int.cpp (from r68627, /trunk/libs/random/test/test_uniform_int.cpp)
==============================================================================
--- /trunk/libs/random/test/test_uniform_int.cpp	(original)
+++ trunk/libs/random/test/test_old_uniform_int.cpp	2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
@@ -1,4 +1,4 @@
-/* test_uniform_int.cpp
+/* test_old_uniform_int.cpp
  *
  * Copyright Steven Watanabe 2011
  * Distributed under the Boost Software License, Version 1.0. (See
@@ -9,11 +9,10 @@
  *
  */
 
-#include <boost/random/uniform_int_distribution.hpp>
-#include <boost/random/uniform_real.hpp>
+#include <boost/random/uniform_int.hpp>
 #include <boost/math/distributions/uniform.hpp>
 
-#define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_int_distribution<>
+#define BOOST_RANDOM_DISTRIBUTION boost::uniform_int<>
 #define BOOST_RANDOM_DISTRIBUTION_NAME uniform_int
 #define BOOST_MATH_DISTRIBUTION boost::math::uniform
 #define BOOST_RANDOM_ARG1_TYPE int

Copied: trunk/libs/random/test/test_old_uniform_int_distribution.cpp (from r68627, /trunk/libs/random/test/test_uniform_int_distribution.cpp)
==============================================================================
--- /trunk/libs/random/test/test_uniform_int_distribution.cpp	(original)
+++ trunk/libs/random/test/test_old_uniform_int_distribution.cpp	2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
@@ -1,4 +1,4 @@
-/* test_uniform_int_distribution.cpp
+/* test_old_uniform_int_distribution.cpp
  *
  * Copyright Steven Watanabe 2011
  * Distributed under the Boost Software License, Version 1.0. (See
@@ -9,22 +9,22 @@
  *
  */
 
-#include <boost/random/uniform_int_distribution.hpp>
+#include <boost/random/uniform_int.hpp>
 #include <limits>
 
-#define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_int_distribution<>
+#define BOOST_RANDOM_DISTRIBUTION boost::uniform_int<>
 #define BOOST_RANDOM_ARG1 a
 #define BOOST_RANDOM_ARG2 b
 #define BOOST_RANDOM_ARG1_DEFAULT 0
-#define BOOST_RANDOM_ARG2_DEFAULT 0x7fffffff
-#define BOOST_RANDOM_ARG1_VALUE 100
+#define BOOST_RANDOM_ARG2_DEFAULT 9
+#define BOOST_RANDOM_ARG1_VALUE 5
 #define BOOST_RANDOM_ARG2_VALUE 250
 
 #define BOOST_RANDOM_DIST0_MIN 0
-#define BOOST_RANDOM_DIST0_MAX 0x7fffffff
-#define BOOST_RANDOM_DIST1_MIN 100
-#define BOOST_RANDOM_DIST1_MAX 0x7fffffff
-#define BOOST_RANDOM_DIST2_MIN 100
+#define BOOST_RANDOM_DIST0_MAX 9
+#define BOOST_RANDOM_DIST1_MIN 5
+#define BOOST_RANDOM_DIST1_MAX 9
+#define BOOST_RANDOM_DIST2_MIN 5
 #define BOOST_RANDOM_DIST2_MAX 250
 
 #define BOOST_RANDOM_TEST1_PARAMS (0, 9)

Copied: trunk/libs/random/test/test_old_uniform_real.cpp (from r68627, /trunk/libs/random/test/test_uniform_real.cpp)
==============================================================================
--- /trunk/libs/random/test/test_uniform_real.cpp	(original)
+++ trunk/libs/random/test/test_old_uniform_real.cpp	2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
@@ -1,4 +1,4 @@
-/* test_uniform_real.cpp
+/* test_old_uniform_real.cpp
  *
  * Copyright Steven Watanabe 2011
  * Distributed under the Boost Software License, Version 1.0. (See
@@ -9,12 +9,12 @@
  *
  */
 
-#include <boost/random/uniform_real_distribution.hpp>
+#include <boost/random/uniform_real.hpp>
 #include <boost/random/uniform_real.hpp>
 #include <boost/math/distributions/uniform.hpp>
 
-#define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_real_distribution<>
-#define BOOST_RANDOM_DISTRIBUTION_NAME uniform_int
+#define BOOST_RANDOM_DISTRIBUTION boost::uniform_real<>
+#define BOOST_RANDOM_DISTRIBUTION_NAME uniform_real
 #define BOOST_MATH_DISTRIBUTION boost::math::uniform
 #define BOOST_RANDOM_ARG1_TYPE double
 #define BOOST_RANDOM_ARG1_NAME b

Copied: trunk/libs/random/test/test_old_uniform_real_distribution.cpp (from r68627, /trunk/libs/random/test/test_uniform_real_distribution.cpp)
==============================================================================
--- /trunk/libs/random/test/test_uniform_real_distribution.cpp	(original)
+++ trunk/libs/random/test/test_old_uniform_real_distribution.cpp	2011-02-05 00:54:11 EST (Sat, 05 Feb 2011)
@@ -1,4 +1,4 @@
-/* test_uniform_real_distribution.cpp
+/* test_old_uniform_real_distribution.cpp
  *
  * Copyright Steven Watanabe 2011
  * Distributed under the Boost Software License, Version 1.0. (See
@@ -9,10 +9,10 @@
  *
  */
 
-#include <boost/random/uniform_real_distribution.hpp>
+#include <boost/random/uniform_real.hpp>
 #include <limits>
 
-#define BOOST_RANDOM_DISTRIBUTION boost::random::uniform_real_distribution<>
+#define BOOST_RANDOM_DISTRIBUTION boost::uniform_real<>
 #define BOOST_RANDOM_ARG1 a
 #define BOOST_RANDOM_ARG2 b
 #define BOOST_RANDOM_ARG1_DEFAULT 0.0