[Boost-commit] svn:boost r78112 - in sandbox/fixed_point: boost/fixed_point libs/fixed_point/example

Subject: [Boost-commit] svn:boost r78112 - in sandbox/fixed_point: boost/fixed_point libs/fixed_point/example
From: vicente.botet_at_[hidden]
Date: 2012-04-21 08:26:53

Author: viboes
Date: 2012-04-21 08:26:52 EDT (Sat, 21 Apr 2012)
New Revision: 78112
URL: http://svn.boost.org/trac/boost/changeset/78112

Log:
FixedPoint: Added more comments + refactor conversion from arithmetic types
Text files modified: 
   sandbox/fixed_point/boost/fixed_point/number.hpp       |   486 +++++++++++++++++++++++++++++++-------- 
   sandbox/fixed_point/libs/fixed_point/example/ex_xx.cpp |    22                                         
   2 files changed, 398 insertions(+), 110 deletions(-)

Modified: sandbox/fixed_point/boost/fixed_point/number.hpp
==============================================================================
--- sandbox/fixed_point/boost/fixed_point/number.hpp	(original)
+++ sandbox/fixed_point/boost/fixed_point/number.hpp	2012-04-21 08:26:52 EDT (Sat, 21 Apr 2012)
@@ -26,6 +26,7 @@
 #include <boost/type_traits/is_signed.hpp>
 #include <boost/type_traits/is_arithmetic.hpp>
 #include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_floating_point.hpp>
 #include <boost/utility/enable_if.hpp>
 #include <boost/assert.hpp>
 #include <boost/static_assert.hpp>
@@ -34,13 +35,16 @@
 #include <boost/integer/static_log2.hpp>
 #include <boost/ratio/detail/mpl/abs.hpp>
 #include <limits>
+#include <stdexcept>
 #include <cmath>
 #include <boost/integer_traits.hpp>
 
 #include <boost/config.hpp>
 //#include <boost/fixed_point/config.hpp>
+//#include <boost/fixed_point/number_fwd.hpp>
 //#include <boost/fixed_point/round/nearest_odd.hpp>
 //#include <boost/fixed_point/overflow/exception.hpp>
+//#include <boost/fixed_point/detail/helpers.hpp>
 
 #include <limits>
 
@@ -48,6 +52,7 @@
 {
   namespace fixed_point
   {
+    //#include <boost/fixed_point/detail/helpers.hpp>
     namespace detail
     {
 
@@ -129,26 +134,71 @@
 
     }
 
+    //#include <boost/fixed_point/overflow/exceptions.hpp>
     /**
      * Exception throw when there is a positive overflow.
      */
-    struct positive_overflow
+    class positive_overflow: public std::overflow_error
     {
+    public:
+      positive_overflow() :
+        std::overflow_error("FixedPoint: positive overflow")
+      {
+      }
+      explicit positive_overflow(const std::string& what_arg) :
+        std::overflow_error(what_arg)
+      {
+      }
+      explicit positive_overflow(const char* what_arg) :
+        std::overflow_error(what_arg)
+      {
+      }
     };
+
     /**
      * Exception throw when there is a negative overflow.
      */
-    struct negative_overflow
+    class negative_overflow: public std::underflow_error
     {
+    public:
+      negative_overflow() :
+        std::underflow_error("FixedPoint: negative overflow")
+      {
+      }
+      explicit negative_overflow(const std::string& what_arg) :
+        std::underflow_error(what_arg)
+      {
+      }
+      explicit negative_overflow(const char* what_arg) :
+        std::underflow_error(what_arg)
+      {
+      }
     };
 
-    /**
-     * Namespace for rounding policies.
-     */
     namespace round
     {
+#if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
+      /**
+       * When the computation is not exact, rounding will be to one of the two nearest representable values.
+       * The algorithm for choosing between these values is the rounding mode.
+       * Different applications desire different modes, so programmers may specify its own rounding mode.
+       * However the library provides the usual rounding policies.
+       * All of them follwos the following this stereotype
+       *
+       */
+
+      struct stereotype
+      {
+        BOOST_STATIC_CONSTEXPR
+        std::float_round_style round_style;
+        template <typename From, typename To>
+        static typename To::underlying_type round(From const& rhs);
+        template <typename To, typename From>
+        static typename To::underlying_type round_divide(From const& lhs, From const& rhs);
+      };
+#endif
       /**
-       * Use the fastest rounding.
+       *  Speed is more important than the choice in value.
        */
       struct fastest
       {
@@ -158,11 +208,31 @@
 
       /**
        * Rounds toward negative infinity.
+       *
+       * This mode is useful in interval arithmetic.
        */
       struct negative
       {
         BOOST_STATIC_CONSTEXPR
         std::float_round_style round_style = std::round_toward_neg_infinity;
+
+        template <typename From, typename To>
+        static typename To::underlying_type round_integral(From const& rhs)
+        {
+          BOOST_STATIC_CONSTEXPR boost::uintmax_t d = To::resolution_exp;
+          typedef typename detail::max_type<is_signed<typename To::underlying_type>::value>::type tmp_type;
+          BOOST_STATIC_ASSERT(d < (8 * sizeof(tmp_type)));
+
+          tmp_type res = tmp_type(rhs) >> d;
+          return res;
+        }
+
+        template <typename From, typename To>
+        static typename To::underlying_type round_float_point(From const& rhs)
+        {
+          return To::integer_part(rhs / To::template factor<From>());
+        }
+
         template <typename From, typename To>
         static typename To::underlying_type round(From const& rhs)
         {
@@ -207,11 +277,34 @@
       };
       /**
        * Rounds toward zero.
+       *
+       * This mode is useful in implementing integral arithmetic.
        */
       struct truncated
       {
         BOOST_STATIC_CONSTEXPR
         std::float_round_style round_style = std::round_toward_zero;
+
+        template <typename From, typename To>
+        static typename To::underlying_type round_integral(From const& rhs)
+        {
+          BOOST_STATIC_CONSTEXPR boost::uintmax_t d = To::resolution_exp;
+          typedef typename detail::max_type<is_signed<typename To::underlying_type>::value>::type tmp_type;
+          BOOST_STATIC_ASSERT(d < (8 * sizeof(tmp_type)));
+
+          tmp_type m( ( (rhs > 0) ? rhs : -rhs));
+          tmp_type s( ( (rhs > 0) ? +1 : -1));
+
+          tmp_type res = s * (m >> d);
+          return res;
+        }
+
+        template <typename From, typename To>
+        static typename To::underlying_type round_float_point(From const& rhs)
+        {
+          return To::integer_part(rhs / To::template factor<From>());
+        }
+
         template <typename From, typename To>
         static typename To::underlying_type round(From const& rhs)
         {
@@ -239,11 +332,36 @@
       };
       /**
        * Rounds toward positive infinity.
+       *
+       * This mode is useful in interval arithmetic.
        */
       struct positive
       {
         BOOST_STATIC_CONSTEXPR
         std::float_round_style round_style = std::round_toward_infinity;
+
+        template <typename From, typename To>
+        static typename To::underlying_type round_integral(From const& rhs)
+        {
+          BOOST_STATIC_CONSTEXPR boost::uintmax_t d = To::resolution_exp;
+          typedef typename detail::max_type<is_signed<typename To::underlying_type>::value>::type tmp_type;
+          BOOST_STATIC_ASSERT(d < (8 * sizeof(tmp_type)));
+
+          BOOST_STATIC_CONSTEXPR tmp_type w = (1<<d)-1;
+          tmp_type i = rhs;
+
+          BOOST_ASSERT(i <= (integer_traits<tmp_type>::const_max - w));
+
+          tmp_type res = (i + w) >> d;
+          return res;
+        }
+
+        template <typename From, typename To>
+        static typename To::underlying_type round_float_point(From const& rhs)
+        {
+          return To::integer_part(rhs / To::template factor<From>());
+        }
+
         template <typename From, typename To>
         static typename To::underlying_type round(From const& rhs)
         {
@@ -291,7 +409,9 @@
         }
       };
       /**
-       * Rounds to nearest half up.
+       * Round towards the nearest value, but exactly-half values are rounded towards maximum magnitude.
+       *
+       * This mode is the standard school algorithm.
        */
       struct nearest_half_up
       {
@@ -307,7 +427,8 @@
         std::float_round_style round_style = std::round_to_nearest;
       };
       /**
-       * Rounds to nearest even.
+       * Round towards the nearest value, but exactly-half values are rounded towards even values.
+       * This mode has more balance than the classic mode.
        */
       struct nearest_even
       {
@@ -315,7 +436,8 @@
         std::float_round_style round_style = std::round_to_nearest;
       };
       /**
-       * Rounds to nearest odd.
+       * Round towards the nearest value, but exactly-half values are rounded towards odd values.
+       * This mode has as much balance as the near_even mode, but preserves more information.
        */
       struct nearest_odd
       {
@@ -324,13 +446,39 @@
       };
     }
 
-    /**
-     * Namespace for overflow policies.
-     */
     namespace overflow
     {
+
+#if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
       /**
-       * Overflow is impossible and ensured by the user.
+       * Since the range of intermediate values grow to hold all possible values, and variables have a static range and
+       * resolution, construction and assignment may need to reduce the range and resolution.
+       * Reducing the resolution is done with a rounding mode associated with the variable.
+       * When the dynamic value exceeds the range of variable, the assignment overflows.
+       *
+       * When an overflow does occur, the desirable behavior depends on the application, so programmers may specify the
+       * overflow mode with his own specific overflow policy. The library provides however the usual ones.
+       * All of them follows the following stereotype
+       */
+      struct stereotype
+      {
+        BOOST_STATIC_CONSTEXPR
+        bool is_modulo;
+
+        template <typename T, typename U>
+        static BOOST_CONSTEXPR
+        typename T::underlying_type
+        on_negative_overflow(U value);
+
+        template <typename T, typename U>
+        static BOOST_CONSTEXPR
+        typename T::underlying_type
+        on_positive_overflow(U value);
+      };
+#endif
+      /**
+       * Programmer analysis of the program has determined that overflow cannot occur.
+       * Uses of this mode should be accompanied by an argument supporting the conclusion.
        *
        * An assertion is raised on debug mode.
        */
@@ -358,9 +506,7 @@
         }
       };
       /**
-       * Overflow is undefined.
-       *
-       * Usually uses the fastest overflow approach.
+       * Programmers are willing to accept undefined behavior in the event of an overflow.
        */
       struct undefined
       {
@@ -379,6 +525,7 @@
           return value;
         }
       };
+#if ! defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
       namespace detail
       {
         template <typename T, typename U, bool TisSigned = T::is_signed>
@@ -422,8 +569,11 @@
           }
         };
       }
+#endif
+
       /**
-       * Overflow results are wrapped.
+       * The assigned value is the dynamic value @c mod the range of the variable.
+       * This mode makes sense only with unsigned numbers. It is useful for angular measures.
        */
       struct modulus
       {
@@ -443,7 +593,7 @@
         }
       };
       /**
-       * On overflow the results is the nearest.
+       * If the dynamic value exceeds the range of the variable, assign the nearest representable value.
        */
       struct saturate
       {
@@ -464,7 +614,7 @@
 
       };
       /**
-       * On overflow an exception is thrown.
+       * If the dynamic value exceeds the range of the variable, throw an exception of derived from std::overflow_error.
        */
       struct exception
       {
@@ -491,6 +641,27 @@
     {
 
       /**
+       * Every storage policy must define two meta-functions <c>signed_integer_type<Range, Resolution>::type</c> and
+       * <c>unsigned_integer_type<Range, Resolution>::type</c>.
+       */
+      struct stereotype
+      {
+        /**
+         * Gets the signed integer type with enough bits to manage with
+         * the Range and Resolution.
+         */
+        template <int Range, int Resolution>
+        struct signed_integer_type;
+
+        /**
+         * Gets the unsigned integer type with enough bits to manage with
+         * the Range and Resolution
+         */
+        template <int Range, int Resolution>
+        struct unsigned_integer_type;
+      };
+
+      /**
        * The storage is undefined.
        */
       struct undefined
@@ -551,13 +722,33 @@
     }
 
     /**
-     * Namespace for conversion policies.
+     * Since fixed points have different range and resolution the user needs to convert from one type to another.
+     *
+     * When the target type has a larger range and a more precise resolution than the source type, the conversion is implicit.
+     * Otherwise, as the conversion could loss information, the conversion should be explicit to be safe.
+     * Anyway some domains could consider that working with fixed-points should mimic the builtin and expect this conversion to be implicit.
+     * If for this reason that the library manage with both cases via the conversion policy.
+     *
+     * The conversion from builtins arithmetic types suffer from the same loss of information issue but
+     * some users could find an implicit conversion more natural.
+     *
+     * Conversions to builtins arithmetic types is a different concern.
+     * There is no know way to enable conversions operator subject to conditions on the type.
+     * The library has taken a conservative approach and only explicit conversions are provided.
+     * The user could always wrap the type and provide implicit conversion.
+     *
      */
     namespace conversion
     {
+      /**
+       * Used to state that a conversion needs to be explicit.
+       */
       struct explicitly
       {
       };
+      /**
+       * Used to state that a conversion needs to be implicit.
+       */
       struct implicitly
       {
       };
@@ -568,9 +759,37 @@
      */
     namespace arithmetic
     {
+      /*
+       * The range and resolution of the result of basic operations are deduced to try to hold the mathematical results.
+       * This deduction depends on the bound policy.
+       *
+       * - unbounded: The range and resolution of the result of basic operations are large enough to hold the mathematical results.
+       *
+       * Overflow in template argument computation is undefined behavior.
+       * In practice, overflow is unlikely to be a significant problem because even small machines can represent
+       * numbers with thousands of bits and because compiler can diagnose overflow in template arguments.
+       *
+       * The special case in the operations is division, where the mathematical result may require an infinite
+       * number of bits. The actual value must be rounded to a representable value.
+       * The above resolution is sufficient to ensure that if the mathematical result is not zero, the fixed-point
+       * result is not zero.
+       * Furthermore, assuming values have an error of one-half ULP, the defined resolution is close to the error
+       * bound in the computation.
+       *
+       * - bounded: As far as the result type is large enough to hold mathematical results it behaves as the unbounded one.
+       * When the bounding type is not enough large the operation is undefined.
+       * The user need to use functions that have the expected result type as parameter.
+       *
+       * Overflow while computing the arithmetic operations can be detected in this bounded cases.
+       *
+       */
       struct open
       {
       };
+      /*
+       * The range and resolution of the result is the one of the argument operations.
+       * In order to mix different fixed points, the user could be forced to convert explicitly the arguments to the expected type.
+       */
       struct closed
       {
       };
@@ -581,9 +800,19 @@
      */
     namespace bound
     {
+      /**
+       * Bounded fixed points types are closed, that is that the result of an arithmetic operations will be
+       * closed only if both arguments are closed.
+       * The range and resolution are bounded by the larger integral type provided by the compiler.
+       *
+       */
       struct bounded
       {
       };
+
+      /**
+       * The range and resolution of the result of basic operations are large enough to hold the mathematical results.
+       */
       struct unbounded
       {
       };
@@ -748,6 +977,7 @@
     template <class From, class To>
     To number_cast(From const& from);
 
+    //#include <boost/fixed_point/detail/helpers.hpp>
     namespace detail
     {
       template <typename T, int Range, int Resolution >
@@ -1678,47 +1908,48 @@
       typename default_type<F1,F2>::type
       > type;
     };
-#endif
-
-    template <typename T, typename U>
-    struct is_more_precisse;
+#endif // BOOST_FIXED_POINT_DOXYGEN_INVOKED
+    namespace detail
+    {
+      template <typename T, typename U>
+      struct is_more_precisse;
 
-#if ! defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    template <
-    int R1, int P1, typename RP1, typename OP1, typename F1,
-    int R2, int P2, typename RP2, typename OP2, typename F2
-    >
-    struct is_more_precisse<real_t<R1,P1,RP1,OP1,F1>, real_t<R2,P2,RP2,OP2,F2> > :
-    mpl::and_ <
-    mpl::less_equal < mpl::int_<R2>, mpl::int_<R1> >,
-    mpl::greater_equal < mpl::int_<P2>, mpl::int_<P1> >
-    >
-    {};
+      template <
+      int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2
+      >
+      struct is_more_precisse<real_t<R1,P1,RP1,OP1,F1>, real_t<R2,P2,RP2,OP2,F2> > :
+      mpl::and_ <
+      mpl::less_equal < mpl::int_<R2>, mpl::int_<R1> >,
+      mpl::greater_equal < mpl::int_<P2>, mpl::int_<P1> >
+      >
+      {};
 
-    template <
-    int R1, int P1, typename RP1, typename OP1, typename F1,
-    int R2, int P2, typename RP2, typename OP2, typename F2
-    >
-    struct is_more_precisse<real_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> > :
-    mpl::and_ <
-    mpl::less_equal < mpl::int_<R2>, mpl::int_<R1> >,
-    mpl::greater_equal < mpl::int_<P2>, mpl::int_<P1> >
-    >
-    {};
+      template <
+      int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2
+      >
+      struct is_more_precisse<real_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> > :
+      mpl::and_ <
+      mpl::less_equal < mpl::int_<R2>, mpl::int_<R1> >,
+      mpl::greater_equal < mpl::int_<P2>, mpl::int_<P1> >
+      >
+      {};
 
-    template <
-    int R1, int P1, typename RP1, typename OP1, typename F1,
-    int R2, int P2, typename RP2, typename OP2, typename F2
-    >
-    struct is_more_precisse<ureal_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> > :
-    mpl::and_ <
-    mpl::less_equal < mpl::int_<R2>, mpl::int_<R1> >,
-    mpl::greater_equal < mpl::int_<P2>, mpl::int_<P1> >
-    >
-    {};
+      template <
+      int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2
+      >
+      struct is_more_precisse<ureal_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> > :
+      mpl::and_ <
+      mpl::less_equal < mpl::int_<R2>, mpl::int_<R1> >,
+      mpl::greater_equal < mpl::int_<P2>, mpl::int_<P1> >
+      >
+      {};
+    }
 
     template <typename S, typename T>
-    struct is_convertible : is_more_precisse<T,S>
+    struct is_convertible : detail::is_more_precisse<T,S>
     {};
 
     template <typename S, typename T, bool IsArithmetic=is_arithmetic<S>::value >
@@ -1727,7 +1958,7 @@
     struct is_explicitly_convertible<S,T,false> :
     mpl::and_<
     mpl::not_<allows_implicit_conversion_from_fp<T> >,
-    mpl::not_<is_more_precisse<T,S> >
+    mpl::not_<detail::is_more_precisse<T,S> >
     >
     {};
 
@@ -1742,7 +1973,7 @@
     struct is_implicitly_convertible<S,T,false> :
     mpl::and_<
     allows_implicit_conversion_from_fp<T>,
-    mpl::not_<is_more_precisse<T,S> >
+    mpl::not_<detail::is_more_precisse<T,S> >
     >
     {};
 
@@ -1750,7 +1981,6 @@
     struct is_implicitly_convertible<S,T,true> :
     allows_implicit_conversion_from_builtin<T>
     {};
-#endif
 
     /**
      * @brief Signed fixed point number.
@@ -1771,8 +2001,10 @@
       BOOST_MPL_ASSERT_MSG(Range>=Resolution,
           RANGE_MUST_BE_GREATER_EQUAL_THAN_RESOLUTION, (mpl::int_<Range>,mpl::int_<Resolution>));
 #endif
-    public:
 
+    public:
+      //! this type
+      typedef real_t self_type;
       // name the template parameters
       //! the Range parameter.
       BOOST_STATIC_CONSTEXPR int range_exp = Range;
@@ -1839,7 +2071,7 @@
        *
        * @Effects Adapt the resolution of @c rhs to this resolution.
        * @Throws Nothing.
-       * @Notes This overload participates in overload resolution only if the source @c is_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_convertible to the target.
        */
       template <int R, int P, typename RP, typename OP, typename F>
       real_t(real_t<R,P,RP,OP,F> const& rhs
@@ -1847,7 +2079,7 @@
           , typename boost::enable_if<is_convertible<real_t<R,P,RP,OP,F>, real_t > >::type* = 0
 #endif
       )
-      : value_(fixed_point::detail::fxp_number_cast<real_t<R,P,RP,OP,F>, real_t, true, true>()(rhs).count())
+      : value_(fixed_point::detail::fxp_number_cast<real_t<R,P,RP,OP,F>, real_t>()(rhs).count())
       {
       }
       /**
@@ -1858,7 +2090,7 @@
        *
        * @Effects Adapt the resolution of @c rhs to this resolution.
        * @Throws Nothing.
-       * @Notes This overload participates in overload resolution only if the source @c is_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_convertible to the target.
        */
       template <int R, int P, typename RP, typename OP, typename F>
       real_t(ureal_t<R,P,RP,OP,F> const& rhs
@@ -1866,7 +2098,7 @@
           , typename boost::enable_if<is_convertible<ureal_t<R,P,RP,OP,F>, real_t > >::type* = 0
 #endif
       )
-      : value_(fixed_point::detail::fxp_number_cast<ureal_t<R,P,RP,OP,F>, real_t, true, true>()(rhs).count())
+      : value_(fixed_point::detail::fxp_number_cast<ureal_t<R,P,RP,OP,F>, real_t>()(rhs).count())
       {
       }
 
@@ -1878,7 +2110,7 @@
        *
        * @Effects Rounds and check overflow if needed.
        * @Throws Whatever the target overflow policy can throw.
-       * @Notes This overload participates in overload resolution only if the source @c is_explicitly_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_explicitly_convertible to the target.
        */
       template <int R, int P, typename RP, typename OP, typename F>
       explicit real_t(real_t<R,P,RP,OP,F> const& rhs
@@ -1901,7 +2133,7 @@
        *
        * @Effects Rounds and check overflow if needed.
        * @Throws Whatever the target overflow policy can throw.
-       * @Notes This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
        */
       template <int R, int P, typename RP, typename OP, typename F>
       real_t(real_t<R,P,RP,OP,F> const& rhs
@@ -1924,7 +2156,7 @@
        *
        * @Throws Whatever the target overflow policy can throw.
        * @Effects Rounds and check overflow if needed.
-       * @Notes This overload participates in overload resolution only if the source @c is_explicitly_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_explicitly_convertible to the target.
        */
       template <int R, int P, typename RP, typename OP, typename F>
       explicit real_t(ureal_t<R,P,RP,OP,F> const& rhs
@@ -1947,7 +2179,7 @@
        *
        * @Effects Rounds and check overflow if needed.
        * @Throws Whatever the target overflow policy can throw.
-       * @Notes This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
        */
       template <int R, int P, typename RP, typename OP, typename F>
       real_t(ureal_t<R,P,RP,OP,F> const& rhs
@@ -1970,7 +2202,7 @@
        *
        * @Effects Rounds and check overflow if needed.
        * @Throws Whatever the target overflow policy can throw.
-       * @Notes This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
        */
 
       template <int R, int P, typename RP, typename OP, typename F>
@@ -1989,7 +2221,7 @@
        *
        * @Effects Rounds and check overflow if needed.
        * @Throws Whatever the target overflow policy can throw.
-       * @Notes This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
+       * @Remark This overload participates in overload resolution only if the source @c is_implicitly_convertible to the target.
        */
       template <int R, int P, typename RP, typename OP, typename F>
       real_t(convert_tag<ureal_t<R,P,RP,OP,F> > rhs)
@@ -2140,33 +2372,53 @@
       {
         return underlying_type(std::floor(x));
       }
+      template <typename I>
+      static underlying_type classify(I i
+#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
+          , typename boost::enable_if<is_integral<I> >::type* = 0
+#endif
+      )
+      {
+        // Round
+        underlying_type indx = rounding_type::template round_integral<I, self_type>(i);
+        // Overflow
+        if (indx > max_index)
+        {
+          return overflow_type::template on_positive_overflow<self_type,underlying_type>(indx);
+        }
+        if (indx < min_index)
+        {
+          return overflow_type::template on_negative_overflow<self_type,underlying_type>(indx);
+        }
+
+        return indx;
+      }
+
       template <typename FP>
-      static underlying_type classify(FP x)
+      static underlying_type classify(FP x
+#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
+          , typename boost::enable_if<is_floating_point<FP> >::type* = 0
+#endif
+      )
       {
 
-        //        underlying_type indx = rounding_type::template round<To>(x)
-        //        // Overflow
-        //        if (x>max().as<FP>())
-        //        {
-        //          return overflow_type::template on_positive_overflow<To,underlying_type>(indx)));
-        //        }
-        //        if (rhs.count() < (typename From::underlying_type(To::min_index)<<(P2-P1)))
-        //        {
-        //          return To(index(OP2::template on_negative_overflow<To,underlying_type>(indx)));
-        //        }
-        //
-        //        // Round
-        //        return To(index(RP2::template round<From,To>(rhs)));
-
-        if (x<min().as<FP>())
-        return min_index;
-        if (x>max().as<FP>())
-        return max_index;
-        return integer_part(x/factor<FP>());
+        // Round
+        underlying_type indx = rounding_type::template round_float_point<FP,self_type>(x);
+        // Overflow
+        if (indx > max_index)
+        {
+          return overflow_type::template on_positive_overflow<self_type,underlying_type>(indx);
+        }
+        if (indx < min_index)
+        {
+          return overflow_type::template on_negative_overflow<self_type,underlying_type>(indx);
+        }
+
+        return indx;
       }
 
       /**
-       * Implicit conversion from arithmetic @T.
+       * Implicit conversion from arithmetic @c T.
        */
       template <typename T>
       real_t(T x
@@ -2175,7 +2427,7 @@
 #endif
       ) : value_(fixed_point::detail::arthm_number_cast<T, real_t>()(x).count())
       {}
-      //! explicit conversion from arithmetic @T.
+      //! explicit conversion from arithmetic @c T.
       template <typename T>
       explicit real_t(T x
 #if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
@@ -2380,6 +2632,8 @@
 #endif
 
     public:
+      //! this type
+      typedef ureal_t self_type;
 
       // name the template parameters
       //! the Range parameter.
@@ -2443,7 +2697,7 @@
       ureal_t(ureal_t<R,P,RP,OP,F> const& rhs
           , typename boost::enable_if<is_convertible<ureal_t<R,P,RP,OP,F>, ureal_t > >::type* = 0
       )
-      : value_(fixed_point::detail::fxp_number_cast<ureal_t<R,P,RP,OP,F>, ureal_t, true, true>()(rhs).count())
+      : value_(fixed_point::detail::fxp_number_cast<ureal_t<R,P,RP,OP,F>, ureal_t>()(rhs).count())
       {
       }
 
@@ -2561,12 +2815,46 @@
 
         return k*factor<FP>();
       }
+
+      template <typename I>
+      static underlying_type classify(I i
+#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
+          , typename boost::enable_if<is_integral<I> >::type* = 0
+#endif
+      )
+      {
+        if (i<0)
+          return overflow_type::template on_negative_overflow<self_type,underlying_type>(0);
+        // Round
+        underlying_type indx = rounding_type::template round_integral<I, self_type>(i);
+        // Overflow
+        if (indx > max_index)
+        {
+          return overflow_type::template on_positive_overflow<self_type,underlying_type>(indx);
+        }
+
+        return indx;
+      }
+
       template <typename FP>
-      static underlying_type classify(FP x)
+      static underlying_type classify(FP x
+#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
+          , typename boost::enable_if<is_floating_point<FP> >::type* = 0
+#endif
+      )
       {
-        if (x<min().as<FP>()) return min_index;
-        if (x>max().as<FP>()) return max_index;
-        return integer_part(x/factor<FP>());
+        if (x<0)
+          return overflow_type::template on_negative_overflow<self_type,underlying_type>(0);
+
+        // Round
+        underlying_type indx = rounding_type::template round_float_point<FP,self_type>(x);
+        // Overflow
+        if (indx > max_index)
+        {
+          return overflow_type::template on_positive_overflow<self_type,underlying_type>(indx);
+        }
+
+        return indx;
       }
 
       //! implicit conversion from int
@@ -2827,7 +3115,7 @@
 #else
     ureal_t< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>
 #endif
-    to_unsigned_number()
+    to_ureal_t()
     {
       return ureal_t<
       static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution
@@ -2850,7 +3138,7 @@
 #else
     real_t< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>
 #endif
-    to_signed_number()
+    to_real_t()
     {
       return real_t<
       static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution

Modified: sandbox/fixed_point/libs/fixed_point/example/ex_xx.cpp
==============================================================================
--- sandbox/fixed_point/libs/fixed_point/example/ex_xx.cpp	(original)
+++ sandbox/fixed_point/libs/fixed_point/example/ex_xx.cpp	2012-04-21 08:26:52 EDT (Sat, 21 Apr 2012)
@@ -16,17 +16,17 @@
 
 pixel blend(pixel a, pixel b)
 {
-  BOOST_AUTO(scale, (to_unsigned_number<255, 0> ()));
+  BOOST_AUTO(scale, (to_ureal_t<255, 0> ()));
   BOOST_AUTO(a_r, a.r / scale);
   BOOST_AUTO(b_r, b.r / scale);
   (void) a_r;
   (void) b_r;
-  BOOST_AUTO(aia, b.a * (to_unsigned_number<1, 0> () - a.a));
+  BOOST_AUTO(aia, b.a * (to_ureal_t<1, 0> () - a.a));
   BOOST_AUTO(c_a, a.a + aia);
   BOOST_AUTO(c_r, (a.r * a.a + b.r * aia) / c_a);
   pixel c;
-  c.a = number_cast<ureal_t<8, 0> > (c_a * to_unsigned_number<255, 0> ());
-  c.r = number_cast<ureal_t<8, 0> > (c_r * to_unsigned_number<255, 0> ());
+  c.a = number_cast<ureal_t<8, 0> > (c_a * to_ureal_t<255, 0> ());
+  c.r = number_cast<ureal_t<8, 0> > (c_r * to_ureal_t<255, 0> ());
   return c;
 }
 
@@ -55,7 +55,7 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    ureal_t<2, -2, round::negative> n = to_unsigned_number<1, 0> (); //
+    ureal_t<2, -2, round::negative> n = to_ureal_t<1, 0> (); //
     std::cout << int(n.count()) << std::endl;
     BOOST_TEST(n.count() == 4);
   }
@@ -405,7 +405,7 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    ureal_t<4, -1> n1(-0.5f);
+    ureal_t<4, -1, round::negative, ::overflow::saturate> n1(-0.5f);
     BOOST_TEST(n1.count() == 0);
     BOOST_TEST(n1.as_float() == 0.0f);
   }
@@ -1045,27 +1045,27 @@
   //  }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    BOOST_AUTO(scale, (to_unsigned_number<255, 0> ()));
+    BOOST_AUTO(scale, (to_ureal_t<255, 0> ()));
     BOOST_TEST(scale.count() == 255);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    BOOST_AUTO(scale, (to_signed_number<255, 0> ()));
+    BOOST_AUTO(scale, (to_real_t<255, 0> ()));
     BOOST_TEST(scale.count() == 255);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    BOOST_AUTO(scale, (to_unsigned_number<1, -12> ()));
+    BOOST_AUTO(scale, (to_ureal_t<1, -12> ()));
     BOOST_TEST(scale.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    BOOST_AUTO(scale, (to_signed_number<1, -12> ()));
+    BOOST_AUTO(scale, (to_real_t<1, -12> ()));
     BOOST_TEST(scale.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    BOOST_AUTO(scale, (to_unsigned_number<3, 10> ()));
+    BOOST_AUTO(scale, (to_ureal_t<3, 10> ()));
     BOOST_TEST(scale.count() == 3);
   }
   {