Refactor name and remove old implementation

Author: mborland

include/boost/decimal/decimal32.hpp

@@ -954,7 +954,7 @@ constexpr auto operator-(decimal32 lhs, decimal32 rhs) noexcept -> decimal32
     auto exp_rhs {rhs.biased_exponent()};
     detail::normalize(sig_rhs, exp_rhs);
 
-    return detail::new_sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
+    return detail::d32_sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
                                            sig_rhs, exp_rhs, rhs.isneg(),
                                            abs_lhs_bigger);
 }
@@ -984,7 +984,7 @@ 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::new_sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
+    return detail::d32_sub_impl<decimal32>(sig_lhs, exp_lhs, lhs.isneg(),
                                            final_sig_rhs, exp_rhs, (rhs < 0),
                                            abs_lhs_bigger);
 }
@@ -1014,7 +1014,7 @@ constexpr auto operator-(Integer lhs, decimal32 rhs) noexcept
     auto exp_rhs {rhs.biased_exponent()};
     detail::normalize(sig_rhs, exp_rhs);
 
-    return detail::new_sub_impl<decimal32>(final_sig_lhs, exp_lhs, (lhs < 0),
+    return detail::d32_sub_impl<decimal32>(final_sig_lhs, exp_lhs, (lhs < 0),
                                            sig_rhs, exp_rhs, rhs.isneg(),
                                            abs_lhs_bigger);
 }

include/boost/decimal/decimal32_fast.hpp

@@ -820,11 +820,11 @@ constexpr auto operator-(decimal32_fast lhs, decimal32_fast rhs) noexcept -> dec
     }
     #endif
 
-    return detail::new_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) > abs(rhs)
-            );
+    );
 }
 
 template <typename Integer>
@@ -849,7 +849,7 @@ constexpr auto operator-(decimal32_fast lhs, Integer rhs) noexcept
     detail::normalize(sig_rhs, exp_rhs);
     auto final_sig_rhs {static_cast<decimal32_fast::significand_type>(detail::make_positive_unsigned(sig_rhs))};
 
-    return detail::new_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);
@@ -876,11 +876,11 @@ constexpr auto operator-(Integer lhs, decimal32_fast rhs) noexcept
     detail::normalize(sig_lhs, exp_lhs);
     auto final_sig_lhs {static_cast<decimal32_fast::significand_type>(detail::make_positive_unsigned(sig_lhs))};
 
-    return detail::new_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,7 +18,7 @@ namespace decimal {
 namespace detail {
 
 template <typename ReturnType, typename T, typename U>
-BOOST_DECIMAL_FORCE_INLINE constexpr auto new_sub_impl(T lhs_sig, U lhs_exp, bool lhs_sign,
+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
 {
@@ -83,74 +83,6 @@ BOOST_DECIMAL_FORCE_INLINE constexpr auto new_sub_impl(T lhs_sig, U lhs_exp, boo
     return {res_sig, new_exp, new_sign};
 }
 
-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
-{
-    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)};
-
-    if (delta_exp > detail::precision + 1)
-    {
-        // If the difference in exponents is more than the digits of accuracy
-        // we return the larger of the two
-        //
-        // e.g. 1e20 - 1e-20 = 1e20
-        return abs_lhs_bigger ? ReturnType{lhs_sig, lhs_exp, false} :
-                                ReturnType{rhs_sig, rhs_exp, true};
-    }
-
-    // The two numbers can be subtracted together without special handling
-
-    auto& sig_bigger {abs_lhs_bigger ? signed_sig_lhs : signed_sig_rhs};
-    auto& exp_bigger {abs_lhs_bigger ? lhs_exp : rhs_exp};
-    auto& sig_smaller {abs_lhs_bigger ? signed_sig_rhs : signed_sig_lhs};
-    auto& smaller_sign {abs_lhs_bigger ? rhs_sign : lhs_sign};
-
-    if (delta_exp == 1)
-    {
-        sig_bigger *= 10;
-        --delta_exp;
-        --exp_bigger;
-    }
-    else
-    {
-        if (delta_exp >= 2)
-        {
-            sig_bigger *= 100;
-            delta_exp -= 2;
-            exp_bigger -= 2;
-        }
-
-        if (delta_exp > 1)
-        {
-            sig_smaller /= pow10(delta_exp - 1);
-            delta_exp = 1;
-        }
-
-        if (delta_exp == 1)
-        {
-            detail::fenv_round(sig_smaller, smaller_sign);
-        }
-    }
-
-    // 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_exp {abs_lhs_bigger ? lhs_exp : rhs_exp};
-    const auto new_sign {new_sig < 0};
-    const auto res_sig {detail::make_positive_unsigned(new_sig)};
-
-    return {res_sig, new_exp, new_sign};
-}
-
 template <typename ReturnType, BOOST_DECIMAL_INTEGRAL T, BOOST_DECIMAL_INTEGRAL U>
 constexpr auto d64_sub_impl(T lhs_sig, U lhs_exp, bool lhs_sign,
                             T rhs_sig, U rhs_exp, bool rhs_sign,