Updated boost to v1.55.0

[rsem.git] / boost / random / uniform_real.hpp

diff --git a/boost/random/uniform_real.hpp b/boost/random/uniform_real.hpp
index 06bfbc39ab16fc1daac9fb4497fa2cf35d99d07a..396072e2d8019db9f0ab3fe967ff82f406d23652 100644 (file)
--- a/boost/random/uniform_real.hpp
+++ b/boost/random/uniform_real.hpp
@@ -7,7 +7,7 @@
  *
  * See http://www.boost.org for most recent version including documentation.
  *
- * $Id: uniform_real.hpp 60755 2010-03-22 00:45:06Z steven_watanabe $
+ * $Id: uniform_real.hpp 71018 2011-04-05 21:27:52Z steven_watanabe $
  *
  * Revision history
  *  2001-04-08  added min<max assertion (N. Becker)
@@ -17,90 +17,64 @@
 #ifndef BOOST_RANDOM_UNIFORM_REAL_HPP
 #define BOOST_RANDOM_UNIFORM_REAL_HPP
 
-#include <cassert>
-#include <iostream>
+#include <boost/assert.hpp>
 #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),
-                        RealType max_arg = RealType(1))
-    : _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);
-  }
+    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)
+        {}
+    };
 
-  // compiler-generated copy ctor and assignment operator are fine
+    /**
+     * 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)
+    {
+        BOOST_ASSERT(min_arg <= max_arg);
+    }
 
-  /**
-   * 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() { }
+    /** Constructs a uniform_real distribution from its parameters. */
+    explicit uniform_real(const param_type& parm)
+      : base_type(parm)
+    {}
 
-  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;
+    /** 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