Merge pull request #693 from cppalliance/sub32

Remove recursive call from 32 bit operator-

Author: mborland

include/boost/decimal/decimal32.hpp

@@ -944,11 +944,6 @@ constexpr auto operator-(decimal32 lhs, decimal32 rhs) noexcept -> decimal32
     }
     #endif
 
-    if (!lhs.isneg() && rhs.isneg())
-    {
-        return lhs + (-rhs);
-    }
-
     const bool abs_lhs_bigger {abs(lhs) > abs(rhs)};
 
     auto sig_lhs {lhs.full_significand()};
@@ -959,9 +954,9 @@ constexpr auto operator-(decimal32 lhs, decimal32 rhs) noexcept -> decimal32
     auto exp_rhs {rhs.biased_exponent()};
     detail::normalize(sig_rhs, exp_rhs);
 
-    return detail::sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
-                                       sig_rhs, exp_rhs, rhs.isneg(),
-                                       abs_lhs_bigger);
+    return detail::d32_sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
+                                           sig_rhs, exp_rhs, rhs.isneg(),
+                                           abs_lhs_bigger);
 }
 
 template <typename Integer>
@@ -978,11 +973,6 @@ constexpr auto operator-(decimal32 lhs, Integer rhs) noexcept
     }
     #endif
 
-    if (!lhs.isneg() && (rhs < 0))
-    {
-        return lhs + detail::make_positive_unsigned(rhs);
-    }
-
     auto sig_rhs {static_cast<promoted_significand_type>(detail::make_positive_unsigned(rhs))};
     const bool abs_lhs_bigger {abs(lhs) > sig_rhs};
 
@@ -994,9 +984,9 @@ constexpr auto operator-(decimal32 lhs, Integer rhs) noexcept
     detail::normalize(sig_rhs, exp_rhs);
     auto final_sig_rhs {static_cast<decimal32::significand_type>(sig_rhs)};
 
-    return detail::sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
-                                       final_sig_rhs, exp_rhs, (rhs < 0),
-                                       abs_lhs_bigger);
+    return detail::d32_sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
+                                           final_sig_rhs, exp_rhs, (rhs < 0),
+                                           abs_lhs_bigger);
 }
 
 template <typename Integer>
@@ -1012,12 +1002,7 @@ constexpr auto operator-(Integer lhs, decimal32 rhs) noexcept
         return rhs;
     }
     #endif
-
-    if (lhs >= 0 && rhs.isneg())
-    {
-        return lhs + (-rhs);
-    }
-
+    
     auto sig_lhs {static_cast<promoted_significand_type>(detail::make_positive_unsigned(lhs))};
     const bool abs_lhs_bigger {sig_lhs > abs(rhs)};
 
@@ -1029,9 +1014,9 @@ constexpr auto operator-(Integer lhs, decimal32 rhs) noexcept
     auto exp_rhs {rhs.biased_exponent()};
     detail::normalize(sig_rhs, exp_rhs);
 
-    return detail::sub_impl<decimal32>(final_sig_lhs, exp_lhs, (lhs < 0),
-                                       sig_rhs, exp_rhs, rhs.isneg(),
-                                       abs_lhs_bigger);
+    return detail::d32_sub_impl<decimal32>(final_sig_lhs, exp_lhs, (lhs < 0),
+                                           sig_rhs, exp_rhs, rhs.isneg(),
+                                           abs_lhs_bigger);
 }
 
 constexpr auto decimal32::operator--() noexcept -> decimal32&

include/boost/decimal/decimal32_fast.hpp

@@ -820,18 +820,11 @@ constexpr auto operator-(decimal32_fast lhs, decimal32_fast rhs) noexcept -> dec
     }
     #endif
 
-    if (!lhs.isneg() && rhs.isneg())
-    {
-        return lhs + (-rhs);
-    }
-
-    const bool abs_lhs_bigger {abs(lhs) > abs(rhs)};
-
-    return detail::sub_impl<decimal32_fast>(
+    return detail::d32_sub_impl<decimal32_fast>(
             lhs.significand_, lhs.biased_exponent(), lhs.sign_,
             rhs.significand_, rhs.biased_exponent(), rhs.sign_,
-            abs_lhs_bigger
-            );
+            abs(lhs) > abs(rhs)
+    );
 }
 
 template <typename Integer>
@@ -850,18 +843,13 @@ constexpr auto operator-(decimal32_fast lhs, Integer rhs) noexcept
 
     auto sig_rhs {static_cast<promoted_significand_type>(detail::make_positive_unsigned(rhs))};
 
-    if (!lhs.isneg() && (rhs < 0))
-    {
-        return lhs + sig_rhs;
-    }
-
     const bool abs_lhs_bigger {abs(lhs) > sig_rhs};
 
     exp_type exp_rhs {0};
     detail::normalize(sig_rhs, exp_rhs);
     auto final_sig_rhs {static_cast<decimal32_fast::significand_type>(detail::make_positive_unsigned(sig_rhs))};
 
-    return detail::sub_impl<decimal32_fast>(
+    return detail::d32_sub_impl<decimal32_fast>(
             lhs.significand_, lhs.biased_exponent(), lhs.sign_,
             final_sig_rhs, exp_rhs, (rhs < 0),
             abs_lhs_bigger);
@@ -881,23 +869,18 @@ constexpr auto operator-(Integer lhs, decimal32_fast rhs) noexcept
     }
     #endif
 
-    if (lhs >= 0 && rhs.isneg())
-    {
-        return lhs + (-rhs);
-    }
-
     auto sig_lhs {static_cast<promoted_significand_type>(detail::make_positive_unsigned(lhs))};
     const bool abs_lhs_bigger {sig_lhs > abs(rhs)};
 
     exp_type exp_lhs {0};
     detail::normalize(sig_lhs, exp_lhs);
     auto final_sig_lhs {static_cast<decimal32_fast::significand_type>(detail::make_positive_unsigned(sig_lhs))};
 
-    return detail::sub_impl<decimal32_fast>(
+    return detail::d32_sub_impl<decimal32_fast>(
             final_sig_lhs, exp_lhs, (lhs < 0),
             rhs.significand_, rhs.biased_exponent(), rhs.sign_,
             abs_lhs_bigger
-            );
+    );
 }
 
 constexpr auto operator*(decimal32_fast lhs, decimal32_fast rhs) noexcept -> decimal32_fast

include/boost/decimal/detail/sub_impl.hpp

@@ -18,15 +18,15 @@ namespace decimal {
 namespace detail {
 
 template <typename ReturnType, typename T, typename U>
-BOOST_DECIMAL_FORCE_INLINE constexpr auto sub_impl(T lhs_sig, U lhs_exp, bool lhs_sign,
-                                                   T rhs_sig, U rhs_exp, bool rhs_sign,
-                                                   bool abs_lhs_bigger) noexcept -> ReturnType
+BOOST_DECIMAL_FORCE_INLINE constexpr auto d32_sub_impl(T lhs_sig, U lhs_exp, bool lhs_sign,
+                                                       T rhs_sig, U rhs_exp, bool rhs_sign,
+                                                       bool abs_lhs_bigger) noexcept -> ReturnType
 {
     using sub_type = std::int_fast32_t;
 
     auto delta_exp {lhs_exp > rhs_exp ? lhs_exp - rhs_exp : rhs_exp - lhs_exp};
-    auto signed_sig_lhs {detail::make_signed_value(lhs_sig, lhs_sign)};
-    auto signed_sig_rhs {detail::make_signed_value(rhs_sig, rhs_sign)};
+    auto signed_sig_lhs {detail::make_signed_value(static_cast<sub_type>(lhs_sig), lhs_sign)};
+    auto signed_sig_rhs {detail::make_signed_value(static_cast<sub_type>(rhs_sig), rhs_sign)};
 
     if (delta_exp > detail::precision + 1)
     {
@@ -74,9 +74,7 @@ BOOST_DECIMAL_FORCE_INLINE constexpr auto sub_impl(T lhs_sig, U lhs_exp, bool lh
 
     // Both of the significands are less than 9'999'999, so we can safely
     // cast them to signed 32-bit ints to calculate the new significand
-    const auto new_sig = (rhs_sign && !lhs_sign) ?
-            static_cast<sub_type>(signed_sig_lhs) + static_cast<sub_type>(signed_sig_rhs) :
-            static_cast<sub_type>(signed_sig_lhs) - static_cast<sub_type>(signed_sig_rhs);
+    const auto new_sig {signed_sig_lhs - signed_sig_rhs};
 
     const auto new_exp {abs_lhs_bigger ? lhs_exp : rhs_exp};
     const auto new_sign {new_sig < 0};