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

Subject: [Boost-commit] svn:boost r78052 - in sandbox/fixed_point: boost/fixed_point libs/fixed_point/example
From: vicente.botet_at_[hidden]
Date: 2012-04-17 14:51:01

Author: viboes
Date: 2012-04-17 14:51:00 EDT (Tue, 17 Apr 2012)
New Revision: 78052
URL: http://svn.boost.org/trac/boost/changeset/78052

Log:
FixedPoint: renaming
Text files modified: 
   sandbox/fixed_point/boost/fixed_point/number.hpp       |  1454 ++++++++++++++++++++------------------- 
   sandbox/fixed_point/libs/fixed_point/example/ex_xx.cpp |   572 +++++++-------                          
   2 files changed, 1046 insertions(+), 980 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-17 14:51:00 EDT (Tue, 17 Apr 2012)
@@ -22,7 +22,7 @@
 #include <boost/mpl/max.hpp>
 #include <boost/mpl/min.hpp>
 #include <boost/mpl/assert.hpp>
-#include <boost/type_traits/common_type.hpp>
+//#include <boost/type_traits/common_type.hpp>
 #include <boost/type_traits/is_same.hpp>
 #include <boost/type_traits/is_signed.hpp>
 #include <boost/utility/enable_if.hpp>
@@ -439,15 +439,15 @@
     }
 
     /**
-     * Namespace for optimization policies.
+     * Namespace for storage policies.
      */
-    namespace optimization
+    namespace storage
     {
 
       struct undefined
       {
         /**
-         * signed_integer_type: Gets the signed integer type with enough bits to manage with the Range and Resolution depending on the Opt
+         * signed_integer_type: Gets the signed integer type with enough bits to manage with the Range and Resolution depending on the F
          */
         template <int Range, int Resolution>
         struct signed_integer_type
@@ -456,7 +456,7 @@
         };
 
         /**
-         * unsigned_integer_type: Gets the unsigned integer type with enough bits to manage with the Range and Resolution depending on the Opt
+         * unsigned_integer_type: Gets the unsigned integer type with enough bits to manage with the Range and Resolution depending on the F
          */
         template <int Range, int Resolution>
         struct unsigned_integer_type
@@ -493,32 +493,86 @@
       };
     }
 
+
+    /**
+     * Namespace for conversion policies.
+     */
+    namespace conversion
+    {
+      struct explicitly
+      {
+      };
+      struct implicitly
+      {
+      };
+    }
+
+    /**
+     * Namespace for arithmetic operations policies.
+     */
+    namespace arithmetic
+    {
+      struct open
+      {
+      };
+      struct closed
+      {
+      };
+    }
+
+    /**
+     * Namespace for bounding policies.
+     */
+    namespace bound
+    {
+      struct bounded
+      {
+      };
+      struct unbounded
+      {
+      };
+    }
+
+    /**
+     * Namespace for bounding policies.
+     */
+    namespace family
+    {
+      struct f1
+      {
+        typedef storage::space storage_type;
+        typedef conversion::explicitly conversion_type;
+        typedef arithmetic::open arithmetic_type;
+        typedef bound::bounded bound_type;
+      };
+    }
+
     template <int Range, int Resolution, typename Rounding = round::negative, typename Overflow = overflow::exception,
-        typename Optimization = optimization::space>
-    class unsigned_number;
+        typename Family = family::f1>
+    class ureal_t;
 
     template <int Range, int Resolution, typename Rounding = round::negative, typename Overflow = overflow::exception,
-        typename Optimization = optimization::space>
-    class signed_number;
+        typename Family = family::f1>
+    class real_t;
 
-    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename Opt1, int R2, int P2, typename RP2,
-        typename OP2, typename Opt2>
+    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename F1, int R2, int P2, typename RP2,
+        typename OP2, typename F2>
     inline Res
-    divide(signed_number<R1, P1, RP1, OP1, Opt1> const& lhs, signed_number<R2, P2, RP2, OP2, Opt2> const& rhs);
-    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename Opt1, int R2, int P2, typename RP2,
-        typename OP2, typename Opt2>
+    divide(real_t<R1, P1, RP1, OP1, F1> const& lhs, real_t<R2, P2, RP2, OP2, F2> const& rhs);
+    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename F1, int R2, int P2, typename RP2,
+        typename OP2, typename F2>
     inline Res
-    divide(signed_number<R1, P1, RP1, OP1, Opt1> const& lhs, signed_number<R2, P2, RP2, OP2, Opt2> const& rhs);
+    divide(real_t<R1, P1, RP1, OP1, F1> const& lhs, real_t<R2, P2, RP2, OP2, F2> const& rhs);
 
-    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename Opt1, int R2, int P2, typename RP2,
-        typename OP2, typename Opt2>
+    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename F1, int R2, int P2, typename RP2,
+        typename OP2, typename F2>
     inline Res
-    divide(signed_number<R1, P1, RP1, OP1, Opt1> const& lhs, unsigned_number<R2, P2, RP2, OP2, Opt2> const& rhs);
+    divide(real_t<R1, P1, RP1, OP1, F1> const& lhs, ureal_t<R2, P2, RP2, OP2, F2> const& rhs);
 
-    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename Opt1, int R2, int P2, typename RP2,
-        typename OP2, typename Opt2>
+    template <typename Res, int R1, int P1, typename RP1, typename OP1, typename F1, int R2, int P2, typename RP2,
+        typename OP2, typename F2>
     inline Res
-    divide(unsigned_number<R1, P1, RP1, OP1, Opt1> const& lhs, signed_number<R2, P2, RP2, OP2, Opt2> const& rhs);
+    divide(ureal_t<R1, P1, RP1, OP1, F1> const& lhs, real_t<R2, P2, RP2, OP2, F2> const& rhs);
 
   }
 }
@@ -529,8 +583,8 @@
 
 #include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
 
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::fixed_point::signed_number, (int)(int)(typename)(typename)(typename))
-BOOST_TYPEOF_REGISTER_TEMPLATE(boost::fixed_point::unsigned_number, (int)(int)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::fixed_point::real_t, (int)(int)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::fixed_point::ureal_t, (int)(int)(typename)(typename)(typename))
 
 #endif
 
@@ -612,21 +666,21 @@
 
       };
 
-      //      template <int Range, int Resolution, typename Optimization=optimization::space>
+      //      template <int Range, int Resolution, typename Family=family::space>
       //      class signed_uniform_quantizer
       //      {
       //        BOOST_MPL_ASSERT_MSG(Range>=Resolution, RANGE_MUST_BE_GREATER_EQUAL_THAN_RESOLUTION, (mpl::int_<Range>,mpl::int_<Resolution>));
       //      public:
       //
       //        //! The underlying integer type
-      //        typedef typename Optimization::template  signed_integer_type<Range,Resolution>::type underlying_type;
+      //        typedef typename Family::template  signed_integer_type<Range,Resolution>::type underlying_type;
       //
       //        // name the template parameters
       //        BOOST_STATIC_CONSTEXPR int range_exp = Range;
       //        BOOST_STATIC_CONSTEXPR int resolution_exp = Resolution;
       //        BOOST_STATIC_CONSTEXPR int digits = range_exp-resolution_exp+1;
       //
-      //        typedef Optimization optimization_type;
+      //        typedef Family family_type;
       //
       //        BOOST_STATIC_CONSTEXPR underlying_type min_index = detail::signed_integer_traits<underlying_type,Range,Resolution>::const_min;
       //        BOOST_STATIC_CONSTEXPR underlying_type max_index = detail::signed_integer_traits<underlying_type,Range,Resolution>::const_max;
@@ -647,11 +701,11 @@
       //
       //
       //      template <typename Final, int Range, int Resolution, typename Rounding=round::negative, typename Overflow=overflow::exception,
-      //          typename Optimization=optimization::space
+      //          typename Family=family::space
       //          >
-      //      class signed_quantizer : public signed_uniform_quantizer<Range,Resolution,Optimization>
+      //      class signed_quantizer : public signed_uniform_quantizer<Range,Resolution,Family>
       //      {
-      //        typedef signed_uniform_quantizer<Range,Resolution,Optimization> base_type;
+      //        typedef signed_uniform_quantizer<Range,Resolution,Family> base_type;
       //      public:
       //        typedef typename base_type::underlying_type underlying_type;
       //        BOOST_STATIC_CONSTEXPR underlying_type min_index = base_type::const_min;
@@ -691,15 +745,15 @@
 
       // LE_Range=true GE_Resolution=true
       ///////////////////////////////////
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       true, true >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -708,15 +762,15 @@
           return To(index(underlying_type(rhs.count()) << (P1-P2)));
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       true, true >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -725,15 +779,15 @@
           return To(index(underlying_type(rhs.count()) << (P1-P2)));
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       true, true >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -743,15 +797,15 @@
         }
       };
 
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       true, true >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -777,15 +831,15 @@
 
       // LE_Range=false GE_Resolution=true
       ////////////////////////////////////
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       false, true >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -819,15 +873,15 @@
           );
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       false, true >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -860,15 +914,15 @@
           );
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       false, true >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -892,15 +946,15 @@
           );
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       false, true >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -928,15 +982,15 @@
 
       // LE_Range=true GE_Resolution=false
       ////////////////////////////////////
-      template <int R, int P1, typename RP1, typename OP1, typename Opt1,
-      int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R, int P1, typename RP1, typename OP1, typename F1,
+      int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R,P1,RP1,OP1,Opt1>,
-      signed_number<R,P2,RP2,OP2,Opt2>,
+      real_t<R,P1,RP1,OP1,F1>,
+      real_t<R,P2,RP2,OP2,F2>,
       true, false >
       {
-        typedef signed_number<R,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R,P1,RP1,OP1,F1> From;
+        typedef real_t<R,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -969,15 +1023,15 @@
           );
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       true, false >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -991,15 +1045,15 @@
 
       ////
 
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       true, false >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1032,15 +1086,15 @@
       };
 
       ////
-      template <int R, int P1, typename RP1, typename OP1, typename Opt1,
-      int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R, int P1, typename RP1, typename OP1, typename F1,
+      int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R,P1,RP1,OP1,Opt1>,
-      signed_number<R,P2,RP2,OP2,Opt2>,
+      ureal_t<R,P1,RP1,OP1,F1>,
+      real_t<R,P2,RP2,OP2,F2>,
       true, false >
       {
-        typedef unsigned_number<R,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R,P1,RP1,OP1,F1> From;
+        typedef real_t<R,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1064,15 +1118,15 @@
 
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       true, false >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1086,15 +1140,15 @@
 
       ////
 
-      template <int R, int P1, typename RP1, typename OP1, typename Opt1,
-      int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R, int P1, typename RP1, typename OP1, typename F1,
+      int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R,P1,RP1,OP1,Opt1>,
-      unsigned_number<R,P2,RP2,OP2,Opt2>,
+      ureal_t<R,P1,RP1,OP1,F1>,
+      ureal_t<R,P2,RP2,OP2,F2>,
       true, false >
       {
-        typedef unsigned_number<R,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1118,15 +1172,15 @@
 
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       true, false >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1141,15 +1195,15 @@
       // LE_Range=false GE_Resolution=false
       /////////////////////////////////////
 
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       false, false >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1181,15 +1235,15 @@
 
         }
       };
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      signed_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      real_t<R2,P2,RP2,OP2,F2>,
       false, false >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef signed_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef real_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1214,15 +1268,15 @@
         }
       };
 
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      signed_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      real_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       false, false >
       {
-        typedef signed_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef real_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1256,15 +1310,15 @@
         }
       };
 
-      template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+      template <int R1, int P1, typename RP1, typename OP1, typename F1,
+      int R2, int P2, typename RP2, typename OP2, typename F2>
       struct number_cast<
-      unsigned_number<R1,P1,RP1,OP1,Opt1>,
-      unsigned_number<R2,P2,RP2,OP2,Opt2>,
+      ureal_t<R1,P1,RP1,OP1,F1>,
+      ureal_t<R2,P2,RP2,OP2,F2>,
       false, false >
       {
-        typedef unsigned_number<R1,P1,RP1,OP1,Opt1> From;
-        typedef unsigned_number<R2,P2,RP2,OP2,Opt2> To;
+        typedef ureal_t<R1,P1,RP1,OP1,F1> From;
+        typedef ureal_t<R2,P2,RP2,OP2,F2> To;
         typedef typename To::underlying_type underlying_type;
 
         BOOST_CONSTEXPR To operator()(const From& rhs) const
@@ -1296,155 +1350,164 @@
 
         }
       };
+      template <typename T, typename U >
+      struct default_type_impl;
+      template <typename T>
+      struct default_type_impl<T,T>
+      {
+        typedef T type;
+      };
 
     } // namespace detail
-  } // namespace fixed_point
+
+    template <typename T, typename U >
+    struct default_type
+    {
+      typedef typename detail::default_type_impl<T,U>::type type;
+    };
 
 #if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-  // common_type trait specializations
+  // default_type trait specializations
 
   template <>
-  struct common_type<fixed_point::overflow::undefined, fixed_point::overflow::modulus>
+  struct default_type<fixed_point::overflow::undefined, fixed_point::overflow::modulus>
   {
     typedef fixed_point::overflow::modulus type;
   };
   template <>
-  struct common_type<fixed_point::overflow::modulus, fixed_point::overflow::undefined>
+  struct default_type<fixed_point::overflow::modulus, fixed_point::overflow::undefined>
   {
     typedef fixed_point::overflow::modulus type;
   };
 
   template <>
-  struct common_type<fixed_point::overflow::saturate, fixed_point::overflow::undefined>
+  struct default_type<fixed_point::overflow::saturate, fixed_point::overflow::undefined>
   {
     typedef fixed_point::overflow::saturate type;
   };
   template <>
-  struct common_type<fixed_point::overflow::undefined, fixed_point::overflow::saturate>
+  struct default_type<fixed_point::overflow::undefined, fixed_point::overflow::saturate>
   {
     typedef fixed_point::overflow::saturate type;
   };
 
   template <>
-  struct common_type<fixed_point::overflow::saturate, fixed_point::overflow::modulus>
+  struct default_type<fixed_point::overflow::saturate, fixed_point::overflow::modulus>
   {
     typedef fixed_point::overflow::exception type;
   };
   template <>
-  struct common_type<fixed_point::overflow::modulus, fixed_point::overflow::saturate>
+  struct default_type<fixed_point::overflow::modulus, fixed_point::overflow::saturate>
   {
     typedef fixed_point::overflow::exception type;
   };
   template <>
-  struct common_type<fixed_point::overflow::exception, fixed_point::overflow::exception>
+  struct default_type<fixed_point::overflow::exception, fixed_point::overflow::exception>
   {
     typedef fixed_point::overflow::exception type;
   };
   template <typename Overflow>
-  struct common_type<fixed_point::overflow::exception, Overflow>
+  struct default_type<fixed_point::overflow::exception, Overflow>
   {
     typedef fixed_point::overflow::exception type;
   };
   template <typename Overflow>
-  struct common_type<Overflow,fixed_point::overflow::exception>
+  struct default_type<Overflow,fixed_point::overflow::exception>
   {
     typedef fixed_point::overflow::exception type;
   };
 
   template <>
-  struct common_type<fixed_point::overflow::impossible, fixed_point::overflow::impossible>
+  struct default_type<fixed_point::overflow::impossible, fixed_point::overflow::impossible>
   {
     typedef fixed_point::overflow::impossible type;
   };
   template <typename Overflow>
-  struct common_type<fixed_point::overflow::impossible, Overflow>
+  struct default_type<fixed_point::overflow::impossible, Overflow>
   {
     typedef Overflow type;
   };
   template <typename Overflow>
-  struct common_type<Overflow,fixed_point::overflow::impossible>
+  struct default_type<Overflow,fixed_point::overflow::impossible>
   {
     typedef Overflow type;
   };
 
   template <>
-  struct common_type<fixed_point::round::truncated,fixed_point::round::truncated>
+  struct default_type<fixed_point::round::truncated,fixed_point::round::truncated>
   {
     typedef fixed_point::round::truncated type;
   };
   template <typename Round>
-  struct common_type<Round,fixed_point::round::truncated>
+  struct default_type<Round,fixed_point::round::truncated>
   {
     typedef fixed_point::round::truncated type;
   };
   template <typename Round>
-  struct common_type<fixed_point::round::truncated,Round>
+  struct default_type<fixed_point::round::truncated,Round>
   {
     typedef fixed_point::round::truncated type;
   };
 
-  template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-  int R2, int P2, typename RP2, typename OP2, typename Opt2>
-  struct common_type<
-  fixed_point::unsigned_number<R1,P1,RP1,OP1,Opt1>,
-  fixed_point::unsigned_number<R2,P2,RP2,OP2,Opt2> >
+  template <int R1, int P1, typename RP1, typename OP1, typename F1,
+  int R2, int P2, typename RP2, typename OP2, typename F2>
+  struct default_type<
+  fixed_point::ureal_t<R1,P1,RP1,OP1,F1>,
+  fixed_point::ureal_t<R2,P2,RP2,OP2,F2> >
   {
-    typedef fixed_point::unsigned_number<
+    typedef fixed_point::ureal_t<
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
     > type;
   };
 
-  template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-  int R2, int P2, typename RP2, typename OP2, typename Opt2>
-  struct common_type<
-  fixed_point::signed_number<R1,P1,RP1,OP1,Opt1>,
-  fixed_point::signed_number<R2,P2,RP2,OP2,Opt2> >
+  template <int R1, int P1, typename RP1, typename OP1, typename F1,
+  int R2, int P2, typename RP2, typename OP2, typename F2>
+  struct default_type<
+  fixed_point::real_t<R1,P1,RP1,OP1,F1>,
+  fixed_point::real_t<R2,P2,RP2,OP2,F2> >
   {
-    typedef fixed_point::signed_number<
+    typedef fixed_point::real_t<
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
     > type;
   };
-  template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-  int R2, int P2, typename RP2, typename OP2, typename Opt2>
-  struct common_type<
-  fixed_point::signed_number<R1,P1,RP1,OP1,Opt1>,
-  fixed_point::unsigned_number<R2,P2,RP2,OP2,Opt2> >
+  template <int R1, int P1, typename RP1, typename OP1, typename F1,
+  int R2, int P2, typename RP2, typename OP2, typename F2>
+  struct default_type<
+  fixed_point::real_t<R1,P1,RP1,OP1,F1>,
+  fixed_point::ureal_t<R2,P2,RP2,OP2,F2> >
   {
-    typedef fixed_point::signed_number<
+    typedef fixed_point::real_t<
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
     > type;
   };
-  template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-  int R2, int P2, typename RP2, typename OP2, typename Opt2>
-  struct common_type<
-  fixed_point::unsigned_number<R1,P1,RP1,OP1,Opt1>,
-  fixed_point::signed_number<R2,P2,RP2,OP2,Opt2> >
+  template <int R1, int P1, typename RP1, typename OP1, typename F1,
+  int R2, int P2, typename RP2, typename OP2, typename F2>
+  struct default_type<
+  fixed_point::ureal_t<R1,P1,RP1,OP1,F1>,
+  fixed_point::real_t<R2,P2,RP2,OP2,F2> >
   {
-    typedef fixed_point::signed_number<
+    typedef fixed_point::real_t<
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
     > type;
   };
 #endif
 
-  namespace fixed_point
-  {
-
     /**
      * @brief Signed fixed point number.
      *
@@ -1453,25 +1516,18 @@
      * @Param{Resolution,resolution specified by an integer. The resolution of a fractional number x is 2^Resolution.}
      * @Param{Rounding,The rounding policy.}
      * @Param{Overflow,The overflow policy.}
-     * @Param{Optimization,The optimization policy.}
+     * @Param{Family,The family traits.}
      *
-     * @Example For example, signed_number<8,-4> has values n such that -256 < n < 256 in increments of 2^(-4) = 1/16.
+     * @Example For example, real_t<8,-4> has values n such that -256 < n < 256 in increments of 2^(-4) = 1/16.
      */
-    template <int Range, int Resolution, typename Rounding, typename Overflow, typename Optimization>
-    class signed_number
+    template <int Range, int Resolution, typename Rounding, typename Overflow, typename Family>
+    class real_t
     {
 #if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
       BOOST_MPL_ASSERT_MSG(Range>=Resolution, RANGE_MUST_BE_GREATER_EQUAL_THAN_RESOLUTION, (mpl::int_<Range>,mpl::int_<Resolution>));
 #endif
     public:
 
-      //! The underlying integer type
-      typedef typename Optimization::template signed_integer_type<Range,Resolution>::type underlying_type;
-#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-      BOOST_MPL_ASSERT_MSG((sizeof(underlying_type)*8) >= (Range-Resolution+1), UNDERLYING_TYPE_MUST_BE_LARGE_ENOUGH, (underlying_type));
-      BOOST_MPL_ASSERT_MSG(boost::is_signed<underlying_type>::value, UNDERLYING_TYPE_MUST_BE_SIGNED, (underlying_type));
-#endif
-
       // name the template parameters
       //! the Range parameter.
       BOOST_STATIC_CONSTEXPR int range_exp = Range;
@@ -1481,8 +1537,16 @@
       typedef Rounding rounding_type;
       //! the Overflow parameter.
       typedef Overflow overflow_type;
-      //! the Optimization parameter.
-      typedef Optimization optimization_type;
+      //! the Family parameter.
+      typedef Family family_type;
+
+      //! The underlying integer type
+      typedef typename Family::storage_type storage_type;
+      typedef typename storage_type::template signed_integer_type<Range,Resolution>::type underlying_type;
+#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
+      BOOST_MPL_ASSERT_MSG((sizeof(underlying_type)*8) >= (Range-Resolution+1), UNDERLYING_TYPE_MUST_BE_LARGE_ENOUGH, (underlying_type));
+      BOOST_MPL_ASSERT_MSG(boost::is_signed<underlying_type>::value, UNDERLYING_TYPE_MUST_BE_SIGNED, (underlying_type));
+#endif
 
       //! whether the tyoe is signed (always true).
       BOOST_STATIC_CONSTEXPR bool is_signed = true;
@@ -1498,17 +1562,17 @@
       /**
        * Default constructor.
        */
-      BOOST_CONSTEXPR signed_number()
+      BOOST_CONSTEXPR real_t()
       {} // = default;
       /**
        * Copy constructor.
        */
-      BOOST_CONSTEXPR signed_number(signed_number const& rhs) : value_(rhs.value_)
+      BOOST_CONSTEXPR real_t(real_t const& rhs) : value_(rhs.value_)
       {} // = default;
 
-      //! Implicit constructor from a signed_number with no larger range and no better resolution
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      signed_number(signed_number<R,P,RP,OP,Opt> const& rhs
+      //! Implicit constructor from a real_t with no larger range and no better resolution
+      template <int R, int P, typename RP, typename OP, typename F>
+      real_t(real_t<R,P,RP,OP,F> const& rhs
           , typename boost::enable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -1516,12 +1580,12 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<signed_number<R,P,RP,OP,Opt>, signed_number, true, true>()(rhs).count())
+      : value_(fixed_point::detail::number_cast<real_t<R,P,RP,OP,F>, real_t, true, true>()(rhs).count())
       {
       }
-      //! Implicit constructor from a unsigned_number with no larger range and no better resolution
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      signed_number(unsigned_number<R,P,RP,OP,Opt> const& rhs
+      //! Implicit constructor from a ureal_t with no larger range and no better resolution
+      template <int R, int P, typename RP, typename OP, typename F>
+      real_t(ureal_t<R,P,RP,OP,F> const& rhs
           , typename boost::enable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -1529,13 +1593,13 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<unsigned_number<R,P,RP,OP,Opt>, signed_number, true, true>()(rhs).count())
+      : value_(fixed_point::detail::number_cast<ureal_t<R,P,RP,OP,F>, real_t, true, true>()(rhs).count())
       {
       }
 
-      //! explicit constructor from a signed_number with larger range or better resolution
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      explicit signed_number(signed_number<R,P,RP,OP,Opt> const& rhs
+      //! explicit constructor from a real_t with larger range or better resolution
+      template <int R, int P, typename RP, typename OP, typename F>
+      explicit real_t(real_t<R,P,RP,OP,F> const& rhs
           , typename boost::disable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -1543,15 +1607,15 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<signed_number<R,P,RP,OP,Opt>, signed_number,
+      : value_(fixed_point::detail::number_cast<real_t<R,P,RP,OP,F>, real_t,
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >::value,
           mpl::greater_equal < mpl::int_<P>, mpl::int_<Resolution> >::value
           >()(rhs).count())
       {
       }
-      //! explicit constructor from a signed_number with larger range or better resolution
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      explicit signed_number(unsigned_number<R,P,RP,OP,Opt> const& rhs
+      //! explicit constructor from a real_t with larger range or better resolution
+      template <int R, int P, typename RP, typename OP, typename F>
+      explicit real_t(ureal_t<R,P,RP,OP,F> const& rhs
           , typename boost::disable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -1559,16 +1623,16 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<unsigned_number<R,P,RP,OP,Opt>, signed_number,
+      : value_(fixed_point::detail::number_cast<ureal_t<R,P,RP,OP,F>, real_t,
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >::value,
           mpl::greater_equal < mpl::int_<P>, mpl::int_<Resolution> >::value
           >()(rhs).count())
       {
       }
 
-      //! implicit constructor from a signed_number with larger range or better resolution when wrapped by a convert_tag.
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      signed_number(convert_tag<signed_number<R,P,RP,OP,Opt> > rhs
+      //! implicit constructor from a real_t with larger range or better resolution when wrapped by a convert_tag.
+      template <int R, int P, typename RP, typename OP, typename F>
+      real_t(convert_tag<real_t<R,P,RP,OP,F> > rhs
           , typename boost::disable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -1576,15 +1640,15 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<signed_number<R,P,RP,OP,Opt>, signed_number,
+      : value_(fixed_point::detail::number_cast<real_t<R,P,RP,OP,F>, real_t,
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >::value,
           mpl::greater_equal < mpl::int_<P>, mpl::int_<Resolution> >::value
           >()(rhs.get()).count())
       {
       }
-      //! implicit constructor from a unsigned_number with larger range or better resolution when wrapped by a convert_tag.
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      signed_number(convert_tag<unsigned_number<R,P,RP,OP,Opt> > rhs
+      //! implicit constructor from a ureal_t with larger range or better resolution when wrapped by a convert_tag.
+      template <int R, int P, typename RP, typename OP, typename F>
+      real_t(convert_tag<ureal_t<R,P,RP,OP,F> > rhs
           , typename boost::disable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -1592,7 +1656,7 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<unsigned_number<R,P,RP,OP,Opt>, signed_number,
+      : value_(fixed_point::detail::number_cast<ureal_t<R,P,RP,OP,F>, real_t,
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >::value,
           mpl::greater_equal < mpl::int_<P>, mpl::int_<Resolution> >::value
           >()(rhs.get()).count())
@@ -1600,7 +1664,7 @@
       }
 
       //! destructor
-      //~signed_number() {} //= default;
+      //~real_t() {} //= default;
 
 
       /**
@@ -1612,7 +1676,7 @@
        * @Requires <c>min_index<=i<=max_index</c>.
        */
       template <typename UT>
-      BOOST_CONSTEXPR explicit signed_number(index_tag<UT> i) : value_(i.get())
+      BOOST_CONSTEXPR explicit real_t(index_tag<UT> i) : value_(i.get())
       {
 #if defined(BOOST_NO_CONSTEXPR)
         BOOST_ASSERT(i.get()>=min_index);
@@ -1633,23 +1697,23 @@
       /**
        * @Returns the absolute zero.
        */
-      static BOOST_CONSTEXPR signed_number zero()
+      static BOOST_CONSTEXPR real_t zero()
       {
-        return signed_number(index(0));
+        return real_t(index(0));
       }
       /**
        * @Returns the minimal value that can be represented.
        */
-      static BOOST_CONSTEXPR signed_number min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+      static BOOST_CONSTEXPR real_t min BOOST_PREVENT_MACRO_SUBSTITUTION ()
       {
-        return signed_number(index(min_index));
+        return real_t(index(min_index));
       }
       /**
        * @Returns the maximal value that can be represented.
        */
-      static BOOST_CONSTEXPR signed_number max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+      static BOOST_CONSTEXPR real_t max BOOST_PREVENT_MACRO_SUBSTITUTION ()
       {
-        return signed_number(index(max_index));
+        return real_t(index(max_index));
       }
 
       /**
@@ -1761,35 +1825,35 @@
       }
 
       //! implicit conversion from int
-      explicit signed_number(int x) : value_(detail::shift_left<-Resolution>(x))
+      explicit real_t(int x) : value_(detail::shift_left<-Resolution>(x))
       {}
       //! implicit conversion from float
-      explicit signed_number(float x) : value_(classify(x))
+      explicit real_t(float x) : value_(classify(x))
       {}
       //! implicit conversion from double
-      explicit signed_number(double x) : value_(classify(x))
+      explicit real_t(double x) : value_(classify(x))
       {}
       //! implicit conversion from long double
-      explicit signed_number(long double x) : value_(classify(x))
+      explicit real_t(long double x) : value_(classify(x))
       {}
 
       //! implicit conversion from int
-      signed_number(convert_tag<int> x) : value_(detail::shift_left<-Resolution>(x.get()))
+      real_t(convert_tag<int> x) : value_(detail::shift_left<-Resolution>(x.get()))
       {}
       //! implicit conversion from float
-      signed_number(convert_tag<float> x) : value_(classify(x.get()))
+      real_t(convert_tag<float> x) : value_(classify(x.get()))
       {}
       //! implicit conversion from double
-      signed_number(convert_tag<double> x) : value_(classify(x.get()))
+      real_t(convert_tag<double> x) : value_(classify(x.get()))
       {}
       //! implicit conversion from long double
-      signed_number(convert_tag<long double> x) : value_(classify(x.get()))
+      real_t(convert_tag<long double> x) : value_(classify(x.get()))
       {}
 
       template <typename T>
-      signed_number& operator=(convert_tag<T> v)
+      real_t& operator=(convert_tag<T> v)
       {
-        *this=signed_number(v);
+        *this=real_t(v);
         return *this;
       }
 
@@ -1798,24 +1862,24 @@
       /**
        * @Returns this instance.
        */
-      signed_number operator+() const
+      real_t operator+() const
       {
         return *this;
       }
       /**
        * @Returns a new instance with the representation negated.
        */
-      signed_number operator-() const
+      real_t operator-() const
       {
         // As the range is symmetric the type is preserved
-        return signed_number(index(-value_));
+        return real_t(index(-value_));
       }
 
       /**
        * @Effects Pre-increase this instance as if <c>*this+=1</c>
        * @Returns this instance.
        */
-      signed_number& operator++()
+      real_t& operator++()
       {
         *this+=convert(1);
         return *this;
@@ -1825,9 +1889,9 @@
        * @Effects Post-increase this instance as if <c>*this+=1</c>
        * @Returns a copy of this instance before increasing it.
        */
-      signed_number operator++(int)
+      real_t operator++(int)
       {
-        signed_number tmp=*this;
+        real_t tmp=*this;
         *this+=convert(1);
         return tmp;
       }
@@ -1836,7 +1900,7 @@
        * @Effects Pre-decrease this instance as if <c>*this-=1</c>
        * @Returns this instance.
        */
-      signed_number& operator--()
+      real_t& operator--()
       {
         *this-=convert(1);
         return *this;
@@ -1846,57 +1910,57 @@
        * @Effects Post-decrease this instance as if <c>*this-=1</c>
        * @Returns a copy of this instance before decreasing it.
        */
-      signed_number operator--(int)
+      real_t operator--(int)
       {
-        signed_number tmp=*this;
+        real_t tmp=*this;
         *this-=convert(1);
         return tmp;
       }
 
       /**
-       * @Effects As if <c>number_cast<signed_number>(*this+rhs)</c>
+       * @Effects As if <c>number_cast<real_t>(*this+rhs)</c>
        * @Returns this instance.
        * @Throws Any exception the Overflow policy can throw.
        */
-      signed_number& operator += (signed_number const& rhs)
+      real_t& operator += (real_t const& rhs)
       {
-        signed_number tmp = number_cast<signed_number>(*this+rhs);
+        real_t tmp = number_cast<real_t>(*this+rhs);
         value_ = tmp.count();
         return *this;
       }
 
       /**
-       * @Effects As if <c>number_cast<signed_number>(*this-rhs)</c>
+       * @Effects As if <c>number_cast<real_t>(*this-rhs)</c>
        * @Returns this instance.
        * @Throws Any exception the Overflow policy can throw.
        */
-      signed_number& operator-=(const signed_number& rhs)
+      real_t& operator-=(const real_t& rhs)
       {
-        signed_number tmp = number_cast<signed_number>(*this-rhs);
+        real_t tmp = number_cast<real_t>(*this-rhs);
         value_ = tmp.count();
         return *this;
       }
 
       /**
-       * @Effects As if <c>number_cast<signed_number>(*this*rhs)</c>
+       * @Effects As if <c>number_cast<real_t>(*this*rhs)</c>
        * @Returns this instance.
        * @Throws Any exception the Overflow policy can throw.
        */
-      signed_number& operator*=(const signed_number& rhs)
+      real_t& operator*=(const real_t& rhs)
       {
-        signed_number tmp = number_cast<signed_number>((*this) * rhs);
+        real_t tmp = number_cast<real_t>((*this) * rhs);
         value_ = tmp.count();
         return *this;
       }
 
       /**
-       * @Effects As if <c>divide<signed_number>(*this,rhs)</c>
+       * @Effects As if <c>divide<real_t>(*this,rhs)</c>
        * @Returns this instance.
        * @Throws Any exception the Overflow policy can throw.
        */
-      signed_number& operator/=(const signed_number& rhs)
+      real_t& operator/=(const real_t& rhs)
       {
-        signed_number tmp = divide<signed_number>(*this , rhs);
+        real_t tmp = divide<real_t>(*this , rhs);
         value_ = tmp.count();
         return *this;
       }
@@ -1907,10 +1971,10 @@
        * @Returns a new instance with the same data representation and with the range and resolution increased by @c N.
        */
       template <unsigned N>
-      signed_number<Range+N, Resolution+N, Rounding, Overflow, Optimization>
+      real_t<Range+N, Resolution+N, Rounding, Overflow, Family>
       virtual_scale() const
       {
-        return signed_number<Range+N, Resolution+N, Rounding, Overflow, Optimization>(index(count()));
+        return real_t<Range+N, Resolution+N, Rounding, Overflow, Family>(index(count()));
       }
 
       /**
@@ -1939,9 +2003,9 @@
         }
         else
         {
-          signed_number tmp=
-          divide<signed_number<Range, Resolution, RP, Overflow, Optimization> >(*this,
-              signed_number<-N+1, -N, Rounding, Overflow, Optimization>(index(1)));
+          real_t tmp=
+          divide<real_t<Range, Resolution, RP, Overflow, Family> >(*this,
+              real_t<-N+1, -N, Rounding, Overflow, Family>(index(1)));
           value_ = tmp.count();
         }
       }
@@ -1959,10 +2023,10 @@
      * @Param{Resolution,resolution specified by an integer. The resolution of a fractional number x is 2^Resolution.}
      * @Param{Rounding,The rounding policy.}
      * @Param{Overflow,The overflow policy.}
-     * @Param{Optimization,The optimization policy.}
+     * @Param{Family,The family policy.}
      */
-    template <int Range, int Resolution, typename Rounding, typename Overflow, typename Optimization>
-    class unsigned_number
+    template <int Range, int Resolution, typename Rounding, typename Overflow, typename Family>
+    class ureal_t
     {
 #if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
       BOOST_MPL_ASSERT_MSG(Range>=Resolution, RANGE_MUST_BE_GREATER_EQUAL_THAN_RESOLUTION, (mpl::int_<Range>,mpl::int_<Resolution>));
@@ -1970,14 +2034,6 @@
 
     public:
 
-      //! The underlying integer type
-      typedef typename Optimization::template unsigned_integer_type<Range,Resolution>::type underlying_type;
-
-#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-      BOOST_MPL_ASSERT_MSG((sizeof(underlying_type)*8) >= (Range-Resolution), UNDERLYING_TYPE_MUST_BE_LARGE_ENOUGH, (underlying_type));
-      BOOST_MPL_ASSERT_MSG(!boost::is_signed<underlying_type>::value, UNDERLYING_TYPE_MUST_BE_UNSIGNED, (underlying_type));
-#endif
-
       // name the template parameters
       //! the Range parameter.
       BOOST_STATIC_CONSTEXPR int range_exp = Range;
@@ -1987,8 +2043,18 @@
       typedef Rounding rounding_type;
       //! the Overflow parameter.
       typedef Overflow overflow_type;
-      //! the Optimization parameter.
-      typedef Optimization optimization_type;
+      //! the Family parameter.
+      typedef Family family_type;
+
+      //! The underlying integer type
+      typedef typename Family::storage_type storage_type;
+      typedef typename storage_type::template unsigned_integer_type<Range,Resolution>::type underlying_type;
+
+#if !defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
+      BOOST_MPL_ASSERT_MSG((sizeof(underlying_type)*8) >= (Range-Resolution), UNDERLYING_TYPE_MUST_BE_LARGE_ENOUGH, (underlying_type));
+      BOOST_MPL_ASSERT_MSG(!boost::is_signed<underlying_type>::value, UNDERLYING_TYPE_MUST_BE_UNSIGNED, (underlying_type));
+#endif
+
 
       //! whether the tyoe is signed (always @c false).
       BOOST_STATIC_CONSTEXPR bool is_signed = false;
@@ -2003,18 +2069,18 @@
       /**
        * Default constructor.
        */
-      BOOST_CONSTEXPR unsigned_number()
+      BOOST_CONSTEXPR ureal_t()
       {} // = default;
       /**
        * Copy constructor.
        */
-      BOOST_CONSTEXPR unsigned_number(unsigned_number const& rhs) : value_(rhs.value_)
+      BOOST_CONSTEXPR ureal_t(ureal_t const& rhs) : value_(rhs.value_)
       {} // = default;
 
 
-      //! implicit constructor from a unsigned_number with no larger range and no better resolution
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      unsigned_number(unsigned_number<R,P,RP,OP,Opt> const& rhs
+      //! implicit constructor from a ureal_t with no larger range and no better resolution
+      template <int R, int P, typename RP, typename OP, typename F>
+      ureal_t(ureal_t<R,P,RP,OP,F> const& rhs
           , typename boost::enable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -2022,13 +2088,13 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<unsigned_number<R,P,RP,OP,Opt>, unsigned_number, true, true>()(rhs).count())
+      : value_(fixed_point::detail::number_cast<ureal_t<R,P,RP,OP,F>, ureal_t, true, true>()(rhs).count())
       {
       }
 
-      //! explicit constructor from a unsigned_number with larger range or better resolution
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      explicit unsigned_number(unsigned_number<R,P,RP,OP,Opt> const& rhs
+      //! explicit constructor from a ureal_t with larger range or better resolution
+      template <int R, int P, typename RP, typename OP, typename F>
+      explicit ureal_t(ureal_t<R,P,RP,OP,F> const& rhs
           , typename boost::disable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -2036,16 +2102,16 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<unsigned_number<R,P,RP,OP,Opt>, unsigned_number,
+      : value_(fixed_point::detail::number_cast<ureal_t<R,P,RP,OP,F>, ureal_t,
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >::value,
           mpl::greater_equal < mpl::int_<P>, mpl::int_<Resolution> >::value
           >()(rhs).count())
       {
       }
 
-      //! implicit constructor from a unsigned_number with larger range or better resolution
-      template <int R, int P, typename RP, typename OP, typename Opt>
-      unsigned_number(convert_tag<unsigned_number<R,P,RP,OP,Opt> > rhs
+      //! implicit constructor from a ureal_t with larger range or better resolution
+      template <int R, int P, typename RP, typename OP, typename F>
+      ureal_t(convert_tag<ureal_t<R,P,RP,OP,F> > rhs
           , typename boost::disable_if <
           mpl::and_ <
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >,
@@ -2053,7 +2119,7 @@
           >
           >::type* = 0
       )
-      : value_(fixed_point::detail::number_cast<unsigned_number<R,P,RP,OP,Opt>, unsigned_number,
+      : value_(fixed_point::detail::number_cast<ureal_t<R,P,RP,OP,F>, ureal_t,
           mpl::less_equal < mpl::int_<R>, mpl::int_<Range> >::value,
           mpl::greater_equal < mpl::int_<P>, mpl::int_<Resolution> >::value
           >()(rhs.get()).count())
@@ -2061,7 +2127,7 @@
       }
 
       //! destructor
-      //~unsigned_number() {} //= default;
+      //~ureal_t() {} //= default;
 
 
       /**
@@ -2073,7 +2139,7 @@
        * @Requires <c>0<=i<=max_index</c>.
        */
       template <typename UT>
-      explicit unsigned_number(index_tag<UT> i) : value_(i.get())
+      explicit ureal_t(index_tag<UT> i) : value_(i.get())
       {
         //BOOST_ASSERT(i.get()>=min_index);
         BOOST_ASSERT(i.get()<=max_index);
@@ -2092,25 +2158,25 @@
       /**
        * @Returns the absolute zero.
        */
-      static BOOST_CONSTEXPR unsigned_number zero()
+      static BOOST_CONSTEXPR ureal_t zero()
       {
-        return unsigned_number(index(0));
+        return ureal_t(index(0));
       }
 
       /**
        * @Returns the minimal value that can be represented.
        */
-      static BOOST_CONSTEXPR unsigned_number min BOOST_PREVENT_MACRO_SUBSTITUTION ()
+      static BOOST_CONSTEXPR ureal_t min BOOST_PREVENT_MACRO_SUBSTITUTION ()
       {
-        return unsigned_number(index(min_index));
+        return ureal_t(index(min_index));
       }
 
       /**
        * @Returns the maximal value that can be represented.
        */
-      static BOOST_CONSTEXPR unsigned_number max BOOST_PREVENT_MACRO_SUBSTITUTION ()
+      static BOOST_CONSTEXPR ureal_t max BOOST_PREVENT_MACRO_SUBSTITUTION ()
       {
-        return unsigned_number(index(max_index));
+        return ureal_t(index(max_index));
       }
 
       /**
@@ -2149,37 +2215,37 @@
       }
 
       //! implicit conversion from int
-      explicit unsigned_number(unsigned int x) : value_(detail::shift_left<-Resolution>(x))
+      explicit ureal_t(unsigned int x) : value_(detail::shift_left<-Resolution>(x))
       {}
 
       //! implicit conversion from float
-      explicit unsigned_number(float x) : value_(classify(x))
+      explicit ureal_t(float x) : value_(classify(x))
       {}
       //! implicit conversion from double
-      explicit unsigned_number(double x) : value_(classify(x))
+      explicit ureal_t(double x) : value_(classify(x))
       {}
       //! implicit conversion from long double
-      explicit unsigned_number(long double x) : value_(classify(x))
+      explicit ureal_t(long double x) : value_(classify(x))
       {}
 
       //! implicit conversion from int
-      unsigned_number(convert_tag<unsigned int> x) : value_(detail::shift_left<-Resolution>(x.get()))
+      ureal_t(convert_tag<unsigned int> x) : value_(detail::shift_left<-Resolution>(x.get()))
       {}
 
       //! implicit conversion from float
-      unsigned_number(convert_tag<float> x) : value_(classify(x.get()))
+      ureal_t(convert_tag<float> x) : value_(classify(x.get()))
       {}
       //! implicit conversion from double
-      unsigned_number(convert_tag<double> x) : value_(classify(x.get()))
+      ureal_t(convert_tag<double> x) : value_(classify(x.get()))
       {}
       //! implicit conversion from long double
-      unsigned_number(convert_tag<long double> x) : value_(classify(x.get()))
+      ureal_t(convert_tag<long double> x) : value_(classify(x.get()))
       {}
 
       template <typename T>
-      unsigned_number& operator=(convert_tag<T> v)
+      ureal_t& operator=(convert_tag<T> v)
       {
-        *this=unsigned_number(v);
+        *this=ureal_t(v);
         return *this;
       }
 
@@ -2239,24 +2305,24 @@
       /**
        * @Returns this instance.
        */
-      unsigned_number operator+() const
+      ureal_t operator+() const
       {
         return *this;
       }
       /**
        * @Returns an instance of a signed fixed point nummber with the representation the negation of the representation of this.
        */
-      signed_number<Range,Resolution,Rounding,Overflow,Optimization>
+      real_t<Range,Resolution,Rounding,Overflow,Family>
       operator-() const
       {
-        return signed_number<Range,Resolution,Rounding,Overflow,Optimization>(index(-value_));
+        return real_t<Range,Resolution,Rounding,Overflow,Family>(index(-value_));
       }
 
       /**
        * @Effects Pre-increase this instance as if <c>*this+=1</c>
        * @Returns <c>*this</c>.
        */
-      unsigned_number& operator++()
+      ureal_t& operator++()
       {
         *this+=convert(1u);
         return *this;
@@ -2265,9 +2331,9 @@
        * @Effects Post-increase this instance as if <c>*this+=1</c>
        * @Returns a copy of this instance before increasing it.
        */
-      unsigned_number operator++(int)
+      ureal_t operator++(int)
       {
-        unsigned_number tmp=*this;
+        ureal_t tmp=*this;
         *this+=convert(1u);
         return tmp;
       }
@@ -2275,7 +2341,7 @@
        * @Effects Pre-decrease this instance as if <c>*this-=1</c>
        * @Returns <c>*this</c>.
        */
-      unsigned_number& operator--()
+      ureal_t& operator--()
       {
         *this-=convert(1u);
         return *this;
@@ -2284,56 +2350,56 @@
        * @Effects Post-decrease this instance as if <c>*this-=1</c>
        * @Returns a copy of this instance before decreasing it.
        */
-      unsigned_number operator--(int)
+      ureal_t operator--(int)
       {
-        unsigned_number tmp=*this;
+        ureal_t tmp=*this;
         *this-=convert(1u);
         return tmp;
       }
 
       /**
-       * @Effects As if <c>number_cast<unsigned_number>(*this+rhs)</c>
+       * @Effects As if <c>number_cast<ureal_t>(*this+rhs)</c>
        * @Returns <c>*this</c>.
        * @Throws Any exception the Overflow policy can throw.
        */
-      unsigned_number& operator += (unsigned_number const& rhs)
+      ureal_t& operator += (ureal_t const& rhs)
       {
-        unsigned_number tmp = number_cast<unsigned_number>((*this) + rhs);
+        ureal_t tmp = number_cast<ureal_t>((*this) + rhs);
         value_ = tmp.count();
         return *this;
       }
 
       /**
-       * @Effects As if <c>number_cast<unsigned_number>(*this-rhs)</c>
+       * @Effects As if <c>number_cast<ureal_t>(*this-rhs)</c>
        * @Returns <c>*this</c>.
        * @Throws Any exception the Overflow policy can throw.
        */
-      unsigned_number& operator-=(unsigned_number const& rhs)
+      ureal_t& operator-=(ureal_t const& rhs)
       {
-        unsigned_number tmp = number_cast<unsigned_number>((*this) - rhs);
+        ureal_t tmp = number_cast<ureal_t>((*this) - rhs);
         value_ = tmp.count();
         return *this;
       }
       /**
-       * @Effects As if <c>number_cast<unsigned_number>(*this*rhs)</c>
+       * @Effects As if <c>number_cast<ureal_t>(*this*rhs)</c>
        * @Returns <c>*this</c>.
        * @Throws Any exception the Overflow policy can throw.
        */
-      unsigned_number& operator*=(unsigned_number const& rhs)
+      ureal_t& operator*=(ureal_t const& rhs)
       {
-        unsigned_number tmp = number_cast<unsigned_number>((*this) * rhs);
+        ureal_t tmp = number_cast<ureal_t>((*this) * rhs);
         value_ = tmp.count();
         return *this;
       }
 
       /**
-       * @Effects As if <c>divide<unsigned_number>(*this,rhs)</c>
+       * @Effects As if <c>divide<ureal_t>(*this,rhs)</c>
        * @Returns <c>*this</c>.
        * @Throws Any exception the Overflow policy can throw.
        */
-      unsigned_number& operator/=(unsigned_number const& rhs)
+      ureal_t& operator/=(ureal_t const& rhs)
       {
-        unsigned_number tmp = divide<unsigned_number>(*this, rhs);
+        ureal_t tmp = divide<ureal_t>(*this, rhs);
         value_ += tmp.count();
         return *this;
       }
@@ -2346,10 +2412,10 @@
        * @Returns a new instance with the same data representation and with the range and resolution increased by @c N.
        */
       template <std::size_t N>
-      unsigned_number<Range+N, Resolution+N, Rounding, Overflow, Optimization>
+      ureal_t<Range+N, Resolution+N, Rounding, Overflow, Family>
       virtual_scale() const
       {
-        return unsigned_number<Range+N, Resolution+N, Rounding, Overflow, Optimization>(index(count()));
+        return ureal_t<Range+N, Resolution+N, Rounding, Overflow, Family>(index(count()));
       }
 
       /**
@@ -2378,9 +2444,9 @@
         }
         else
         {
-          unsigned_number tmp=
-          divide<unsigned_number<Range, Resolution, RP, Overflow, Optimization> >(*this,
-          unsigned_number<-N+1, -N, Rounding, Overflow, Optimization>(index(1)));
+          ureal_t tmp=
+          divide<ureal_t<Range, Resolution, RP, Overflow, Family> >(*this,
+          ureal_t<-N+1, -N, Rounding, Overflow, Family>(index(1)));
           value_ = tmp.count();
         }
       }
@@ -2391,44 +2457,44 @@
     };
 
     /**
-     * unsigned_number compile time factory.
+     * ureal_t compile time factory.
      *
-     * @Returns an @c unsigned_number enough large to represent <c>Times*(2^Resolution)</c>.
+     * @Returns an @c ureal_t enough large to represent <c>Times*(2^Resolution)</c>.
      */
     template <int Times, int Resolution>
     BOOST_CONSTEXPR
     inline
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    unsigned_number< LOG2(ABS(Times+1)), Resolution>
+    ureal_t< LOG2(ABS(Times+1)), Resolution>
 #else
-    unsigned_number< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>
+    ureal_t< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>
 #endif
     to_unsigned_number()
     {
-      return unsigned_number< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>(index(Times));
+      return ureal_t< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>(index(Times));
     }
     /**
-     * signed_number compile time factory.
+     * real_t compile time factory.
      *
-     * @Returns a @c signed_number enough large to represent <c>Times*(2^Resolution)</c>.
+     * @Returns a @c real_t enough large to represent <c>Times*(2^Resolution)</c>.
      */
     template <int Times, int Resolution>
     BOOST_CONSTEXPR
     inline
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    signed_number< LOG2(ABS(Times+1)), Resolution>
+    real_t< LOG2(ABS(Times+1)), Resolution>
 #else
-    signed_number< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>
+    real_t< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>
 #endif
     to_signed_number()
     {
-      return signed_number< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>(index(Times));
+      return real_t< static_log2<mpl::abs<mpl::int_<Times+1> >::type::value>::value+Resolution, Resolution>(index(Times));
     }
 
     //    /**
-    //     * unsigned_number compile time factory from integer and fractional parts
+    //     * ureal_t compile time factory from integer and fractional parts
     //     *
-    //     * @Returns an @c unsigned_number enough large to represent <c>Integral.Fractional</c>.
+    //     * @Returns an @c ureal_t enough large to represent <c>Integral.Fractional</c>.
     //     *
     //     * @Example ratio_to_fp<ratio<314,100>,-32>
     //     */
@@ -2436,23 +2502,23 @@
     //    BOOST_CONSTEXPR
     //    inline
     //#if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    //    unsigned_number< LOG2(ABS(Integral+1)), LOG2(ABS(Fractional+1))>
+    //    ureal_t< LOG2(ABS(Integral+1)), LOG2(ABS(Fractional+1))>
     //#else
-    //    unsigned_number<
+    //    ureal_t<
     //      static_log2<mpl::abs<mpl::int_<Integral+1> >::type::value>::value,
     //      static_log2<mpl::abs<mpl::int_<Fractional+1> >::type::value>::value>
     //#endif
     //    ratio_to_fp()
     //    {
     //      BOOST_CONSTEXPR intmax_t Resolution=static_log2<mpl::abs<mpl::int_<Fractional+1> >::type::value>::value;
-    //      return unsigned_number<
+    //      return ureal_t<
     //            static_log2<mpl::abs<mpl::int_<Integral+1> >::type::value>::value,
     //            Resolution
     //            >(index(Times));
     //    }
 
 
-    // signed_number non-member arithmetic
+    // real_t non-member arithmetic
 
     // mixed fixed point arithmetic
 
@@ -2460,12 +2526,12 @@
      * signed + int -> signed.
      * @Returns <c>lhs+AT(rhs)</c>.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1>
     inline
-    signed_number<R1+1,P1,RP1,OP1,Opt1>
-    operator+(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, int rhs)
+    real_t<R1+1,P1,RP1,OP1,F1>
+    operator+(real_t<R1,P1,RP1,OP1,F1> const& lhs, int rhs)
     {
-      typedef signed_number<R1,P1,RP1,OP1,Opt1> arg_type;
+      typedef real_t<R1,P1,RP1,OP1,F1> arg_type;
 
       return lhs + arg_type(rhs);
     }
@@ -2474,32 +2540,32 @@
      * signed + signed -> signed.
      * @Returns <c>RT(incex(RT(lhs).count()+RT(rhs).count())</c>.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator+(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator+(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()+result_type(rhs).count()));
@@ -2509,32 +2575,32 @@
      * unsigned + signed -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator+(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator+(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()+result_type(rhs).count()));
@@ -2543,32 +2609,32 @@
      * signed + unsigned -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator+(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator+(real_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()+result_type(rhs).count()));
@@ -2577,32 +2643,32 @@
      * unsigned + unsigned -> unsigned.
      * @Returns a unsigned fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    unsigned_number<
+    ureal_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator+(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator+(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef unsigned_number<
+      typedef ureal_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()+result_type(rhs).count()));
@@ -2612,32 +2678,32 @@
      * signed - signed -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator-(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator-(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()-result_type(rhs).count()));
@@ -2647,32 +2713,32 @@
      * unsigned - signed -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator-(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator-(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()-result_type(rhs).count()));
@@ -2682,32 +2748,32 @@
      * signed - unsigned -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator-(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator-(real_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()-result_type(rhs).count()));
@@ -2717,32 +2783,32 @@
      * unsigned - unsigned -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
     MAX(R1,R2)+1,
     MIN(P1,P2),
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
     mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
     mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator-(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator-(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       mpl::max<mpl::int_<R1>,mpl::int_<R2> >::type::value+1,
       mpl::min<mpl::int_<P1>,mpl::int_<P2> >::type::value,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return result_type(index(result_type(lhs).count()-result_type(rhs).count()));
@@ -2752,30 +2818,30 @@
      * signed * signed -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
     R1+R2,
     P1+P2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator*(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator*(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       R1+R2,
       P1+P2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
       typedef typename result_type::underlying_type underlying_type;
 
@@ -2786,30 +2852,30 @@
      * signed * unsigned -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
     R1+R2,
     P1+P2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator*(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator*(real_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       R1+R2,
       P1+P2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
       typedef typename result_type::underlying_type underlying_type;
 
@@ -2820,30 +2886,30 @@
      * unsigned * signed -> signed.
      * @Returns a signed fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
     R1+R2,
     P1+P2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator*(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator*(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       R1+R2,
       P1+P2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
       typedef typename result_type::underlying_type underlying_type;
 
@@ -2854,30 +2920,30 @@
      * unsigned * unsigned -> unsigned.
      * @Returns a unsigned fixed point enough large to avoid overflow.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    unsigned_number<
+    ureal_t<
     R1+R2,
     P1+P2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator*(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator*(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef unsigned_number<
+      typedef ureal_t<
       R1+R2,
       P1+P2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
       typedef typename result_type::underlying_type underlying_type;
 
@@ -2901,141 +2967,141 @@
 
     /**
      * fixed point division giving the expected result type.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the expected result.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the expected result.
      */
     template <
     typename Res,
-    int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     Res
-    divide(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    divide(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       typedef Res result_type;
       typedef typename result_type::underlying_type underlying_type;
 
-      typedef typename common_type<signed_number<R1,P1,RP1,OP1,Opt1>, signed_number<R2,P2,RP2,OP2,Opt2> >::type CT;
+      typedef typename default_type<real_t<R1,P1,RP1,OP1,F1>, real_t<R2,P2,RP2,OP2,F2> >::type DT;
       //BOOST_STATIC_CONSTEXPR int P = Res::resolution_exp;
 
-      //BOOST_STATIC_ASSERT((Res::digits>=(CT::digits-P)));
-      BOOST_STATIC_ASSERT((Res::is_signed==CT::is_signed));
-      BOOST_ASSERT_MSG(CT(rhs).count()!=0, "Division by 0");
+      //BOOST_STATIC_ASSERT((Res::digits>=(DT::digits-P)));
+      BOOST_STATIC_ASSERT((Res::is_signed==DT::is_signed));
+      BOOST_ASSERT_MSG(DT(rhs).count()!=0, "Division by 0");
 
-      //      underlying_type ci = detail::shift<typename CT::underlying_type, CT::digits, P>(CT(lhs).count()) / CT(rhs).count();
+      //      underlying_type ci = detail::shift<typename DT::underlying_type, DT::digits, P>(DT(lhs).count()) / DT(rhs).count();
       //      return result_type(index(ci)); // ....
       typedef typename result_type::rounding_type rounding_type;
-      return result_type(index(rounding_type::template round_divide<Res>(CT(lhs), CT(rhs))));
+      return result_type(index(rounding_type::template round_divide<Res>(DT(lhs), DT(rhs))));
     }
 
     /**
      * fixed point division giving the expected result type.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the expected result.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the expected result.
      */
     template <
     typename Res,
-    int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     Res
-    divide(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    divide(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       typedef Res result_type;
       typedef typename result_type::underlying_type underlying_type;
-      typedef typename common_type<unsigned_number<R1,P1,RP1,OP1,Opt1>, unsigned_number<R2,P2,RP2,OP2,Opt2> >::type CT;
+      typedef typename default_type<ureal_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> >::type DT;
       //BOOST_STATIC_CONSTEXPR int P = Res::resolution_exp;
 
-      //BOOST_STATIC_ASSERT((Res::digits>=(CT::digits-P)));
-      BOOST_STATIC_ASSERT((Res::is_signed==CT::is_signed));
-      BOOST_ASSERT_MSG(CT(rhs).count()!=0, "Division by 0");
+      //BOOST_STATIC_ASSERT((Res::digits>=(DT::digits-P)));
+      BOOST_STATIC_ASSERT((Res::is_signed==DT::is_signed));
+      BOOST_ASSERT_MSG(DT(rhs).count()!=0, "Division by 0");
 
-      //      underlying_type ci = detail::shift<typename CT::underlying_type, CT::digits, P>(CT(lhs).count()) / CT(rhs).count();
+      //      underlying_type ci = detail::shift<typename DT::underlying_type, DT::digits, P>(DT(lhs).count()) / DT(rhs).count();
       //      return result_type(index(ci)); // ....
       typedef typename result_type::rounding_type rounding_type;
-      return result_type(index(rounding_type::template round_divide<Res>(CT(lhs), CT(rhs))));
+      return result_type(index(rounding_type::template round_divide<Res>(DT(lhs), DT(rhs))));
     }
 
     /**
      * fixed point division giving the expected result type.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the expected result.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the expected result.
      */
     template <
     typename Res,
-    int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     Res
-    divide(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    divide(real_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       typedef Res result_type;
       typedef typename result_type::underlying_type underlying_type;
-      typedef typename common_type<signed_number<R1,P1,RP1,OP1,Opt1>, unsigned_number<R2,P2,RP2,OP2,Opt2> >::type CT;
+      typedef typename default_type<real_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> >::type DT;
       //BOOST_STATIC_CONSTEXPR int P = Res::resolution_exp;
 
-      //BOOST_STATIC_ASSERT((Res::digits>=(CT::digits-P)));
-      BOOST_STATIC_ASSERT((Res::is_signed==CT::is_signed));
-      BOOST_ASSERT_MSG(CT(rhs).count()!=0, "Division by 0");
+      //BOOST_STATIC_ASSERT((Res::digits>=(DT::digits-P)));
+      BOOST_STATIC_ASSERT((Res::is_signed==DT::is_signed));
+      BOOST_ASSERT_MSG(DT(rhs).count()!=0, "Division by 0");
 
-      //      underlying_type ci = detail::shift<typename CT::underlying_type, CT::digits, P>(CT(lhs).count()) / CT(rhs).count();
+      //      underlying_type ci = detail::shift<typename DT::underlying_type, DT::digits, P>(DT(lhs).count()) / DT(rhs).count();
       //      return result_type(index(ci)); // ....
       typedef typename result_type::rounding_type rounding_type;
-      return result_type(index(rounding_type::template round_divide<Res>(CT(lhs), CT(rhs))));
+      return result_type(index(rounding_type::template round_divide<Res>(DT(lhs), DT(rhs))));
     }
 
     /**
      * fixed point division giving the expected result type.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the expected result.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the expected result.
      */
     template <
     typename Res,
-    int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     Res
-    divide(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    divide(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       typedef Res result_type;
       typedef typename result_type::underlying_type underlying_type;
-      typedef typename common_type<unsigned_number<R1,P1,RP1,OP1,Opt1>, signed_number<R2,P2,RP2,OP2,Opt2> >::type CT;
+      typedef typename default_type<ureal_t<R1,P1,RP1,OP1,F1>, real_t<R2,P2,RP2,OP2,F2> >::type DT;
       //BOOST_STATIC_CONSTEXPR int P = Res::resolution_exp;
 
-      //BOOST_STATIC_ASSERT((Res::digits>=(CT::digits-P)));
-      BOOST_STATIC_ASSERT((Res::is_signed==CT::is_signed));
-      BOOST_ASSERT_MSG(CT(rhs).count()!=0, "Division by 0");
+      //BOOST_STATIC_ASSERT((Res::digits>=(DT::digits-P)));
+      BOOST_STATIC_ASSERT((Res::is_signed==DT::is_signed));
+      BOOST_ASSERT_MSG(DT(rhs).count()!=0, "Division by 0");
 
-      //      underlying_type ci = detail::shift<typename CT::underlying_type, CT::digits, P>(CT(lhs).count()) / CT(rhs).count();
+      //      underlying_type ci = detail::shift<typename DT::underlying_type, DT::digits, P>(DT(lhs).count()) / DT(rhs).count();
       //      return result_type(index(ci)); // ....
       typedef typename result_type::rounding_type rounding_type;
-      return result_type(index(rounding_type::template round_divide<Res>(CT(lhs), CT(rhs))));
+      return result_type(index(rounding_type::template round_divide<Res>(DT(lhs), DT(rhs))));
     }
 
     /**
      * fixed point division  deducing the result type as <R1-P2, P1,R2>.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the result type.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the result type.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
     R1-P2,
     P1-R2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator/(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator/(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       R1-P2,
       P1-R2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return divide<result_type>(lhs,rhs);
@@ -3043,32 +3109,32 @@
 
     /**
      * fixed point division  deducing the result type as <R1-P2, P1,R2>.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the result type.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the result type.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
     R1-P2,
     P1-R2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator/(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator/(real_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       R1-P2,
       P1-R2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return divide<result_type>(lhs,rhs);
@@ -3076,32 +3142,32 @@
 
     /**
      * fixed point division  deducing the result type as <R1-P2, P1,R2>.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the result type.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the result type.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    signed_number<
+    real_t<
     R1-P2,
     P1-R2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator/(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator/(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef signed_number<
+      typedef real_t<
       R1-P2,
       P1-R2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return divide<result_type>(lhs,rhs);
@@ -3109,32 +3175,32 @@
 
     /**
      * fixed point division  deducing the result type as <R1-P2, P1,R2>.
-     * @Returns CT(lhs) / CT(rhs) taking in account the rounding policy of the result type.
+     * @Returns DT(lhs) / DT(rhs) taking in account the rounding policy of the result type.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
-    unsigned_number<
+    ureal_t<
     R1-P2,
     P1-R2,
 #if defined(BOOST_FIXED_POINT_DOXYGEN_INVOKED)
-    CT(RP1,RP2),
-    CT(OP1,OP2),
-    CT(Opt1,Opt2)
+    DT(RP1,RP2),
+    DT(OP1,OP2),
+    DT(F1,F2)
 #else
-    typename common_type<RP1,RP2>::type,
-    typename common_type<OP1,OP2>::type,
-    typename common_type<Opt1,Opt2>::type
+    typename default_type<RP1,RP2>::type,
+    typename default_type<OP1,OP2>::type,
+    typename default_type<F1,F2>::type
 #endif
     >
-    operator/(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator/(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef unsigned_number<
+      typedef ureal_t<
       R1-P2,
       P1-R2,
-      typename common_type<RP1,RP2>::type,
-      typename common_type<OP1,OP2>::type,
-      typename common_type<Opt1,Opt2>::type
+      typename default_type<RP1,RP2>::type,
+      typename default_type<OP1,OP2>::type,
+      typename default_type<F1,F2>::type
       > result_type;
 
       return divide<result_type>(lhs,rhs);
@@ -3143,100 +3209,100 @@
     // comparisons
 
     /**
-     * @Returns As if <c>CT(lhs).count() == CT(rhs).count()</c> where CT is the common_type of the parameters..
+     * @Returns As if <c>DT(lhs).count() == DT(rhs).count()</c> where DT is the default_type of the parameters..
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator==(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator==(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef typename common_type<signed_number<R1,P1,RP1,OP1,Opt1>, signed_number<R2,P2,RP2,OP2,Opt2> >::type CT;
-      return CT(lhs).count() == CT(rhs).count();
+      typedef typename default_type<real_t<R1,P1,RP1,OP1,F1>, real_t<R2,P2,RP2,OP2,F2> >::type DT;
+      return DT(lhs).count() == DT(rhs).count();
     }
 
     /**
-     * @Returns As if <c>CT(lhs).count() == CT(rhs).count()</c> where CT is the common_type of the parameters..
+     * @Returns As if <c>DT(lhs).count() == DT(rhs).count()</c> where DT is the default_type of the parameters..
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator==(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator==(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef typename common_type<unsigned_number<R1,P1,RP1,OP1,Opt1>, unsigned_number<R2,P2,RP2,OP2,Opt2> >::type CT;
-      return CT(lhs).count() == CT(rhs).count();
+      typedef typename default_type<ureal_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> >::type DT;
+      return DT(lhs).count() == DT(rhs).count();
     }
 
     /**
-     * @Returns <c>CT(lhs).count() != CT(rhs).count()</c> where CT is the common_type of the parameters..
+     * @Returns <c>DT(lhs).count() != DT(rhs).count()</c> where DT is the default_type of the parameters..
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator!=(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator!=(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return !(lhs == rhs);
     }
 
     /**
-     * @Returns <c>CT(lhs).count() != CT(rhs).count()</c> where CT is the common_type of the parameters..
+     * @Returns <c>DT(lhs).count() != DT(rhs).count()</c> where DT is the default_type of the parameters..
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator!=(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator!=(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return !(lhs == rhs);
     }
 
     /**
-     * @Returns <c>CT(lhs).count() < CT(rhs).count()</c> where CT is the common_type of the parameters..
+     * @Returns <c>DT(lhs).count() < DT(rhs).count()</c> where DT is the default_type of the parameters..
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator<(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator<(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef typename common_type<signed_number<R1,P1,RP1,OP1,Opt1>, signed_number<R2,P2,RP2,OP2,Opt2> >::type CT;
-      return CT(lhs).count() < CT(rhs).count();
+      typedef typename default_type<real_t<R1,P1,RP1,OP1,F1>, real_t<R2,P2,RP2,OP2,F2> >::type DT;
+      return DT(lhs).count() < DT(rhs).count();
     }
 
     /**
-     * @Returns <c>CT(lhs).count() < CT(rhs).count()</c> where CT is the common_type of the parameters..
+     * @Returns <c>DT(lhs).count() < DT(rhs).count()</c> where DT is the default_type of the parameters..
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator<(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator<(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
-      typedef typename common_type<unsigned_number<R1,P1,RP1,OP1,Opt1>, unsigned_number<R2,P2,RP2,OP2,Opt2> >::type CT;
-      return CT(lhs).count() < CT(rhs).count();
+      typedef typename default_type<ureal_t<R1,P1,RP1,OP1,F1>, ureal_t<R2,P2,RP2,OP2,F2> >::type DT;
+      return DT(lhs).count() < DT(rhs).count();
     }
 
     /**
      * @Returns <c>rhs < lhs</c>.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator>(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator>(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return rhs < lhs;
     }
     /**
      * @Returns <c>rhs < lhs</c>.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator>(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator>(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return rhs < lhs;
     }
@@ -3244,22 +3310,22 @@
     /**
      * @Returns <c>!(rhs < lhs)</c>.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator<=(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator<=(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return !(rhs < lhs);
     }
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     /**
      * @Returns <c>!(rhs < lhs)</c>.
      */
     inline
     bool
-    operator<=(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator<=(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return !(rhs < lhs);
     }
@@ -3267,22 +3333,22 @@
     /**
      * @Returns <c>!(lhs < rhs)</c>.
      */
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-      int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     inline
     bool
-    operator>=(signed_number<R1,P1,RP1,OP1,Opt1> const& lhs, signed_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator>=(real_t<R1,P1,RP1,OP1,F1> const& lhs, real_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return !(lhs < rhs);
     }
-    template <int R1, int P1, typename RP1, typename OP1, typename Opt1,
-    int R2, int P2, typename RP2, typename OP2, typename Opt2>
+    template <int R1, int P1, typename RP1, typename OP1, typename F1,
+    int R2, int P2, typename RP2, typename OP2, typename F2>
     /**
      * @Returns <c>!(lhs < rhs)</c>.
      */
     inline
     bool
-    operator>=(unsigned_number<R1,P1,RP1,OP1,Opt1> const& lhs, unsigned_number<R2,P2,RP2,OP2,Opt2> const& rhs)
+    operator>=(ureal_t<R1,P1,RP1,OP1,F1> const& lhs, ureal_t<R2,P2,RP2,OP2,F2> const& rhs)
     {
       return !(lhs < rhs);
     }
@@ -3304,10 +3370,10 @@
 namespace std
 {
   //! numeric limits trait specializations
-  template <int R, int P, typename RP, typename OP, typename Opt>
-  struct numeric_limits<boost::fixed_point::signed_number<R, P, RP, OP, Opt> >
+  template <int R, int P, typename RP, typename OP, typename F>
+  struct numeric_limits<boost::fixed_point::real_t<R, P, RP, OP, F> >
   {
-    typedef boost::fixed_point::signed_number<R, P, RP, OP, Opt> rep;
+    typedef boost::fixed_point::real_t<R, P, RP, OP, F> rep;
   public:
     BOOST_STATIC_CONSTEXPR
     bool is_specialized = true;

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-17 14:51:00 EDT (Tue, 17 Apr 2012)
@@ -11,7 +11,7 @@
 
 struct pixel
 {
-  unsigned_number<8, 0> r, g, b, a;
+  ureal_t<8, 0> r, g, b, a;
 };
 
 pixel blend(pixel a, pixel b)
@@ -25,8 +25,8 @@
   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<unsigned_number<8, 0> > (c_a * to_unsigned_number<255, 0> ());
-  c.r = number_cast<unsigned_number<8, 0> > (c_r * to_unsigned_number<255, 0> ());
+  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> ());
   return c;
 }
 
@@ -34,99 +34,99 @@
 {
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2, round::negative> n;
+    ureal_t<2, -2, round::negative> n;
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2, round::negative> n;
+    real_t<2, -2, round::negative> n;
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2, round::truncated> n;
+    real_t<2, -2, round::truncated> n;
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2, round::positive> n;
+    real_t<2, -2, round::positive> n;
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2, round::negative> n( (index(1)));
+    ureal_t<2, -2, round::negative> n( (index(1)));
     BOOST_TEST(n.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2, round::negative> n = to_unsigned_number<1, 0> (); //
+    ureal_t<2, -2, round::negative> n = to_unsigned_number<1, 0> (); //
     std::cout << int(n.count()) << std::endl;
     BOOST_TEST(n.count() == 4);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2, round::negative> n( (index(1)));
+    real_t<2, -2, round::negative> n( (index(1)));
     BOOST_TEST(n.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2, round::truncated> n( (index(1)));
+    real_t<2, -2, round::truncated> n( (index(1)));
     BOOST_TEST(n.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2, round::positive> n( (index(1)));
+    real_t<2, -2, round::positive> n( (index(1)));
     BOOST_TEST(n.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<1, -32> n1( (index(1U)));
-    unsigned_number<64, 31, round::negative> n2(n1);
+    ureal_t<1, -32> n1( (index(1U)));
+    ureal_t<64, 31, round::negative> n2(n1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<8, 0> n1( (index(255)));
-    unsigned_number<8, 0, round::negative> n2(n1);
+    ureal_t<8, 0> n1( (index(255)));
+    ureal_t<8, 0, round::negative> n2(n1);
     BOOST_TEST(n2.count() == 255);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<9, -1> n1( (index(-254)));
-    signed_number<7, 0, round::negative> n2(n1);
+    real_t<9, -1> n1( (index(-254)));
+    real_t<7, 0, round::negative> n2(n1);
     BOOST_TEST(n2.count() == -127);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(1)));
-    unsigned_number<2, -2, round::negative> n2(n1);
+    ureal_t<2, -2> n1( (index(1)));
+    ureal_t<2, -2, round::negative> n2(n1);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n2.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(1)));
-    signed_number<2, -2, round::negative> n2(n1);
+    real_t<2, -2> n1( (index(1)));
+    real_t<2, -2, round::negative> n2(n1);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n2.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(1)));
-    signed_number<2, -2, round::negative> n2;
+    real_t<2, -2> n1( (index(1)));
+    real_t<2, -2, round::negative> n2;
     n2 = n1;
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n2.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(1)));
-    signed_number<2, -3, round::negative> n2(n1);
+    real_t<2, -2> n1( (index(1)));
+    real_t<2, -3, round::negative> n2(n1);
     BOOST_TEST(n1.count() == 1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 2);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(1)));
-    signed_number<2, -3, round::negative> n2;
+    real_t<2, -2> n1( (index(1)));
+    real_t<2, -3, round::negative> n2;
     n2 = n1;
     BOOST_TEST(n1.count() == 1);
     std::cout << int(n2.count()) << std::endl;
@@ -134,153 +134,153 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(1)));
-    unsigned_number<2, -3, round::negative> n2(n1);
+    ureal_t<2, -2> n1( (index(1)));
+    ureal_t<2, -3, round::negative> n2(n1);
     BOOST_TEST(n1.count() == 1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 2);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -3> n1( (index(1)));
-    unsigned_number<2, -2, round::negative> n2(n1);
+    ureal_t<2, -3> n1( (index(1)));
+    ureal_t<2, -2, round::negative> n2(n1);
     BOOST_TEST(n1.count() == 1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   //  {
-  //    unsigned_number<2,-3> n1((index(1)));
-  //    unsigned_number<2,-2> n2;
+  //    ureal_t<2,-3> n1((index(1)));
+  //    ureal_t<2,-2> n2;
   //    n2=n1; // compile must fail as conversion required
   //  }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -3> n1( (index(1)));
-    unsigned_number<2, -2, round::negative> n2;
-    n2 = number_cast<unsigned_number<2, -2, round::negative> > (n1);
+    ureal_t<2, -3> n1( (index(1)));
+    ureal_t<2, -2, round::negative> n2;
+    n2 = number_cast<ureal_t<2, -2, round::negative> > (n1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(1)));
-    signed_number<2, -2, round::negative> n2(n1);
+    real_t<2, -3> n1( (index(1)));
+    real_t<2, -2, round::negative> n2(n1);
     BOOST_TEST(n1.count() == 1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(1)));
-    signed_number<2, -2, round::positive> n2(n1);
+    real_t<2, -3> n1( (index(1)));
+    real_t<2, -2, round::positive> n2(n1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(1)));
-    signed_number<2, -2, round::truncated> n2(n1);
+    real_t<2, -3> n1( (index(1)));
+    real_t<2, -2, round::truncated> n2(n1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(0)));
-    signed_number<2, -2, round::negative> n2(n1);
+    real_t<2, -3> n1( (index(0)));
+    real_t<2, -2, round::negative> n2(n1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -3> n1( (index(0)));
-    unsigned_number<2, -2, round::negative> n2(n1);
+    ureal_t<2, -3> n1( (index(0)));
+    ureal_t<2, -2, round::negative> n2(n1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(2)));
-    signed_number<2, -2, round::negative> n2(n1);
+    real_t<2, -3> n1( (index(2)));
+    real_t<2, -2, round::negative> n2(n1);
     BOOST_TEST(n1.count() == 2);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(2)));
-    signed_number<2, -2, round::positive> n2(n1);
+    real_t<2, -3> n1( (index(2)));
+    real_t<2, -2, round::positive> n2(n1);
     BOOST_TEST(n1.count() == 2);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(2)));
-    signed_number<2, -2, round::truncated> n2(n1);
+    real_t<2, -3> n1( (index(2)));
+    real_t<2, -2, round::truncated> n2(n1);
     BOOST_TEST(n1.count() == 2);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(-1)));
-    signed_number<2, -2, round::negative> n2(n1);
+    real_t<2, -3> n1( (index(-1)));
+    real_t<2, -2, round::negative> n2(n1);
     BOOST_TEST(n1.count() == -1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == -1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(-1)));
-    signed_number<2, -2, round::positive> n2(n1);
+    real_t<2, -3> n1( (index(-1)));
+    real_t<2, -2, round::positive> n2(n1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(-1)));
-    signed_number<2, -2, round::truncated> n2(n1);
+    real_t<2, -3> n1( (index(-1)));
+    real_t<2, -2, round::truncated> n2(n1);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(-2)));
-    signed_number<2, -2, round::negative> n2(n1);
+    real_t<2, -3> n1( (index(-2)));
+    real_t<2, -2, round::negative> n2(n1);
     BOOST_TEST(n1.count() == -2);
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n2.count() == -1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(-2)));
-    signed_number<2, -2, round::positive> n2(n1);
+    real_t<2, -3> n1( (index(-2)));
+    real_t<2, -2, round::positive> n2(n1);
     BOOST_TEST(n1.count() == -2);
     BOOST_TEST(n2.count() == -1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -3> n1( (index(-2)));
-    signed_number<2, -2, round::truncated> n2(n1);
+    real_t<2, -3> n1( (index(-2)));
+    real_t<2, -2, round::truncated> n2(n1);
     BOOST_TEST(n1.count() == -2);
     BOOST_TEST(n2.count() == -1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(-7)));
+    real_t<2, -1> n1( (index(-7)));
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
+    real_t<2, -1> n1( (index(7)));
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -1> n1( (index(7)));
+    ureal_t<2, -1> n1( (index(7)));
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
+    real_t<2, -2> n1( (index(15)));
     try
     {
-      signed_number<2, -1> n2(n1);
+      real_t<2, -1> n2(n1);
       BOOST_TEST(false);
     }
     catch (positive_overflow &)
@@ -289,10 +289,10 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(15)));
+    ureal_t<2, -2> n1( (index(15)));
     try
     {
-      unsigned_number<2, -1> n2(n1);
+      ureal_t<2, -1> n2(n1);
       BOOST_TEST(false);
     }
     catch (positive_overflow &)
@@ -301,10 +301,10 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(-15)));
+    real_t<2, -2> n1( (index(-15)));
     try
     {
-      signed_number<2, -1> n2(n1);
+      real_t<2, -1> n2(n1);
       BOOST_TEST(false);
     }
     catch (negative_overflow &)
@@ -313,10 +313,10 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<3, -1> n1( (index(15)));
+    real_t<3, -1> n1( (index(15)));
     try
     {
-      signed_number<2, -1> n2(n1);
+      real_t<2, -1> n2(n1);
       BOOST_TEST(false);
     }
     catch (positive_overflow &)
@@ -325,10 +325,10 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<3, -1> n1( (index(-15)));
+    real_t<3, -1> n1( (index(-15)));
     try
     {
-      signed_number<2, -1> n2(n1);
+      real_t<2, -1> n2(n1);
       BOOST_TEST(false);
     }
     catch (negative_overflow &)
@@ -337,10 +337,10 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<3, -2> n1( (index(31)));
+    real_t<3, -2> n1( (index(31)));
     try
     {
-      signed_number<2, -1> n2(n1);
+      real_t<2, -1> n2(n1);
       BOOST_TEST(false);
     }
     catch (positive_overflow &)
@@ -349,10 +349,10 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<3, -2> n1( (index(-31)));
+    real_t<3, -2> n1( (index(-31)));
     try
     {
-      signed_number<2, -1> n2(n1);
+      real_t<2, -1> n2(n1);
       BOOST_TEST(false);
     }
     catch (negative_overflow &)
@@ -363,49 +363,49 @@
   // C(int)
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(1);
+    real_t<4, -1> n1(1);
     BOOST_TEST(n1.count() == 2);
     BOOST_TEST(n1.as_int() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(-1);
+    real_t<4, -1> n1(-1);
     BOOST_TEST(n1.count() == -2);
     BOOST_TEST(n1.as_int() == -1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1(1U);
+    ureal_t<4, -1> n1(1U);
     BOOST_TEST(n1.count() == 2);
     BOOST_TEST(n1.as_unsigned_int() == 1U);
   }
   //  {
   //    std::cout << __FILE__ << "[" <<__LINE__<<"]"<<std::endl;
-  //    unsigned_number<4,-1> n1(-1); // compile must fail as ambiguous
+  //    ureal_t<4,-1> n1(-1); // compile must fail as ambiguous
   //  }
   /////////////////////////////////////////////////////////////////
   // C(float)
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(0.5f);
+    real_t<4, -1> n1(0.5f);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n1.as_float() == 0.5f);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(-0.5f);
+    real_t<4, -1> n1(-0.5f);
     BOOST_TEST(n1.count() == -1);
     BOOST_TEST(n1.as_float() == -0.5f);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1(0.5f);
+    ureal_t<4, -1> n1(0.5f);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n1.as_float() == 0.5f);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1(-0.5f);
+    ureal_t<4, -1> n1(-0.5f);
     BOOST_TEST(n1.count() == 0);
     BOOST_TEST(n1.as_float() == 0.0f);
   }
@@ -413,19 +413,19 @@
   // C(double)
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(0.5);
+    real_t<4, -1> n1(0.5);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n1.as_double() == 0.5);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(-0.5);
+    real_t<4, -1> n1(-0.5);
     BOOST_TEST(n1.count() == -1);
     BOOST_TEST(n1.as_double() == -0.5);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1(0.5);
+    ureal_t<4, -1> n1(0.5);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n1.as_double() == 0.5);
   }
@@ -433,19 +433,19 @@
   // C(long double)
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(0.5l);
+    real_t<4, -1> n1(0.5l);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n1.as_long_double() == 0.5l);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1(-0.5l);
+    real_t<4, -1> n1(-0.5l);
     BOOST_TEST(n1.count() == -1);
     BOOST_TEST(n1.as_long_double() == -0.5l);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1(0.5l);
+    ureal_t<4, -1> n1(0.5l);
     BOOST_TEST(n1.count() == 1);
     BOOST_TEST(n1.as_long_double() == 0.5l);
   }
@@ -453,93 +453,93 @@
   /////////////////////////////////////////////////////////////////
   // unary plus
   {
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2(+n1);
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2(+n1);
     BOOST_TEST(n2.count() == 7);
   }
   {
-    unsigned_number<2, -1> n1( (index(3)));
-    unsigned_number<2, -1> n2(+n1);
+    ureal_t<2, -1> n1( (index(3)));
+    ureal_t<2, -1> n2(+n1);
     BOOST_TEST(n2.count() == 3);
   }
   /////////////////////////////////////////////////////////////////
   // unary minus
   {
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2(-n1);
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2(-n1);
     BOOST_TEST(n2.count() == -7);
-    signed_number<2, -1> n3(-n2);
+    real_t<2, -1> n3(-n2);
     BOOST_TEST(n3.count() == 7);
   }
   {
-    unsigned_number<2, -1> n1( (index(3)));
-    signed_number<2, -1> n2(-n1);
+    ureal_t<2, -1> n1( (index(3)));
+    real_t<2, -1> n2(-n1);
     BOOST_TEST(n2.count() == -3);
-    signed_number<2, -1> n3(-n2);
+    real_t<2, -1> n3(-n2);
     BOOST_TEST(n3.count() == 3);
   }
   /////////////////////////////////////////////////////////////////
   // plus
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -1> n3 = n1 + n2;
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -1> n3 = n1 + n2;
     BOOST_TEST(n3.count() == 14);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(7)));
-    unsigned_number<2, -2> n2( (index(7)));
-    signed_number<3, -2> n3 = n1 + n2;
+    ureal_t<2, -2> n1( (index(7)));
+    ureal_t<2, -2> n2( (index(7)));
+    real_t<3, -2> n3 = n1 + n2;
     BOOST_TEST(n3.count() == 14);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(7)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<3, -2> n3 = n2 + n1;
+    ureal_t<2, -2> n1( (index(7)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<3, -2> n3 = n2 + n1;
     BOOST_TEST(n3.count() == 14);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
     BOOST_AUTO(n3, n1 + n2);
     BOOST_TEST(n3.count() == 14);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(-7)));
-    signed_number<2, -1> n2( (index(-7)));
-    signed_number<3, -1> n3 = n1 + n2;
+    real_t<2, -1> n1( (index(-7)));
+    real_t<2, -1> n2( (index(-7)));
+    real_t<3, -1> n3 = n1 + n2;
     BOOST_TEST(n3.count() == -14);
   }
   /////////////////////////////////////////////////////////////////
   // +=
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(3)));
-    signed_number<2, -1> n2( (index(3)));
+    real_t<2, -1> n1( (index(3)));
+    real_t<2, -1> n2( (index(3)));
     n1 += n2;
     BOOST_TEST(n1.count() == 6);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1( (index(3)));
+    real_t<4, -1> n1( (index(3)));
     BOOST_TEST(n1.count() == 3);
     n1 += convert(1.0);
     BOOST_TEST(n1.count() == 5);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1( (index(3)));
+    real_t<4, -1> n1( (index(3)));
     n1 += convert(1);
     BOOST_TEST(n1.count() == 5);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1( (index(3)));
+    ureal_t<4, -1> n1( (index(3)));
     n1 += convert(1u);
     BOOST_TEST(n1.count() == 5);
   }
@@ -547,13 +547,13 @@
   // ++()
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1( (index(3)));
+    real_t<4, -1> n1( (index(3)));
     ++n1;
     BOOST_TEST(n1.count() == 5);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1( (index(3)));
+    ureal_t<4, -1> n1( (index(3)));
     ++n1;
     BOOST_TEST(n1.count() == 5);
   }
@@ -561,15 +561,15 @@
   // ++(int)
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1( (index(3)));
-    signed_number<4, -1> n2 = n1++;
+    real_t<4, -1> n1( (index(3)));
+    real_t<4, -1> n2 = n1++;
     BOOST_TEST(n1.count() == 5);
     BOOST_TEST(n2.count() == 3);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1( (index(3)));
-    unsigned_number<4, -1> n2 = n1++;
+    ureal_t<4, -1> n1( (index(3)));
+    ureal_t<4, -1> n2 = n1++;
     BOOST_TEST(n1.count() == 5);
     BOOST_TEST(n2.count() == 3);
   }
@@ -577,13 +577,13 @@
   // --()
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<4, -1> n1( (index(3)));
+    real_t<4, -1> n1( (index(3)));
     --n1;
     BOOST_TEST(n1.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<4, -1> n1( (index(3)));
+    ureal_t<4, -1> n1( (index(3)));
     --n1;
     BOOST_TEST(n1.count() == 1);
   }
@@ -591,24 +591,24 @@
   // minus
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -1> n3 = n1 - n2;
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -1> n3 = n1 - n2;
     BOOST_TEST(n3.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(7)));
-    unsigned_number<2, -2> n2( (index(7)));
-    signed_number<3, -2> n3 = n1 - n2;
+    ureal_t<2, -2> n1( (index(7)));
+    ureal_t<2, -2> n2( (index(7)));
+    real_t<3, -2> n3 = n1 - n2;
     BOOST_TEST(n3.count() == 0);
   }
   /////////////////////////////////////////////////////////////////
   // -=
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
     n1 -= n2;
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 0);
@@ -617,33 +617,33 @@
   // multiply
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<4, -2> n3 = n1 * n2;
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<4, -2> n3 = n1 * n2;
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 49);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(7)));
-    unsigned_number<2, -2> n2( (index(7)));
-    unsigned_number<4, -4> n3 = n1 * n2;
+    ureal_t<2, -2> n1( (index(7)));
+    ureal_t<2, -2> n2( (index(7)));
+    ureal_t<4, -4> n3 = n1 * n2;
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 49);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(7)));
-    unsigned_number<2, -2> n2( (index(7)));
-    signed_number<4, -4> n3 = n1 * n2;
+    real_t<2, -2> n1( (index(7)));
+    ureal_t<2, -2> n2( (index(7)));
+    real_t<4, -4> n3 = n1 * n2;
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 49);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<2, -2> n1( (index(7)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<4, -4> n3 = n1 * n2;
+    ureal_t<2, -2> n1( (index(7)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<4, -4> n3 = n1 * n2;
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 49);
   }
@@ -652,15 +652,15 @@
   // virtual_scale
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<6, -2> n1( (index(7)));
-    signed_number<8, 0> n2 = n1.virtual_scale<2> ();
+    real_t<6, -2> n1( (index(7)));
+    real_t<8, 0> n2 = n1.virtual_scale<2> ();
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n1.count() == 7);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<6, -2> n1( (index(7)));
-    unsigned_number<8, 0> n2 = n1.virtual_scale<2> ();
+    ureal_t<6, -2> n1( (index(7)));
+    ureal_t<8, 0> n2 = n1.virtual_scale<2> ();
     std::cout << int(n2.count()) << std::endl;
     BOOST_TEST(n1.count() == 7);
   }
@@ -668,14 +668,14 @@
   // scale_up
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<6, -2> n1( (index(7)));
+    real_t<6, -2> n1( (index(7)));
     n1.scale_up<2> ();
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 28);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<6, -2> n1( (index(7)));
+    ureal_t<6, -2> n1( (index(7)));
     n1.scale_up<2> ();
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 28);
@@ -684,28 +684,28 @@
   // scale
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<6, -2> n1( (index(7)));
+    real_t<6, -2> n1( (index(7)));
     n1.scale<2, round::truncated> ();
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 28);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<6, -2> n1( (index(4)));
+    real_t<6, -2> n1( (index(4)));
     n1.scale<-2, round::truncated> ();
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<6, -2> n1( (index(7)));
+    ureal_t<6, -2> n1( (index(7)));
     n1.scale<2, round::truncated> ();
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 28);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<6, -2> n1( (index(4U)));
+    ureal_t<6, -2> n1( (index(4U)));
     n1.scale<-2, round::truncated> ();
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 1);
@@ -714,33 +714,33 @@
   // *=
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<6, -1, round::truncated> n1( (index(7)));
-    signed_number<6, -1, round::truncated> n2( (index(3)));
+    real_t<6, -1, round::truncated> n1( (index(7)));
+    real_t<6, -1, round::truncated> n2( (index(3)));
     n1 *= n2;
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 10); // The exact result 21/4 rounds to 10/2.
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<6, -1, round::truncated> n1( (index(7)));
-    unsigned_number<6, -1, round::truncated> n2( (index(3)));
+    real_t<6, -1, round::truncated> n1( (index(7)));
+    ureal_t<6, -1, round::truncated> n2( (index(3)));
     n1 *= n2;
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 10); // The exact result 21/4 rounds to 10/2.
   }
   //  {
   //    std::cout << __FILE__ << "[" <<__LINE__<<"]"<<std::endl;
-  //    unsigned_number<6,-1, round::truncated> n1((index(7)));
-  //    signed_number<6,-1, round::truncated> n2((index(3)));
+  //    ureal_t<6,-1, round::truncated> n1((index(7)));
+  //    real_t<6,-1, round::truncated> n2((index(3)));
   //    n1*=n2; // compile fails
   //    std::cout << int(n1.count()) << std::endl;
   //    BOOST_TEST(n1.count()==10); // The exact result 21/4 rounds to 10/2.
   //  }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    unsigned_number<6, -1, round::truncated> n1( (index(7)));
-    signed_number<6, -1, round::truncated> n2( (index(3)));
-    n1 *= number_cast<unsigned_number<6, -1, round::truncated> > (n2); // force cast
+    ureal_t<6, -1, round::truncated> n1( (index(7)));
+    real_t<6, -1, round::truncated> n2( (index(3)));
+    n1 *= number_cast<ureal_t<6, -1, round::truncated> > (n2); // force cast
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 10); // The exact result 21/4 rounds to 10/2.
   }
@@ -748,15 +748,15 @@
   // /=
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<3, -2, round::truncated> n1( (index(1)));
-    signed_number<3, -2, round::truncated> n2( (index(7)));
+    real_t<3, -2, round::truncated> n1( (index(1)));
+    real_t<3, -2, round::truncated> n2( (index(7)));
     n1 /= n2;
     BOOST_TEST(n1.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<3, -2, round::truncated> n1( (index(7)));
-    signed_number<3, -2, round::truncated> n2( (index(3)));
+    real_t<3, -2, round::truncated> n1( (index(7)));
+    real_t<3, -2, round::truncated> n2( (index(3)));
     n1 /= n2;
     std::cout << int(n1.count()) << std::endl;
     BOOST_TEST(n1.count() == 9); // 7*4/3
@@ -764,200 +764,200 @@
   // divide
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(1)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -2> n3 = divide<signed_number<3, -2, round::truncated> > (n1, n2);
+    real_t<2, -1> n1( (index(1)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -2> n3 = divide<real_t<3, -2, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(1)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -2> n3 = divide<signed_number<3, -2, round::negative> > (n1, n2);
+    real_t<2, -1> n1( (index(1)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -2> n3 = divide<real_t<3, -2, round::negative> > (n1, n2);
     BOOST_TEST(n3.count() == 0);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(1)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -2> n3 = divide<signed_number<3, -2, round::positive> > (n1, n2);
+    real_t<2, -1> n1( (index(1)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -2> n3 = divide<real_t<3, -2, round::positive> > (n1, n2);
     BOOST_TEST(n3.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -2> n2( (index(1)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::truncated> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -2> n2( (index(1)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 30);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -2> n2( (index(1)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::negative> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -2> n2( (index(1)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::negative> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 30);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -2> n2( (index(1)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::positive> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -2> n2( (index(1)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::positive> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 30);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(-15)));
-    signed_number<2, -2> n2( (index(1)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::negative> > (n1, n2);
+    real_t<2, -2> n1( (index(-15)));
+    real_t<2, -2> n2( (index(1)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::negative> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == -30);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(-15)));
-    signed_number<2, -2> n2( (index(1)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::positive> > (n1, n2);
+    real_t<2, -2> n1( (index(-15)));
+    real_t<2, -2> n2( (index(1)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::positive> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == -30);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::negative> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::negative> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 4);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::positive> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::positive> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 5);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(-15)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::negative> > (n1, n2);
+    real_t<2, -2> n1( (index(-15)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::negative> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == -5);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(-15)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::positive> > (n1, n2);
+    real_t<2, -2> n1( (index(-15)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::positive> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == -4);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -1> n2( (index(1)));
-    signed_number<4, -1> n3 = divide<signed_number<4, -1, round::truncated> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -1> n2( (index(1)));
+    real_t<4, -1> n3 = divide<real_t<4, -1, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 15);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -1> n2( (index(1)));
-    signed_number<4, 0> n3 = divide<signed_number<4, 0, round::truncated> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -1> n2( (index(1)));
+    real_t<4, 0> n3 = divide<real_t<4, 0, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 7);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -1> n2( (index(1)));
-    signed_number<4, 1> n3 = divide<signed_number<4, 1, round::truncated> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -1> n2( (index(1)));
+    real_t<4, 1> n3 = divide<real_t<4, 1, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 3);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -2> n1( (index(15)));
-    signed_number<2, -1> n2( (index(1)));
-    signed_number<4, 2> n3 = divide<signed_number<4, 2, round::truncated> > (n1, n2);
+    real_t<2, -2> n1( (index(15)));
+    real_t<2, -1> n2( (index(1)));
+    real_t<4, 2> n3 = divide<real_t<4, 2, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(1)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -6> n3 = divide<signed_number<3, -6, round::truncated> > (n1, n2);
+    real_t<2, -1> n1( (index(1)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -6> n3 = divide<real_t<3, -6, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 9);
   }
   {
-    unsigned_number<2, -1> n1( (index(1)));
-    unsigned_number<2, -2> n2( (index(7)));
-    unsigned_number<4, -6> n3 = divide<unsigned_number<4, -6, round::truncated> > (n1, n2);
+    ureal_t<2, -1> n1( (index(1)));
+    ureal_t<2, -2> n2( (index(7)));
+    ureal_t<4, -6> n3 = divide<ureal_t<4, -6, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 18);
   }
   {
-    signed_number<2, -1> n1( (index(1)));
-    unsigned_number<2, -2> n2( (index(7)));
-    signed_number<4, -6> n3 = divide<signed_number<4, -6, round::truncated> > (n1, n2);
+    real_t<2, -1> n1( (index(1)));
+    ureal_t<2, -2> n2( (index(7)));
+    real_t<4, -6> n3 = divide<real_t<4, -6, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 18);
   }
   {
-    unsigned_number<2, -1> n1( (index(1)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<4, -6> n3 = divide<signed_number<4, -6, round::truncated> > (n1, n2);
+    ureal_t<2, -1> n1( (index(1)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<4, -6> n3 = divide<real_t<4, -6, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 18);
   }
   {
-    unsigned_number<2, -1> n1( (index(1)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<4, -3> n3 = n1 / n2;
+    ureal_t<2, -1> n1( (index(1)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<4, -3> n3 = n1 / n2;
     BOOST_TEST(n3.count() == 2);
   }
   {
-    signed_number<2, -1> n1( (index(1)));
-    signed_number<2, -2> n2( (index(7)));
-    signed_number<6, -3> n3 = divide<signed_number<6, -3, round::truncated> > (n1, n2);
+    real_t<2, -1> n1( (index(1)));
+    real_t<2, -2> n2( (index(7)));
+    real_t<6, -3> n3 = divide<real_t<6, -3, round::truncated> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 2);
   }
   {
-    signed_number<2, -1> n1( (index(-1)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -6> n3 = divide<signed_number<3, -6, round::truncated> > (n1, n2);
+    real_t<2, -1> n1( (index(-1)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -6> n3 = divide<real_t<3, -6, round::truncated> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == -9);
   }
   {
-    signed_number<2, -1> n1( (index(1)));
-    signed_number<2, -1> n2( (index(7)));
-    signed_number<3, -3, round::negative> n3 = n1 / n2;
+    real_t<2, -1> n1( (index(1)));
+    real_t<2, -1> n2( (index(7)));
+    real_t<3, -3, round::negative> n3 = n1 / n2;
     BOOST_TEST(n3.count() == 1);
   }
   {
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(1)));
-    signed_number<3, -6> n3 = divide<signed_number<3, -6, round::truncated> > (n1, n2);
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(1)));
+    real_t<3, -6> n3 = divide<real_t<3, -6, round::truncated> > (n1, n2);
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 7 * 64);
   }
   {
-    signed_number<4, 1> n1( (index(1)));
-    signed_number<4, 1> n2( (index(7)));
-    signed_number<3, -6> n3 = divide<signed_number<3, -6, round::truncated> > (n1, n2);
+    real_t<4, 1> n1( (index(1)));
+    real_t<4, 1> n2( (index(7)));
+    real_t<3, -6> n3 = divide<real_t<3, -6, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 9);
   }
   {
-    signed_number<4, 1> n1( (index(1)));
-    signed_number<4, 1> n2( (index(7)));
-    signed_number<3, -3> n3 = divide<signed_number<3, -3, round::truncated> > (n1, n2);
+    real_t<4, 1> n1( (index(1)));
+    real_t<4, 1> n2( (index(7)));
+    real_t<3, -3> n3 = divide<real_t<3, -3, round::truncated> > (n1, n2);
     BOOST_TEST(n3.count() == 1);
   }
   {
-    signed_number<4, 1> n1( (index(7)));
-    signed_number<4, 1> n2( (index(1)));
+    real_t<4, 1> n1( (index(7)));
+    real_t<4, 1> n2( (index(1)));
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     std::cout << int(n2.count()) << std::endl;
-    signed_number<3, -6> n3 = divide<signed_number<3, -6, round::truncated> > (n1, n2);
+    real_t<3, -6> n3 = divide<real_t<3, -6, round::truncated> > (n1, n2);
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
     std::cout << int(n3.count()) << std::endl;
     BOOST_TEST(n3.count() == 7 * 64);
@@ -966,79 +966,79 @@
   // equal
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
     BOOST_TEST(n1 == n2);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -2> n2( (index(14)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -2> n2( (index(14)));
     BOOST_TEST(n1 == n2);
   }
   /////////////////////////////////////////////////////////////////
   // not_equal
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(1)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(1)));
     BOOST_TEST(n1 != n2);
   }
   /////////////////////////////////////////////////////////////////
   // gt
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(1)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(1)));
     BOOST_TEST(n1 > n2);
   }
   /////////////////////////////////////////////////////////////////
   // ge
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(1)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(1)));
     BOOST_TEST(n1 >= n2);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
     BOOST_TEST(n1 >= n2);
   }
   /////////////////////////////////////////////////////////////////
   // lt
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(1)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(1)));
     BOOST_TEST(n2 < n1);
   }
   // le
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(1)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(1)));
     BOOST_TEST(n2 <= n1);
   }
   //  {
-  //    unsigned_number<2,-1> n1((index(-7))); // assertion failed
+  //    ureal_t<2,-1> n1((index(-7))); // assertion failed
   //  }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<1, -2> n2( (index(1)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<1, -2> n2( (index(1)));
     BOOST_TEST(n2 <= n1);
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    signed_number<2, -1> n1( (index(7)));
-    signed_number<2, -1> n2( (index(7)));
+    real_t<2, -1> n1( (index(7)));
+    real_t<2, -1> n2( (index(7)));
     BOOST_TEST(n2 <= n1);
   }
   //  {
-  //    signed_number<32,-32> n; // compile fail
-  //    std::cout  << sizeof(signed_number<32,-32>::underlying_type) << std::endl;
+  //    real_t<32,-32> n; // compile fail
+  //    std::cout  << sizeof(real_t<32,-32>::underlying_type) << std::endl;
   //    std::cout  << ::std::numeric_limits<long>::digits << std::endl;
   //    std::cout  << (int)(sizeof(boost::long_long_type) * CHAR_BIT) << std::endl;
   //  }
@@ -1069,13 +1069,13 @@
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    typedef unsigned_number<8, 0> T;
+    typedef ureal_t<8, 0> T;
     std::cout << T::min_index << std::endl;
     std::cout << T::max_index << std::endl;
   }
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    typedef signed_number<8, 0> T;
+    typedef real_t<8, 0> T;
     std::cout << T::min_index << std::endl;
     std::cout << T::max_index << std::endl;
     std::cout << sizeof(long int) << std::endl;
@@ -1084,7 +1084,7 @@
   /////////////////////////////////////////////////////////////////
   {
     std::cout << __FILE__ << "[" << __LINE__ << "]" << std::endl;
-    typedef signed_number<15, -16> fp_15__16; // Signed fixed-point values with 15 bits of integer part
+    typedef real_t<15, -16> fp_15__16; // Signed fixed-point values with 15 bits of integer part
     // and 16 bits of fractional part.
     fp_15__16 f1, f2;
     f1 = convert(1.2345); // Conversion from floating point.