diff --git a/include/checked.hpp b/include/checked.hpp
index 9bb9ca9..12a99a1 100644
--- a/include/checked.hpp
+++ b/include/checked.hpp
@@ -160,6 +160,21 @@ namespace checked {
         ;
     }
 
+    template<class R, class T, class U>
+    SAFE_NUMERIC_CONSTEXPR checked_result<R> add(
+        const T & t,
+        const U & u
+    ) {
+        return
+            add<R, T, U>(
+                std::numeric_limits<R>::min(),
+                std::numeric_limits<R>::max(),
+                t,
+                u
+            )
+        ;
+    }
+
     ////////////////////////////////////////////////////
     // safe subtraction on primitive types
     namespace detail {
@@ -231,6 +246,21 @@ namespace checked {
                 detail::subtract<R>(minr, maxr, t, u)
         ;
     }
+    
+    template<class R, class T, class U>
+    SAFE_NUMERIC_CONSTEXPR checked_result<R> subtract(
+        const T & t,
+        const U & u
+    ) {
+        return
+            subtract<R, T, U>(
+                std::numeric_limits<R>::min(),
+                std::numeric_limits<R>::max(),
+                t,
+                u
+            )
+        ;
+    }
 
     ////////////////////////////////////////////////////
     // safe multiplication on unsafe types
@@ -389,9 +419,9 @@ namespace checked {
             detail::cast<R>(u) != checked_result<R>::exception_type::no_exception ?
                 detail::cast<R>(u)
             :
-            //sizeof(R) >= sizeof(T) + sizeof(U) ?
-            //    checked_result<R>(static_cast<R>(t) * static_cast<R>(u))
-            //:
+            sizeof(R) >= sizeof(T) + sizeof(U) ?
+                checked_result<R>(static_cast<R>(t) * static_cast<R>(u))
+            :
                 detail::multiply<R>(minr, maxr, t, u)
         ;
     }
@@ -491,32 +521,89 @@ namespace checked {
             )
         ;
     }
-    /*
-    template<class T, class U>
-    decltype(T() / U())
-    check_modulus_overflow(const T & t, const U & u){
-        if(0 == u)
-            overflow("modulus divide by zero");
 
-        if(boost::numeric::is_signed<U>::value){
-            // t unsigned, u signed
-            if(boost::numeric::is_unsigned<T>::value){
-                if(u < 0){
-                    overflow("conversion of negative value to unsigned");
-                }
-            }
-            else{
-            // both signed
-                // pathological case: change sign on negative number so it overflows
-                if(t == boost::integer_traits<T>::const_min && u == -1)
-                    overflow("overflow in result");
-            }
-        }
-        // both unsigned
-        // t signed, u unsigned
-        return t % u;
+    ////////////////////////////////
+    // safe modulus on unsafe types
+    namespace detail {
+
+    template<class R>
+    typename boost::enable_if_c<
+        std::is_unsigned<R>::value,
+        checked_result<R>
+    >::type
+    SAFE_NUMERIC_CONSTEXPR modulus(
+        const R & minr,
+        const R & maxr,
+        const R t,
+        const R u
+    ) {
+        return checked_result<R>(t % u);
     }
-    */
+
+    template<class R>
+    typename boost::enable_if_c<
+        std::is_signed<R>::value,
+        checked_result<R>
+    >::type
+    SAFE_NUMERIC_CONSTEXPR modulus(
+        const R & minr,
+        const R & maxr,
+        const R t,
+        const R u
+    ){
+        return
+            // note presumption of two's complement arithmetic
+            (u < 0 && t == std::numeric_limits<R>::min()) ?
+                checked_result<R>(
+                    checked_result<R>::exception_type::domain_error,
+                    "divide by zero"
+                )
+            :
+                checked_result<R>(t % u)
+            ;
+    }
+
+    } // namespace detail
+
+    template<class R, class T, class U>
+    SAFE_NUMERIC_CONSTEXPR checked_result<R> modulus(
+        const R & minr,
+        const R & maxr,
+        const T & t,
+        const U & u
+    ) {
+        static_assert(! is_safe<T>::value, "should not be a base type here!");
+        return
+            detail::cast<R>(t) != checked_result<R>::exception_type::no_exception ?
+                detail::cast<R>(t)
+            :
+            detail::cast<R>(u) != checked_result<R>::exception_type::no_exception ?
+                detail::cast<R>(u)
+            :
+                u == 0 ?
+                    checked_result<R>(
+                        checked_result<R>::exception_type::domain_error,
+                        "divide by zero"
+                    )
+                :
+                    detail::divide<R>(minr, maxr, t, u)
+        ;
+    }
+    template<class R, class T, class U>
+    SAFE_NUMERIC_CONSTEXPR checked_result<R> modulus(
+        const T & t,
+        const U & u
+    ) {
+        return
+            divide<R, T, U>(
+                std::numeric_limits<R>::min(),
+                std::numeric_limits<R>::max(),
+                t,
+                u
+            )
+        ;
+    }
+
 } // checked
 } // numeric
 } // boost
diff --git a/include/interval.hpp b/include/interval.hpp
index f27894e..49e52d7 100644
--- a/include/interval.hpp
+++ b/include/interval.hpp
@@ -45,6 +45,24 @@ struct interval {
     }
 };
 
+template<typename R, typename T, typename U>
+SAFE_NUMERIC_CONSTEXPR interval<R> operator+(const interval<T> & t, const interval<U> & u){
+    // adapted from https://en.wikipedia.org/wiki/Interval_arithmetic
+    return interval<R>(
+        checked::add<R>(t.l, u.l),
+        checked::add<R>(t.u, u.u)
+    );
+}
+
+template<typename R, typename T, typename U>
+SAFE_NUMERIC_CONSTEXPR interval<R> operator-(const interval<T> & t, const interval<U> & u){
+    // adapted from https://en.wikipedia.org/wiki/Interval_arithmetic
+    return interval<R>(
+        checked::subtract<R>(t.l, u.u),
+        checked::subtract<R>(t.u, u.l)
+    );
+}
+
 template<typename R, typename T, typename U>
 SAFE_NUMERIC_CONSTEXPR interval<R> operator*(const interval<T> & t, const interval<U> & u){
     // the following is adapted from boost interval arith.hpp
@@ -157,63 +175,43 @@ SAFE_NUMERIC_CONSTEXPR interval<R> operator/(const interval<T> & t, const interv
         ;
 }
 
-/*
 template<typename R, typename T, typename U>
-SAFE_NUMERIC_CONSTEXPR interval<R> operator/(const interval<T> & t, const interval<U> & u){
-    // adapted from boost interval library
+SAFE_NUMERIC_CONSTEXPR interval<R> operator%(const interval<T> & t, const interval<U> & u){
+    // adapted from / operator above
     return
-        (t.u < 0) ?
-            (u.u < 0) ?
-                interval<R>(
-                    checked_result<R>(t.u, u.l),
-                    checked_result<R>(t.l, u.u)
-                )
-            :
-                interval<R>(
-                    checked_result<R>(t.l, u.l),
-                    checked_result<R>(t.u, u.u)
+        (u.l <= 0) ?
+            interval<R>(
+                0,
+                checked_result<R>(
+                    checked_result<R>::exception_type::domain_error,
+                    "interval divisor includes zero"
                 )
+            )
         :
-        (t.l < 0) ?
-            (u.u < 0) ?
-                interval<R>(
-                    checked_result<R>(t.u, u.u),
-                    checked_result<R>(t.l, u.u)
+            interval<R>(
+                min(
+                    min(
+                        checked::modulus<R>(t.l, u.l),
+                        checked::modulus<R>(t.l, u.u)
+                    ),
+                    min(
+                        checked::modulus<R>(t.u, u.l),
+                        checked::modulus<R>(t.u, u.u)
+                    )
+                ),
+                max(
+                    max(
+                        checked::modulus<R>(t.l, u.l),
+                        checked::modulus<R>(t.l, u.u)
+                    ),
+                    max(
+                        checked::modulus<R>(t.u, u.l),
+                        checked::modulus<R>(t.u, u.u)
+                    )
                 )
-            :
-                interval<R>(
-                    checked_result<R>(t.l, u.l),
-                    checked_result<R>(t.u, u.l)
-                )
-        :
-            (u.u < 0) ?
-                interval<R>(
-                    checked_result<R>(t.u, u.u),
-                    checked_result<R>(t.l, u.l)
-                )
-            :
-                interval<R>(
-                    checked_result<R>(t.l, u.u),
-                    checked_result<R>(t.u, u.l)
-                )
-    ;
+            )
+        ;
 }
-  if (::boost::numeric::interval_lib::user::is_neg(xu))
-    if (::boost::numeric::interval_lib::user::is_neg(yu))
-      return I(rnd.div_down(xu, yl), rnd.div_up(xl, yu), true);
-    else
-      return I(rnd.div_down(xl, yl), rnd.div_up(xu, yu), true);
-  else if (::boost::numeric::interval_lib::user::is_neg(xl))
-    if (::boost::numeric::interval_lib::user::is_neg(yu))
-      return I(rnd.div_down(xu, yu), rnd.div_up(xl, yu), true);
-    else
-      return I(rnd.div_down(xl, yl), rnd.div_up(xu, yl), true);
-  else
-    if (::boost::numeric::interval_lib::user::is_neg(yu))
-      return I(rnd.div_down(xu, yu), rnd.div_up(xl, yl), true);
-    else
-      return I(rnd.div_down(xl, yu), rnd.div_up(xu, yl), true);
-*/
 
 } // numeric
 } // boost
diff --git a/include/native.hpp b/include/native.hpp
index 14db46d..b152578 100644
--- a/include/native.hpp
+++ b/include/native.hpp
@@ -32,7 +32,7 @@ struct safe;
 struct native {
     template<typename T, typename U, typename P, typename E>
     struct addition_result {
-        typedef typename base_type<T>::type base_type_t;
+        typedef typename ::boost::numeric::base_type<T>::type base_type_t;
         typedef typename base_type<U>::type base_type_u;
         typedef decltype(base_type_t() + base_type_u()) result_base_type;
         typedef safe<result_base_type, P, E> type;
@@ -58,6 +58,13 @@ struct native {
         typedef decltype(base_type_t() / base_type_u()) result_base_type;
         typedef safe<result_base_type, P, E> type;
     };
+    template<typename T, typename U, typename P, typename E>
+    struct modulus_result {
+        typedef typename base_type<T>::type base_type_t;
+        typedef typename base_type<U>::type base_type_u;
+        typedef decltype(base_type_t() / base_type_u()) result_base_type;
+        typedef safe<result_base_type, P, E> type;
+    };
 };
 
 } // numeric
diff --git a/include/safe_base.hpp b/include/safe_base.hpp
index c2ed0ff..45c2a8f 100644
--- a/include/safe_base.hpp
+++ b/include/safe_base.hpp
@@ -227,74 +227,6 @@ public:
     }
 
 /*
-    /////////////////////////////////////////////////////////////////
-    // subtraction
-    template<class T, class U>
-    struct no_subtraction_overflow_possible : public
-        boost::mpl::and_<
-            typename boost::mpl::greater<
-                typename boost::mpl::sizeof_< decltype(Stored() - U()) >,
-                typename boost::mpl::max<
-                    boost::mpl::sizeof_<U>,
-                    boost::mpl::sizeof_<Stored>
-                >::type
-            >,
-            boost::numeric::is_signed<decltype(Stored() - U())>
-        >
-    {};
-
-    template<class T, class U>
-    struct no_subtraction_overflow_possible;
-
-    // case 1 - no overflow possible
-
-    template<class U>
-    typename boost::enable_if<
-        no_subtraction_overflow_possible<Stored, U>,
-        decltype(Stored() - U())
-    >::type
-    inline operator-(const U & rhs) const {
-        return m_t - rhs;
-    }
-
-    template<class U>
-    typename boost::disable_if<
-        no_subtraction_overflow_possible<Stored, U>,
-        decltype(Stored() - U())
-    >::type
-    inline operator-(const U & rhs) const {
-        return detail::check_subtraction_overflow<
-            boost::numeric::is_signed<Stored>::value,
-            boost::numeric::is_signed<U>::value
-        >::subtract(m_t, boost::numeric::safe_cast<decltype(Stored() - U())>(rhs));
-    }
-
-    /////////////////////////////////////////////////////////////////
-    // multiplication
-
-    template<class U>
-    decltype(U() * Stored())
-    inline operator*(const U & rhs) const {
-        return detail::check_multiplication_overflow(m_t, rhs);
-    }
-
-    /////////////////////////////////////////////////////////////////
-    // division
-    template<class U>
-    decltype(U() / Stored())
-    inline operator/(const U & rhs) const {
-        return detail::check_division_overflow(m_t, rhs);
-    }
-
-    /////////////////////////////////////////////////////////////////
-    // modulus
-    template<class U>
-    decltype(Stored() % U())
-    inline operator%(const U & rhs) const {
-        if(0 == rhs)
-            throw std::domain_error("Divide by zero");
-        return detail::check_modulus_overflow(m_t, rhs);
-    }
 
     /////////////////////////////////////////////////////////////////
     // logical operators
diff --git a/include/safe_base_operations.hpp b/include/safe_base_operations.hpp
index 30afb0f..176c9a1 100644
--- a/include/safe_base_operations.hpp
+++ b/include/safe_base_operations.hpp
@@ -104,6 +104,40 @@ struct common_policies {
 // These should catch things like U < safe_base<...> and implement them
 // as safe_base<...> >= U which should be handled above.
 
+/////////////////////////////////////////////////////////////////
+// cast
+
+/*
+template<class R, class U>
+T safe_cast(const U & u) {
+
+    typedef typename base_type<R>::type result_base_type;
+
+    // filter out case were overflow cannot occur
+    SAFE_NUMERIC_CONSTEXPR const interval<R> r_interval;
+    SAFE_NUMERIC_CONSTEXPR const interval<U> u_interval(
+        base_value<std::numeric_limits<U>::min()>,
+        base_value<std::numeric_limits<U>::max()>
+    );
+
+
+                    = operator*<result_base_type>(
+            interval<typename base_type<T>::type>(),
+            interval<typename base_type<U>::type>()
+        );
+
+
+    if(std::numeric_limits<T>::is_unsigned)
+        if(u < 0)
+            overflow("casting alters value");
+    if(safe_compare::greater_than(u, std::numeric_limits<T>::max()))
+        overflow("safe range overflow");
+    if(safe_compare::less_than(u, std::numeric_limits<T>::min()))
+        overflow("safe range underflow");
+    return static_cast<T>(u);
+}
+*/
+
 /////////////////////////////////////////////////////////////////
 // addition
 
@@ -137,29 +171,31 @@ inline operator+(const T & t, const U & u){
     );
 
     typedef typename base_type<result_type>::type result_base_type;
+    typedef typename base_type<T>::type t_base_type;
+    typedef typename base_type<U>::type u_base_type;
 
     // filter out case were overflow cannot occur
+    // note: subtle trickery.  Suppose is safe_range<MIN, ..>.  Then
+    // std::numeric_limits<T>::min() will be safe_range<MIN with a value of MIN
+    // Use base_value(T) ( which equals MIN ) to create a new interval. Same
+    // for MAX.  Now
+    SAFE_NUMERIC_CONSTEXPR const interval<t_base_type> t_interval = {
+            base_value(std::numeric_limits<T>::min()),
+            base_value(std::numeric_limits<T>::max())
+        };
+    SAFE_NUMERIC_CONSTEXPR const interval<u_base_type> u_interval = {
+            base_value(std::numeric_limits<U>::min()),
+            base_value(std::numeric_limits<U>::max())
+        };
 
-    SAFE_NUMERIC_CONSTEXPR checked_result<result_base_type> maxx = checked::add(
-        base_value(std::numeric_limits<result_type>::min()),
-        base_value(std::numeric_limits<result_type>::max()),
-        base_value(std::numeric_limits<T>::max()),
-        base_value(std::numeric_limits<U>::max())
-    );
-
-    SAFE_NUMERIC_CONSTEXPR checked_result<result_base_type> minx = checked::add(
-        base_value(std::numeric_limits<result_type>::min()),
-        base_value(std::numeric_limits<result_type>::max()),
-        base_value(std::numeric_limits<T>::min()),
-        base_value(std::numeric_limits<U>::min())
-    );
-
-    typedef typename checked_result<result_base_type>::exception_type exception_type;
+    // when we add the temporary intervals above, we'll get a new interva
+    // with the correct range for the sum !  Same goes for all the operations
+    // defined below.
+    SAFE_NUMERIC_CONSTEXPR const interval<result_base_type> r_interval
+        = operator+<result_base_type>(t_interval, u_interval);
 
     // if no over/under flow possible
-    if(maxx == exception_type::no_exception
-    && minx == exception_type::no_exception)
-        // just do simple addition of base values
+    if(r_interval.no_exception())
         return result_type(base_value(t) + base_value(u));
 
     // otherwise do the addition checking for overflow
@@ -207,29 +243,24 @@ inline operator-(const T & t, const U & u){
     );
 
     typedef typename base_type<result_type>::type result_base_type;
+    typedef typename base_type<T>::type t_base_type;
+    typedef typename base_type<U>::type u_base_type;
 
     // filter out case were overflow cannot occur
+    SAFE_NUMERIC_CONSTEXPR const interval<t_base_type> t_interval = {
+            base_value(std::numeric_limits<T>::min()),
+            base_value(std::numeric_limits<T>::max())
+        };
+    SAFE_NUMERIC_CONSTEXPR const interval<u_base_type> u_interval = {
+            base_value(std::numeric_limits<U>::min()),
+            base_value(std::numeric_limits<U>::max())
+        };
 
-    SAFE_NUMERIC_CONSTEXPR checked_result<result_base_type> maxx = checked::subtract(
-        base_value(std::numeric_limits<result_type>::min()),
-        base_value(std::numeric_limits<result_type>::max()),
-        base_value(std::numeric_limits<T>::max()),
-        base_value(std::numeric_limits<U>::min())
-    );
-
-    SAFE_NUMERIC_CONSTEXPR checked_result<result_base_type> minx = checked::subtract(
-        base_value(std::numeric_limits<result_type>::min()),
-        base_value(std::numeric_limits<result_type>::max()),
-        base_value(std::numeric_limits<T>::min()),
-        base_value(std::numeric_limits<U>::max())
-    );
-
-    typedef typename checked_result<result_base_type>::exception_type exception_type;
+    SAFE_NUMERIC_CONSTEXPR const interval<result_base_type> r_interval
+        = operator-<result_base_type>(t_interval, u_interval);
 
     // if no over/under flow possible
-    if(maxx == exception_type::no_exception
-    && minx == exception_type::no_exception)
-        // just do simple subtraction of base values
+    if(r_interval.no_exception())
         return result_type(base_value(t) - base_value(u));
 
     // otherwise do the subtraction checking for overflow
@@ -282,12 +313,12 @@ inline operator*(const T & t, const U & u){
 
     // filter out case were overflow cannot occur
     SAFE_NUMERIC_CONSTEXPR const interval<t_base_type> t_interval = {
-            base_value(std::numeric_limits<t_base_type>::min()),
-            base_value(std::numeric_limits<t_base_type>::max())
+            base_value(std::numeric_limits<T>::min()),
+            base_value(std::numeric_limits<T>::max())
         };
     SAFE_NUMERIC_CONSTEXPR const interval<u_base_type> u_interval = {
-            base_value(std::numeric_limits<u_base_type>::min()),
-            base_value(std::numeric_limits<u_base_type>::max())
+            base_value(std::numeric_limits<U>::min()),
+            base_value(std::numeric_limits<U>::max())
         };
 
     SAFE_NUMERIC_CONSTEXPR const interval<result_base_type> r_interval
@@ -348,12 +379,12 @@ inline operator/(const T & t, const U & u){
 
     // filter out case were overflow cannot occur
     SAFE_NUMERIC_CONSTEXPR const interval<t_base_type> t_interval = {
-            base_value(std::numeric_limits<t_base_type>::min()),
-            base_value(std::numeric_limits<t_base_type>::max())
+            base_value(std::numeric_limits<T>::min()),
+            base_value(std::numeric_limits<T>::max())
         };
     SAFE_NUMERIC_CONSTEXPR const interval<u_base_type> u_interval = {
-            base_value(std::numeric_limits<u_base_type>::min()),
-            base_value(std::numeric_limits<u_base_type>::max())
+            base_value(std::numeric_limits<U>::min()),
+            base_value(std::numeric_limits<U>::max())
         };
 
     SAFE_NUMERIC_CONSTEXPR const interval<result_base_type> r_interval
@@ -376,7 +407,87 @@ inline operator/(const T & t, const U & u){
     return static_cast<result_type>(r);
 }
 
+/////////////////////////////////////////////////////////////////
+// modulus
+
+template<class T, class U>
+struct modulus_result {
+    typedef common_policies<T, U> P;
+    typedef typename P::promotion_policy::template modulus_result<
+        T,
+        U,
+        typename P::promotion_policy,
+        typename P::exception_policy
+    >::type type;
+};
+
+template<class T, class U>
+typename boost::lazy_enable_if<
+    boost::mpl::or_<
+        boost::numeric::is_safe<T>,
+        boost::numeric::is_safe<U>
+    >,
+    modulus_result<T, U>
+>::type
+inline operator%(const T & t, const U & u){
+    // argument dependent lookup should guarentee that we only get here
+    // only if one of the types is a safe type. Verify this here
+    typedef modulus_result<T, U> ar;
+    typedef typename ar::type result_type;
+    static_assert(
+        boost::numeric::is_safe<result_type>::value,
+        "Promotion failed to return safe type"
+    );
+
+    typedef typename base_type<result_type>::type result_base_type;
+    typedef typename base_type<T>::type t_base_type;
+    typedef typename base_type<U>::type u_base_type;
+
+    // filter out case were overflow cannot occur
+    SAFE_NUMERIC_CONSTEXPR const interval<t_base_type> t_interval = {
+            base_value(std::numeric_limits<T>::min()),
+            base_value(std::numeric_limits<T>::max())
+        };
+    SAFE_NUMERIC_CONSTEXPR const interval<u_base_type> u_interval = {
+            base_value(std::numeric_limits<U>::min()),
+            base_value(std::numeric_limits<U>::max())
+        };
+
+    SAFE_NUMERIC_CONSTEXPR const interval<result_base_type> r_interval
+        = operator%<result_base_type>(t_interval, u_interval);
+
+    // if no over/under flow possible
+    if(r_interval.no_exception())
+        return result_type(base_value(t) % base_value(u));
+
+    // otherwise do the multiplication checking for overflow
+    checked_result<result_base_type>  r = checked::modulus(
+        base_value(std::numeric_limits<result_type>::min()),
+        base_value(std::numeric_limits<result_type>::max()),
+        base_value(t),
+        base_value(u)
+    );
+
+    r.template dispatch<typename ar::P::exception_policy>();
+    
+    return static_cast<result_type>(r);
+}
+
 /*
+// modulus
+template<class T, class Stored, class Derived, class Policies>
+typename boost::enable_if<
+    boost::is_integral<T>,
+    decltype(T() % Stored())
+>::type
+inline operator%(const T & lhs, const safe_base<Stored, Derived, Policies> & rhs) {
+    if(safe_compare::equal(0, rhs))
+        throw std::domain_error("Divide by zero");
+    return static_cast<
+        decltype(T() % Stored())
+    >(lhs % static_cast<const Stored &>(rhs));
+}
+
 
 // comparison operators
 template<class T, class Stored, class Derived, class Policies>
@@ -428,45 +539,6 @@ inline operator<=(const T & lhs, const safe_base<Stored, Derived, Policies> & rh
     return  rhs >= lhs;
 }
 
-// multiplication
-template<class T, class Stored, class Derived, class Policies>
-typename boost::enable_if<
-    boost::is_integral<T>,
-    decltype(T() * Stored())
->::type
-inline operator*(const T & lhs, const safe_base<Stored, Derived, Policies> & rhs) {
-    return rhs * lhs;
-}
-
-// division
-// special case - possible overflow
-template<class T, class Stored, class Derived, class Policies>
-typename boost::enable_if<
-    boost::is_integral<T>,
-    decltype(T() / Stored())
->::type
-inline operator/(const T & lhs, const safe_base<Stored, Derived, Policies> & rhs) {
-    if(safe_compare::equal(0, rhs))
-        throw std::domain_error("Divide by zero");
-    return static_cast<
-        decltype(T() / Stored())
-    >(lhs / static_cast<const Stored &>(rhs));
-}
-
-// modulus
-template<class T, class Stored, class Derived, class Policies>
-typename boost::enable_if<
-    boost::is_integral<T>,
-    decltype(T() % Stored())
->::type
-inline operator%(const T & lhs, const safe_base<Stored, Derived, Policies> & rhs) {
-    if(safe_compare::equal(0, rhs))
-        throw std::domain_error("Divide by zero");
-    return static_cast<
-        decltype(T() % Stored())
-    >(lhs % static_cast<const Stored &>(rhs));
-}
-
 // logical operators
 template<class T, class Stored, class Derived, class Policies>
 typename boost::enable_if<
diff --git a/include/safe_compare.hpp b/include/safe_compare.hpp
index 9340981..ff15617 100644
--- a/include/safe_compare.hpp
+++ b/include/safe_compare.hpp
@@ -14,24 +14,20 @@
 
 #include <type_traits>
 #include <limits>
-#include <boost/mpl/if.hpp>
+#include <boost/mpl/eval_if.hpp>
 #include <boost/mpl/identity.hpp>
 
-//#include "numeric.hpp"
-//#include "concept/numeric.hpp"
-//#include "boost/concept/assert.hpp"
-
 namespace boost {
 namespace numeric {
 namespace safe_compare {
     namespace detail {
         template<typename T>
         struct make_unsigned {
-            typedef typename boost::mpl::if_<
+            typedef typename boost::mpl::eval_if<
                 typename std::numeric_limits<T>::is_signed,
                 typename std::make_unsigned<T>,
                 typename boost::mpl::identity<T>
-            >::type::type type;
+            >::type type;
         };
         // both arguments unsigned or signed
         template<bool TS, bool US>
diff --git a/include/safe_integer.hpp b/include/safe_integer.hpp
index 55f5fd5..affa4b3 100644
--- a/include/safe_integer.hpp
+++ b/include/safe_integer.hpp
@@ -66,16 +66,16 @@ struct base_type<safe<T, P, E> > {
     typedef T type;
 };
 
-/*
 template<
     class T,
     class P,
     class E
 >
-SAFE_NUMERIC_CONSTEXPR const T & base_value(const safe<T, P, E>  & t) {
-    return static_cast<const T & >(t);
+SAFE_NUMERIC_CONSTEXPR const T & base_value(
+    const safe<T, P, E>  & st
+) {
+    return static_cast<const T & >(st);
 }
-*/
 
 template<
     class T,
diff --git a/test/test_cast.cpp b/test/test_cast.cpp
index d1c289f..b62ac34 100644
--- a/test/test_cast.cpp
+++ b/test/test_cast.cpp
@@ -7,10 +7,6 @@
 #include <iostream>
 #include <cstdlib> // EXIT_SUCCESS
 
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/array/elem.hpp>
-#include <boost/preprocessor/array/size.hpp>
-#include <boost/preprocessor/stringize.hpp>
 
 #include "../include/safe_cast.hpp"
 #include "../include/safe_compare.hpp"
@@ -53,6 +49,9 @@ bool test_cast(T1 v1, const char *t2_name, const char *t1_name){
     return true; // passed test
 }
 
+#include "test.hpp"
+#include "test_values.hpp"
+
 #define TEST_CAST(T1, v)              \
     rval = rval && test_cast<T1>(     \
         v,                            \
diff --git a/test/test_compare.cpp b/test/test_compare.cpp
index 7c26a3d..f47cc80 100644
--- a/test/test_compare.cpp
+++ b/test/test_compare.cpp
@@ -37,29 +37,34 @@ bool test_compare_detail(
     char expected_result
 ){
     print_argument_types(v1, v2);
-    if('=' == expected_result){
+    switch(expected_result){
+    case '=': {
         if(! boost::numeric::safe_compare::equal(v1, v2))
             return false;
         if(boost::numeric::safe_compare::less_than(v1, v2))
             return false;
         if(boost::numeric::safe_compare::greater_than(v1, v2))
             return false;
+        break;
     }
-    if('<' == expected_result){
+    case '<': {
         if(! boost::numeric::safe_compare::less_than(v1, v2))
             return false;
         if(boost::numeric::safe_compare::equal(v1, v2))
             return false;
         if(boost::numeric::safe_compare::greater_than(v1, v2))
             return false;
+        break;
     }
-    if('>' == expected_result){
+    case '>':{
         if(! boost::numeric::safe_compare::greater_than(v1, v2))
             return false;
         if(boost::numeric::safe_compare::less_than(v1, v2))
             return false;
         if(boost::numeric::safe_compare::equal(v1, v2))
             return false;
+        break;
+    }
     }
     return true;
 }
diff --git a/test/test_conversion.cpp b/test/test_conversion.cpp
index 040456e..0462538 100644
--- a/test/test_conversion.cpp
+++ b/test/test_conversion.cpp
@@ -7,19 +7,11 @@
 // test construction conversions
 
 #include <iostream>
-#include <cstdlib> // EXIT_SUCCESS
-
-#include <boost/preprocessor/repetition/repeat.hpp>
-#include <boost/preprocessor/array/elem.hpp>
-#include <boost/preprocessor/array/size.hpp>
-#include <boost/preprocessor/stringize.hpp>
+#include <exception>
 
 #include "../include/safe_compare.hpp"
 #include "../include/safe_integer.hpp"
 
-#include "test_types.hpp"
-#include "test_values.hpp"
-
 // test conversion to T2 from different literal types
 template<class T2, class T1>
 bool test_conversion(T1 v1, const char *t2_name, const char *t1_name){
@@ -39,7 +31,7 @@ bool test_conversion(T1 v1, const char *t2_name, const char *t1_name){
             return false;
         }
     }
-    catch(std::range_error e){
+    catch(std::exception & e){
         if(boost::numeric::safe_compare::equal(t2, v1)){
             std::cout
                 << "failed to detect error in construction "
@@ -67,7 +59,7 @@ bool test_conversion(T1 v1, const char *t2_name, const char *t1_name){
             return false;
         }
     }
-    catch(std::range_error e){
+    catch(std::exception & e){
         if(boost::numeric::safe_compare::equal(t2, t1)){
             std::cout
                 << "failed to detect error in construction "
@@ -83,6 +75,15 @@ bool test_conversion(T1 v1, const char *t2_name, const char *t1_name){
     return true; // passed test
 }
 
+#include "test.hpp"
+#include "test_types.hpp"
+#include "test_values.hpp"
+
+#include <boost/preprocessor/repetition/repeat.hpp>
+#include <boost/preprocessor/array/elem.hpp>
+#include <boost/preprocessor/array/size.hpp>
+#include <boost/preprocessor/stringize.hpp>
+
 #define TEST_CONVERSION(T1, v)        \
     test_conversion<T1>(              \
         v,                            \
@@ -105,7 +106,6 @@ bool test_conversion(T1 v1, const char *t2_name, const char *t1_name){
         type_index                                 \
     )                                              \
 /**/
-
 int main(int argc, char *argv[]){
     BOOST_PP_REPEAT(
         BOOST_PP_ARRAY_SIZE(TYPES),
@@ -114,3 +114,4 @@ int main(int argc, char *argv[]){
     )
     return 0;
 }
+
diff --git a/test/test_divide.cpp b/test/test_divide.cpp
index 5837984..fe92f9c 100644
--- a/test/test_divide.cpp
+++ b/test/test_divide.cpp
@@ -5,16 +5,9 @@
 // http://www.boost.org/LICENSE_1_0.txt)
 
 #include <iostream>
-#include <cassert>
 
 #include "../include/safe_integer.hpp"
 
-// we could have used decltype and auto for C++11 but we've decided
-// to use boost/typeof to be compatible with older compilers
-#include <boost/typeof/typeof.hpp>
-
-#include "test.hpp"
-
 template<class T1, class T2>
 bool test_divide(
     T1 v1,
@@ -182,7 +175,6 @@ const char *test_division_result[VALUE_ARRAY_SIZE] = {
     )
 /**/
 
-#define COUNT sizeof(test_multiplication_result)
 int main(int argc, char * argv[]){
     bool rval = true;
     TEST_EACH_VALUE_PAIR
diff --git a/test/test_modulus.cpp b/test/test_modulus.cpp
index 552bd22..916a231 100644
--- a/test/test_modulus.cpp
+++ b/test/test_modulus.cpp
@@ -9,12 +9,6 @@
 
 #include "../include/safe_integer.hpp"
 
-// we could have used decltype and auto for C++11 but we've decided
-// to use boost/typeof to be compatible with older compilers
-#include <boost/typeof/typeof.hpp>
-
-#include "test.hpp"
-
 template<class T1, class T2>
 bool test_modulus(
     T1 v1,
@@ -27,73 +21,83 @@ bool test_modulus(
         << "testing  "
         << av1 << " % " << av2
         << std::endl;
+    {
+        boost::numeric::safe<T1> t1 = v1;
+        // presuming native policy
+        boost::numeric::safe<decltype(v1 + v2)> result;
 
-    boost::numeric::safe<T1> t1 = v1;
-    BOOST_TYPEOF_TPL(T1() / T2()) result;
+        try{
+            result = t1 % v2;
 
-    try{
-        result = t1 % v2;
-
-        if(expected_result != '.'){
-        //if(expected_result == 'x'){
-            std::cout
-                << "failed to detect error in division "
-                << std::hex << result << "(" << std::dec << result << ")"
-                << " ! = "<< av1 << " % " << av2
-                << std::endl;
-            try{
-                result = t1 % v2;
+            static_assert(
+                boost::numeric::is_safe<decltype(t1 + v2)>::value,
+                "Expression failed to return safe type"
+            );
+            
+            if(expected_result != '.'){
+                std::cout
+                    << "failed to detect error in division "
+                    << std::hex << result << "(" << std::dec << result << ")"
+                    << " ! = "<< av1 << " % " << av2
+                    << std::endl;
+                try{
+                    result = t1 % v2;
+                }
+                catch(...){}
+                return false;
+            }
+        }
+        catch(std::exception & e){
+            if(expected_result != 'x'){
+                std::cout
+                    << "erroneously detected error in division "
+                    << std::hex << result << "(" << std::dec << result << ")"
+                    << " == "<< av1 << " % " << av2
+                    << std::endl;
+                try{
+                    t1 % v2;
+                }
+                catch(...){}
+                return false;
             }
-            catch(...){}
-            return false;
         }
     }
-    catch(std::range_error){
-        if(expected_result != 'x'){
-        //if(expected_result == '.'){
-            std::cout
-                << "erroneously detected error in division "
-                << std::hex << result << "(" << std::dec << result << ")"
-                << " == "<< av1 << " % " << av2
-                << std::endl;
-            try{
-                result = t1 % v2;
-            }
-            catch(...){}
-            return false;
-        }
-    }
-    boost::numeric::safe<T2> t2 = v2;
-    try{
-        result = t1 % t2;
+    {
+        boost::numeric::safe<T1> t1 = v1;
+        boost::numeric::safe<T2> t2 = v2;
 
-        if(expected_result != '.'){
-        //if(expected_result == 'x'){
-            std::cout
-                << "failed to detect error in division "
-                << std::hex << result << "(" << std::dec << result << ")"
-                << " ! = "<< av1 << " % " << av2
-                << std::endl;
-            try{
-                result = t1 % t2;
+        // presuming native policy
+        boost::numeric::safe<decltype(v1 + v2)> result;
+
+        try{
+            result = t1 % t2;
+
+            if(expected_result != '.'){
+                std::cout
+                    << "failed to detect error in division "
+                    << std::hex << result << "(" << std::dec << result << ")"
+                    << " ! = "<< av1 << " % " << av2
+                    << std::endl;
+                try{
+                    result = t1 % t2;
+                }
+                catch(...){}
+                return false;
             }
-            catch(...){}
-            return false;
         }
-    }
-    catch(std::range_error){
-        if(expected_result != 'x'){
-        //if(expected_result == '.'){
-            std::cout
-                << "erroneously detected error in division "
-                << std::hex << result << "(" << std::dec << result << ")"
-                << " == "<< av1 << " % " << av2
-                << std::endl;
-            try{
-                result = t1 % t2;
+        catch(std::exception & e){
+            if(expected_result != 'x'){
+                std::cout
+                    << "erroneously detected error in division "
+                    << std::hex << result << "(" << std::dec << result << ")"
+                    << " == "<< av1 << " % " << av2
+                    << std::endl;
+                try{
+                    t1 % t2;
+                }
+                catch(...){}
+                return false;
             }
-            catch(...){}
-            return false;
         }
     }
     return true;
@@ -106,44 +110,44 @@ bool test_modulus(
 // This should be changed for a different architecture or better yet
 // be dynamically adjusted depending on the indicated architecture
 
-const char *test_multiplication_result[VALUE_ARRAY_SIZE] = {
+const char *test_modulus_result[VALUE_ARRAY_SIZE] = {
 //      0       0       0       0
 //      01234567012345670123456701234567
 //      01234567890123456789012345678901
 /* 0*/ "................................",
 /* 1*/ "................................",
-/* 2*/ "...x...x...x...x................",
-/* 3*/ "................................",
+/* 2*/ "........................xxxxxxxx",
+/* 3*/ "........................xxxxxxxx",
 /* 4*/ ".................................",
 /* 5*/ "................................",
-/* 6*/ "...x...x...x...x................",
-/* 7*/ "................................",
+/* 6*/ "........................xxxxxxxx",
+/* 7*/ "........................xxxxxxxx",
 
 /* 8*/ "................................",
 /* 9*/ "................................",
-/*10*/ "...x...x...x...x................",
-/*11*/ "................................",
+/*10*/ "..xx..xx..xx............xxxxxxxx",
+/*11*/ "........................xxxxxxxx",
 /*12*/ "................................",
 /*13*/ "................................",
-/*14*/ "...x...x...x...x................",
-/*15*/ "................................",
+/*14*/ "..xx..xx..xx..xx............xxxx",
+/*15*/ "............................xxxx",
 
 //      0       0       0       0
 //      01234567012345670123456701234567
 //      01234567890123456789012345678901
-/*16*/ "..xx..xx..xx..xx................",
-/*17*/ "..xx..xx..xx..xx................",
-/*18*/ "..xx..xx..xx..xx................",
-/*19*/ "..xx..xx..xx..xx................",
-/*20*/ "..xx..xx..xx..xx................",
-/*21*/ "..xx..xx..xx..xx................",
-/*22*/ "..xx..xx..xx..xx................",
-/*23*/ "..xx..xx..xx..xx................",
+/*16*/ "................................",
+/*17*/ "................................",
+/*18*/ "................................",
+/*19*/ "................................",
+/*20*/ "................................",
+/*21*/ "................................",
+/*22*/ "................................",
+/*23*/ "................................",
 
-/*24*/ "..xx..xx..xx..xx................",
-/*25*/ "..xx..xx..xx..xx................",
-/*26*/ "..xx..xx..xx..xx................",
-/*27*/ "..xx..xx..xx..xx................",
+/*24*/ "..xx..xx..xx....................",
+/*25*/ "..xx..xx..xx....................",
+/*26*/ "..xx..xx..xx....................",
+/*27*/ "..xx..xx..xx....................",
 /*28*/ "..xx..xx..xx..xx................",
 /*29*/ "..xx..xx..xx..xx................",
 /*30*/ "..xx..xx..xx..xx................",
@@ -165,11 +169,11 @@ const char *test_multiplication_result[VALUE_ARRAY_SIZE] = {
     TEST_IMPL(                                     \
         BOOST_PP_ARRAY_ELEM(value_index1, VALUES), \
         BOOST_PP_ARRAY_ELEM(value_index2, VALUES), \
-        test_multiplication_result[value_index1][value_index2] \
+        test_modulus_result[value_index1][value_index2] \
     )
 /**/
 
-#define COUNT sizeof(test_multiplication_result)
+#define COUNT sizeof(test_modulus_result)
 int main(int argc, char * argv[]){
     bool rval = true;
     TEST_EACH_VALUE_PAIR
diff --git a/test/test_types.hpp b/test/test_types.hpp
index 23cd730..47d1c60 100644
--- a/test/test_types.hpp
+++ b/test/test_types.hpp
@@ -8,15 +8,17 @@
 #ifndef test_types_hpp
 #define test_types_hpp
 
+#include <cstdint>
+
 #define TYPES (8, (    \
-    boost::int8_t,     \
-    boost::uint8_t,    \
-    boost::int16_t,    \
-    boost::uint16_t,   \
-    boost::int32_t,    \
-    boost::uint32_t,   \
-    boost::int64_t,    \
-    boost::uint64_t    \
+    std::int8_t,     \
+    std::uint8_t,    \
+    std::int16_t,    \
+    std::uint16_t,   \
+    std::int32_t,    \
+    std::uint32_t,   \
+    std::int64_t,    \
+    std::uint64_t    \
 ))
 
 #endif