Implement and refactor mixed type division for 32 bits

Author: mborland

include/boost/decimal/decimal32.hpp

@@ -35,6 +35,7 @@
 #include <boost/decimal/detail/add_impl.hpp>
 #include <boost/decimal/detail/sub_impl.hpp>
 #include <boost/decimal/detail/mul_impl.hpp>
+#include <boost/decimal/detail/div_impl.hpp>
 
 #ifndef BOOST_DECIMAL_BUILD_MODULE
 
@@ -170,8 +171,6 @@ BOOST_DECIMAL_EXPORT class decimal32 final // NOLINT(cppcoreguidelines-special-m
     template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetType, BOOST_DECIMAL_DECIMAL_FLOATING_TYPE Decimal>
     friend constexpr auto to_decimal(Decimal val) noexcept -> TargetType;
 
-    friend constexpr auto generic_div_impl(detail::decimal32_components lhs, detail::decimal32_components rhs,
-                                           detail::decimal32_components& q) noexcept -> void;
     friend constexpr auto div_impl(decimal32 lhs, decimal32 rhs, decimal32& q, decimal32& r) noexcept -> void;
     friend constexpr auto mod_impl(decimal32 lhs, decimal32 rhs, const decimal32& q, decimal32& r) noexcept -> void;
 
@@ -1680,43 +1679,6 @@ constexpr auto decimal32::operator*=(Decimal rhs) noexcept
     return *this;
 }
 
-constexpr auto generic_div_impl(detail::decimal32_components lhs, detail::decimal32_components rhs,
-                                detail::decimal32_components& q) noexcept -> void
-{
-    bool sign {lhs.sign != rhs.sign};
-
-    // If rhs is greater than we need to offset the significands to get the correct values
-    // e.g. 4/8 is 0 but 40/8 yields 5 in integer maths
-    const auto big_sig_lhs {static_cast<std::uint64_t>(lhs.sig) * detail::powers_of_10[detail::precision]};
-    lhs.exp -= detail::precision;
-
-    auto res_sig {big_sig_lhs / static_cast<std::uint64_t>(rhs.sig)};
-    auto res_exp {lhs.exp - rhs.exp};
-
-    const auto sig_dig {detail::num_digits(res_sig)};
-
-    if (sig_dig > std::numeric_limits<std::uint32_t>::digits10)
-    {
-        res_sig /= detail::pow10(static_cast<std::uint64_t>(sig_dig - std::numeric_limits<std::uint32_t>::digits10));
-        res_exp += sig_dig - std::numeric_limits<std::uint32_t>::digits10;
-    }
-
-    const auto res_sig_32 {static_cast<std::uint32_t>(res_sig)};
-
-    #ifdef BOOST_DECIMAL_DEBUG
-    std::cerr << "\nres sig: " << res_sig_32
-              << "\nres exp: " << res_exp << std::endl;
-    #endif
-
-    if (res_sig_32 == 0)
-    {
-        sign = false;
-    }
-
-    // Let the constructor handle shrinking it back down and rounding correctly
-    q = detail::decimal32_components{res_sig_32, res_exp, sign};
-}
-
 constexpr auto div_impl(decimal32 lhs, decimal32 rhs, decimal32& q, decimal32& r) noexcept -> void
 {
     // Check pre-conditions
@@ -1783,7 +1745,7 @@ constexpr auto div_impl(decimal32 lhs, decimal32 rhs, decimal32& q, decimal32& r
     detail::decimal32_components rhs_components {sig_rhs, exp_rhs, rhs.isneg()};
     detail::decimal32_components q_components {};
 
-    generic_div_impl(lhs_components, rhs_components, q_components);
+    detail::generic_div_impl(lhs_components, rhs_components, q_components);
 
     q = decimal32(q_components.sig, q_components.exp, q_components.sign);
 }
@@ -1845,7 +1807,7 @@ constexpr auto operator/(decimal32 lhs, Integer rhs) noexcept
     detail::decimal32_components rhs_components {detail::shrink_significand(detail::make_positive_unsigned(rhs), exp_rhs), exp_rhs, rhs < 0};
     detail::decimal32_components q_components {};
 
-    generic_div_impl(lhs_components, rhs_components, q_components);
+    detail::generic_div_impl(lhs_components, rhs_components, q_components);
 
     return decimal32(q_components.sig, q_components.exp, q_components.sign);
 }
@@ -1888,7 +1850,7 @@ constexpr auto operator/(Integer lhs, decimal32 rhs) noexcept
     detail::decimal32_components rhs_components {sig_rhs, exp_rhs, rhs.isneg()};
     detail::decimal32_components q_components {};
 
-    generic_div_impl(lhs_components, rhs_components, q_components);
+    detail::generic_div_impl(lhs_components, rhs_components, q_components);
 
     return decimal32(q_components.sig, q_components.exp, q_components.sign);
 }

include/boost/decimal/decimal32_fast.hpp

@@ -13,6 +13,7 @@
 #include <boost/decimal/detail/add_impl.hpp>
 #include <boost/decimal/detail/sub_impl.hpp>
 #include <boost/decimal/detail/mul_impl.hpp>
+#include <boost/decimal/detail/div_impl.hpp>
 #include <boost/decimal/detail/ryu/ryu_generic_128.hpp>
 #include <limits>
 #include <cstdint>
@@ -239,6 +240,14 @@ class decimal32_fast final
     friend constexpr auto operator*(Integer lhs, decimal32_fast rhs) noexcept
         BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal32_fast);
 
+    template <typename Integer>
+    friend constexpr auto operator/(decimal32_fast lhs, Integer rhs) noexcept
+        BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal32_fast);
+
+    template <typename Integer>
+    friend constexpr auto operator/(Integer lhs, decimal32_fast rhs) noexcept
+        BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal32_fast);
+
     // Compound operators
     constexpr auto operator+=(decimal32_fast rhs) noexcept -> decimal32_fast&;
     constexpr auto operator-=(decimal32_fast rhs) noexcept -> decimal32_fast&;
@@ -972,6 +981,93 @@ constexpr auto operator/(decimal32_fast lhs, decimal32_fast rhs) noexcept -> dec
     return q;
 }
 
+template <typename Integer>
+constexpr auto operator/(decimal32_fast lhs, Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal32_fast)
+{
+    // Check pre-conditions
+    constexpr decimal32_fast zero {0, 0};
+    constexpr decimal32_fast nan {direct_init(detail::d32_fast_qnan, UINT8_C(0), false)};
+    constexpr decimal32_fast inf {direct_init(detail::d32_fast_inf, UINT8_C(0), false)};
+
+    const bool sign {lhs.isneg() != (rhs < 0)};
+
+    const auto lhs_fp {fpclassify(lhs)};
+
+    switch (lhs_fp)
+    {
+        case FP_NAN:
+            return nan;
+        case FP_INFINITE:
+            return inf;
+        case FP_ZERO:
+            return sign ? -zero : zero;
+        default:
+            static_cast<void>(lhs);
+    }
+
+    if (rhs == 0)
+    {
+        return sign ? -inf : inf;
+    }
+
+    auto sig_lhs {lhs.full_significand()};
+    auto exp_lhs {lhs.biased_exponent()};
+    detail::normalize(sig_lhs, exp_lhs);
+
+    const detail::decimal32_fast_components lhs_components {sig_lhs, exp_lhs, lhs.isneg()};
+    std::int32_t exp_rhs {};
+    const detail::decimal32_fast_components rhs_components {detail::shrink_significand<std::uint_fast32_t>(detail::make_positive_unsigned(rhs), exp_rhs), exp_rhs, rhs < 0};
+    detail::decimal32_fast_components q_components {};
+
+    detail::generic_div_impl(lhs_components, rhs_components, q_components);
+
+    return {q_components.sig, q_components.exp, q_components.sign};
+}
+
+template <typename Integer>
+constexpr auto operator/(Integer lhs, decimal32_fast rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, decimal32_fast)
+{
+    // Check pre-conditions
+    constexpr decimal32_fast zero {0, 0};
+    constexpr decimal32_fast nan {direct_init(detail::d32_fast_qnan, UINT8_C(0), false)};
+    constexpr decimal32_fast inf {direct_init(detail::d32_fast_inf, UINT8_C(0), false)};
+
+    const bool sign {(lhs < 0) != rhs.isneg()};
+
+    const auto rhs_fp {fpclassify(rhs)};
+
+    if (rhs_fp == FP_NAN)
+    {
+        return nan;
+    }
+
+    switch (rhs_fp)
+    {
+        case FP_INFINITE:
+            return sign ? -zero : zero;
+        case FP_ZERO:
+            return sign ? -inf : inf;
+        default:
+            static_cast<void>(lhs);
+    }
+
+    auto sig_rhs {rhs.full_significand()};
+    auto exp_rhs {rhs.biased_exponent()};
+    detail::normalize(sig_rhs, exp_rhs);
+
+    std::int32_t lhs_exp {};
+    const auto lhs_sig {detail::make_positive_unsigned(detail::shrink_significand<std::uint_fast32_t>(lhs, lhs_exp))};
+    const detail::decimal32_fast_components lhs_components {lhs_sig, lhs_exp, lhs < 0};
+    const detail::decimal32_fast_components rhs_components {sig_rhs, exp_rhs, rhs.isneg()};
+    detail::decimal32_fast_components q_components {};
+
+    detail::generic_div_impl(lhs_components, rhs_components, q_components);
+
+    return {q_components.sig, q_components.exp, q_components.sign};
+}
+
 constexpr auto operator%(decimal32_fast lhs, decimal32_fast rhs) noexcept -> decimal32_fast
 {
     decimal32_fast q {};

include/boost/decimal/detail/div_impl.hpp

@@ -0,0 +1,57 @@
+// Copyright 2023 - 2024 Matt Borland
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+
+#ifndef BOOST_DECIMAL_DETAIL_DIV_IMPL_HPP
+#define BOOST_DECIMAL_DETAIL_DIV_IMPL_HPP
+
+#ifndef BOOST_DECIMAL_BUILD_MODULE
+#include <limits>
+#include <cstdint>
+#endif
+
+namespace boost {
+namespace decimal {
+namespace detail {
+
+template <typename T>
+constexpr auto generic_div_impl(const T& lhs, const T& rhs, T& q) noexcept -> void
+{
+    bool sign {lhs.sign != rhs.sign};
+
+    // If rhs is greater than we need to offset the significands to get the correct values
+    // e.g. 4/8 is 0 but 40/8 yields 5 in integer maths
+    const auto big_sig_lhs {static_cast<std::uint64_t>(lhs.sig) * detail::pow10(detail::precision)};
+
+    auto res_sig {big_sig_lhs / static_cast<std::uint64_t>(rhs.sig)};
+    auto res_exp {(lhs.exp - detail::precision) - rhs.exp};
+
+    const auto sig_dig {detail::num_digits(res_sig)};
+
+    if (sig_dig > std::numeric_limits<std::uint32_t>::digits10)
+    {
+        res_sig /= detail::pow10(static_cast<std::uint64_t>(sig_dig - std::numeric_limits<std::uint32_t>::digits10));
+        res_exp += sig_dig - std::numeric_limits<std::uint32_t>::digits10;
+    }
+
+    const auto res_sig_32 {static_cast<std::uint32_t>(res_sig)};
+
+    #ifdef BOOST_DECIMAL_DEBUG
+    std::cerr << "\nres sig: " << res_sig_32
+              << "\nres exp: " << res_exp << std::endl;
+    #endif
+
+    if (res_sig_32 == 0)
+    {
+        sign = false;
+    }
+
+    // Let the constructor handle shrinking it back down and rounding correctly
+    q = T{res_sig_32, res_exp, sign};
+}
+
+} // namespace detail
+} // namespace decimal
+} // namespace boost
+
+#endif //BOOST_DECIMAL_DETAIL_DIV_IMPL_HPP

test/random_decimal32_fast_math.cpp

@@ -946,30 +946,30 @@ int main()
     random_division(0L, 5'000L);
     random_division(0LL, 5'000LL);
     random_division(0, sqrt_int_max);
-    //random_mixed_division(0, 5'000);
-    //random_mixed_division(0L, 5'000L);
-    //random_mixed_division(0LL, 5'000LL);
-    //random_mixed_division(0, sqrt_int_max);
+    random_mixed_division(0, 5'000);
+    random_mixed_division(0L, 5'000L);
+    random_mixed_division(0LL, 5'000LL);
+    random_mixed_division(0, sqrt_int_max);
 
     // Only negative values
     random_division(-5'000, 0);
     random_division(-5'000L, 0L);
     random_division(-5'000LL, 0LL);
     random_division(-sqrt_int_max, 0);
-    //random_mixed_division(-5'000, 0);
-    //random_mixed_division(-5'000L, 0L);
-    //random_mixed_division(-5'000LL, 0LL);
-    //random_mixed_division(-sqrt_int_max, 0);
+    random_mixed_division(-5'000, 0);
+    random_mixed_division(-5'000L, 0L);
+    random_mixed_division(-5'000LL, 0LL);
+    random_mixed_division(-sqrt_int_max, 0);
 
     // Mixed values
     random_division(-5'000, 5'000);
     random_division(-5'000L, 5'000L);
     random_division(-5'000LL, 5'000LL);
     random_division(-sqrt_int_max, sqrt_int_max);
-    //random_mixed_division(-5'000, 5'000);
-    //random_mixed_division(-5'000L, 5'000L);
-    //random_mixed_division(-5'000LL, 5'000LL);
-    //random_mixed_division(-sqrt_int_max, sqrt_int_max);
+    random_mixed_division(-5'000, 5'000);
+    random_mixed_division(-5'000L, 5'000L);
+    random_mixed_division(-5'000LL, 5'000LL);
+    random_mixed_division(-sqrt_int_max, sqrt_int_max);
 
     /*
     // Bitwise operators