Merge pull request #1132 from cppalliance/1106

Fix `decimal_fast32_t` escaping it's domain in mul and div

Author: mborland

include/boost/decimal/decimal_fast32_t.hpp

@@ -121,6 +121,9 @@ BOOST_DECIMAL_EXPORT class decimal_fast32_t final
     template <typename ReturnType, typename T>
     friend constexpr auto detail::add_impl(const T& lhs, const T& rhs) noexcept -> ReturnType;
 
+    template <typename ReturnType, typename T>
+    friend constexpr auto detail::mul_impl(const T& lhs, const T& rhs) noexcept -> ReturnType;
+
     template <BOOST_DECIMAL_FAST_DECIMAL_FLOATING_TYPE DecimalType>
     BOOST_DECIMAL_FORCE_INLINE friend constexpr auto fast_equality_impl(const DecimalType& lhs, const DecimalType& rhs) noexcept -> bool;
 
@@ -144,6 +147,9 @@ BOOST_DECIMAL_EXPORT class decimal_fast32_t final
     template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE TargetDecimalType>
     friend constexpr auto detail::to_chars_hex_impl(char* first, char* last, const TargetDecimalType& value) noexcept -> to_chars_result;
 
+    template <typename DecimalType, typename T>
+    friend constexpr auto detail::generic_div_impl(const T& lhs, const T& rhs) noexcept -> DecimalType;
+
 public:
     constexpr decimal_fast32_t() noexcept = default;
 
@@ -413,7 +419,7 @@ constexpr decimal_fast32_t::decimal_fast32_t(T1 coeff, T2 exp, bool sign) noexce
     sign_ = sign;
 
     // Normalize in the constructor, so we never have to worry about it again
-    detail::normalize<decimal32_t>(min_coeff, exp, sign);
+    detail::normalize<decimal_fast32_t>(min_coeff, exp, sign);
 
     significand_ = static_cast<significand_type>(min_coeff);
 
@@ -902,26 +908,7 @@ constexpr auto operator*(const decimal_fast32_t lhs, const decimal_fast32_t rhs)
     }
     #endif
 
-    using mul_type = std::uint_fast64_t;
-
-    const auto isneg {lhs.sign_ != rhs.sign_};
-    constexpr auto ten_pow_seven {detail::pow10(static_cast<mul_type>(6))};
-    constexpr auto ten_pow_seven_exp_offset {95};
-    constexpr auto ten_pow_six {detail::pow10(static_cast<mul_type>(5))};
-    constexpr auto ten_pow_six_exp_offset {96};
-
-    auto res_sig {(static_cast<mul_type>(lhs.significand_) * static_cast<mul_type>(rhs.significand_))};
-    const bool res_sig_14_dig {res_sig > UINT64_C(10000000000000)};
-    res_sig /= res_sig_14_dig ? ten_pow_seven : ten_pow_six;
-    auto res_exp {lhs.exponent_ + rhs.exponent_};
-    res_exp -= res_sig_14_dig ? ten_pow_seven_exp_offset : ten_pow_six_exp_offset;
-
-    res_exp += detail::fenv_round<decimal_fast32_t>(res_sig, isneg);
-
-    BOOST_DECIMAL_ASSERT(res_sig >= 1'000'000 || res_sig == 0U);
-    BOOST_DECIMAL_ASSERT(res_exp <= 9'999'999 || res_sig == 0U);
-
-    return direct_init(static_cast<decimal_fast32_t::significand_type>(res_sig), static_cast<decimal_fast32_t::exponent_type>(res_exp) , isneg);
+    return detail::mul_impl<decimal_fast32_t>(lhs, rhs);
 }
 
 template <typename Integer>
@@ -959,9 +946,9 @@ constexpr auto operator*(const Integer lhs, const decimal_fast32_t rhs) noexcept
 
 constexpr auto div_impl(const decimal_fast32_t lhs, const decimal_fast32_t rhs, decimal_fast32_t& q, decimal_fast32_t& r) noexcept -> void
 {
-    constexpr decimal_fast32_t zero {0, 0};
-    
     #ifndef BOOST_DECIMAL_FAST_MATH
+    constexpr decimal_fast32_t zero {0, 0};
+
     const bool sign {lhs.isneg() != rhs.isneg()};
     constexpr decimal_fast32_t nan {direct_init(detail::d32_fast_qnan, UINT8_C(0), false)};
     constexpr decimal_fast32_t inf {direct_init(detail::d32_fast_inf, UINT8_C(0), false)};
@@ -1007,43 +994,7 @@ constexpr auto div_impl(const decimal_fast32_t lhs, const decimal_fast32_t rhs,
     static_cast<void>(r);
     #endif
 
-    #ifdef BOOST_DECIMAL_DEBUG
-    std::cerr << "sig lhs: " << sig_lhs
-              << "\nexp lhs: " << exp_lhs
-              << "\nsig rhs: " << sig_rhs
-              << "\nexp rhs: " << exp_rhs << std::endl;
-    #endif
-
-    using local_signed_exponent_type = std::common_type_t<std::int_fast32_t, int>;
-
-    static_assert(sizeof(local_signed_exponent_type) >= 4, "Error in local exponent type definition");
-
-    // We promote to uint64 since the significands are currently 32-bits
-    // By appending enough zeros to the LHS we end up finding what we need anyway
-    constexpr auto ten_pow_precision {detail::pow10(static_cast<std::uint_fast64_t>(detail::precision_v<decimal32_t>))};
-    const auto big_sig_lhs {static_cast<std::uint_fast64_t>(lhs.significand_) * ten_pow_precision};
-    auto res_sig {big_sig_lhs / static_cast<std::uint_fast64_t>(rhs.significand_)};
-    local_signed_exponent_type res_exp {static_cast<local_signed_exponent_type>(lhs.exponent_) - static_cast<local_signed_exponent_type>(rhs.exponent_) + 94};
-    const auto isneg {lhs.sign_ != rhs.sign_};
-
-    // If we have 8 figures round it down to 7
-    if (res_sig >= UINT64_C(10'000'000))
-    {
-        res_exp += detail::fenv_round<decimal_fast32_t>(res_sig, isneg);
-    }
-
-    BOOST_DECIMAL_ASSERT(res_sig >= 1'000'000 || res_sig == 0U);
-    BOOST_DECIMAL_ASSERT(res_exp <= 9'999'999 || res_sig == 0U);
-
-    if (BOOST_DECIMAL_LIKELY(res_exp >= 0))
-    {
-        q = direct_init(static_cast<decimal_fast32_t::significand_type>(res_sig), static_cast<decimal_fast32_t::exponent_type>(res_exp), isneg);
-    }
-    else
-    {
-        // Flush to zero
-        q = zero;
-    }
+    q = detail::generic_div_impl<decimal_fast32_t>(lhs, rhs);
 }
 
 constexpr auto mod_impl(const decimal_fast32_t lhs, const decimal_fast32_t rhs, const decimal_fast32_t& q, decimal_fast32_t& r) noexcept -> void

include/boost/decimal/detail/div_impl.hpp

@@ -32,13 +32,13 @@ BOOST_DECIMAL_FORCE_INLINE constexpr auto generic_div_impl(const T& lhs, const T
     constexpr auto precision_offset {std::numeric_limits<div_type>::digits10 - precision};
     constexpr auto ten_pow_offset {detail::pow10(static_cast<div_type>(precision_offset))};
 
-    const auto big_sig_lhs {lhs.sig * ten_pow_offset};
+    const auto big_sig_lhs {lhs.full_significand() * ten_pow_offset};
 
-    const auto res_sig {big_sig_lhs / rhs.sig};
-    const auto res_exp {(lhs.exp - precision_offset) - rhs.exp};
+    const auto res_sig {big_sig_lhs / rhs.full_significand()};
+    const auto res_exp {(lhs.biased_exponent() - precision_offset) - rhs.biased_exponent()};
 
     // Normalizes sign handling
-    bool sign {lhs.sign != rhs.sign};
+    bool sign {lhs.isneg() != rhs.isneg()};
     if (BOOST_DECIMAL_UNLIKELY(res_sig == 0U))
     {
         sign = false;

test/Jamfile

@@ -70,6 +70,7 @@ run github_issue_1057.cpp ;
 compile-fail github_issue_1087.cpp ;
 run github_issue_1091.cpp ;
 run github_issue_1094.cpp ;
+run github_issue_1106.cpp ;
 run github_issue_1110.cpp ;
 run github_issue_1112.cpp ;
 

test/github_issue_1106.cpp

@@ -0,0 +1,49 @@
+// Copyright 2025 Matt Borland
+// Distributed under the Boost Software License, Version 1.0.
+// https://www.boost.org/LICENSE_1_0.txt
+//
+// See: https://github.com/cppalliance/decimal/issues/1094
+
+#include <boost/decimal.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <limits>
+#include <cmath>
+
+using namespace boost::decimal;
+
+template <typename T>
+void test()
+{
+    using std::isinf;
+    using std::signbit;
+
+    const auto a {std::numeric_limits<T>::lowest() / 99};
+    const T b {100};
+    const auto c {a * b};
+
+    BOOST_TEST(isinf(c));
+    BOOST_TEST(signbit(c));
+
+    // The same as above in principle 
+    const auto d {a / (1/b)};
+    BOOST_TEST(isinf(d));
+    BOOST_TEST(signbit(d));
+}
+
+int main()
+{
+    #ifndef _MSC_VER
+    test<float>();
+    test<double>();
+    #endif
+
+    test<decimal32_t>();
+    test<decimal64_t>();
+    test<decimal128_t>();
+
+    test<decimal_fast32_t>();
+    test<decimal_fast64_t>();
+    test<decimal_fast128_t>();
+
+    return boost::report_errors();
+}