Merge pull request #576 from cppalliance/mixed

Author: mborland

include/boost/decimal/decimal32.hpp

@@ -0,0 +1,98 @@
+// 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_ADD_IMPL_HPP
+#define BOOST_DECIMAL_DETAIL_ADD_IMPL_HPP
+
+#include <boost/decimal/detail/attributes.hpp>
+#include <boost/decimal/detail/apply_sign.hpp>
+#include <boost/decimal/detail/fenv_rounding.hpp>
+
+#ifndef BOOST_DECIMAL_BUILD_MODULE
+#include <cstdint>
+#endif
+
+namespace boost {
+namespace decimal {
+namespace detail {
+
+template <typename ReturnType, typename T1, typename T2>
+constexpr auto add_impl(T1 lhs_sig, std::int32_t lhs_exp, bool lhs_sign,
+                        T2 rhs_sig, std::int32_t rhs_exp, bool rhs_sign) noexcept -> ReturnType
+{
+    const bool sign {lhs_sign};
+
+    auto delta_exp {lhs_exp > rhs_exp ? lhs_exp - rhs_exp : rhs_exp - lhs_exp};
+
+    #ifdef BOOST_DECIMAL_DEBUG_ADD
+    std::cerr << "Starting sig lhs: " << lhs_sig
+              << "\nStarting exp lhs: " << lhs_exp
+              << "\nStarting sig rhs: " << rhs_sig
+              << "\nStarting exp rhs: " << rhs_exp << std::endl;
+    #endif
+
+    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
+
+        #ifdef BOOST_DECIMAL_DEBUG_ADD
+        std::cerr << "New sig: " << lhs_sig
+                  << "\nNew exp: " << lhs_exp
+                  << "\nNew neg: " << lhs_sign << std::endl;
+        #endif
+
+        return {static_cast<std::uint32_t>(lhs_sig), lhs_exp, lhs_sign};
+    }
+
+    // The two numbers can be added together without special handling
+    //
+    // If we can add to the lhs sig rather than dividing we can save some precision
+    // 32-bit signed int can have 9 digits and our normalized significand has 7
+    if (delta_exp <= 2)
+    {
+        lhs_sig *= pow10(static_cast<T1>(delta_exp));
+        lhs_exp -= delta_exp;
+        delta_exp = 0;
+    }
+    else
+    {
+        lhs_sig *= 100;
+        delta_exp -= 2;
+        lhs_exp -=2;
+
+        if (delta_exp > 1)
+        {
+            rhs_sig /= pow10(static_cast<T2>(delta_exp - 1));
+            delta_exp = 1;
+        }
+    }
+
+    if (delta_exp == 1)
+    {
+        detail::fenv_round(rhs_sig, rhs_sign);
+    }
+
+    // Cast the results to signed types so that we can apply a sign at the end if necessary
+    // Both of the significands are maximally 24 bits, so they fit into a 32-bit signed type just fine
+    const auto new_sig {static_cast<std::int32_t>(lhs_sig + rhs_sig)};
+    const auto new_exp {lhs_exp};
+    const auto res_sig {detail::make_positive_unsigned(new_sig)};
+
+    #ifdef BOOST_DECIMAL_DEBUG_ADD
+    std::cerr << "Final sig lhs: " << lhs_sig
+              << "\nFinal sig rhs: " << rhs_sig
+              << "\nResult sig: " << new_sig << std::endl;
+    #endif
+
+    return {res_sig, new_exp, sign};
+}
+
+} // namespace detail
+} // namespace decimal
+} // namespace boost
+
+#endif //BOOST_DECIMAL_DETAIL_ADD_IMPL_HPP

include/boost/decimal/decimal32_fast.hpp

@@ -6,6 +6,7 @@
 #define BOOST_DECIMAL_DETAIL_CMATH_IMPL_FMA_HPP
 
 #include <boost/decimal/decimal32.hpp>
+#include <boost/decimal/decimal32_fast.hpp>
 #include <boost/decimal/decimal64.hpp>
 #include <boost/decimal/decimal128.hpp>
 #include <boost/decimal/detail/config.hpp>
@@ -32,7 +33,7 @@ constexpr auto fmad32(decimal32 x, decimal32 y, decimal32 z) noexcept -> decimal
     auto exp_rhs {y.biased_exponent()};
     detail::normalize(sig_rhs, exp_rhs);
 
-    auto mul_result {mul_impl(sig_lhs, exp_lhs, x.isneg(), sig_rhs, exp_rhs, y.isneg())};
+    auto mul_result {detail::mul_impl<detail::decimal32_components>(sig_lhs, exp_lhs, x.isneg(), sig_rhs, exp_rhs, y.isneg())};
     const decimal32 dec_result {mul_result.sig, mul_result.exp, mul_result.sign};
 
     const auto res_add {detail::check_non_finite(dec_result, z)};

include/boost/decimal/detail/add_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

include/boost/decimal/detail/cmath/fma.hpp

@@ -0,0 +1,68 @@
+// 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_MUL_IMPL_HPP
+#define BOOST_DECIMAL_DETAIL_MUL_IMPL_HPP
+
+#include <boost/decimal/detail/attributes.hpp>
+#include <boost/decimal/detail/apply_sign.hpp>
+#include <boost/decimal/detail/fenv_rounding.hpp>
+
+#ifndef BOOST_DECIMAL_BUILD_MODULE
+#include <cstdint>
+#endif
+
+namespace boost {
+namespace decimal {
+namespace detail {
+
+template <typename ReturnType, typename T1, typename T2>
+constexpr auto mul_impl(T1 lhs_sig, std::int32_t lhs_exp, bool lhs_sign,
+                        T2 rhs_sig, std::int32_t rhs_exp, bool rhs_sign) noexcept -> ReturnType
+{
+    #ifdef BOOST_DECIMAL_DEBUG
+    std::cerr << "sig lhs: " << sig_lhs
+              << "\nexp lhs: " << exp_lhs
+              << "\nsig rhs: " << sig_rhs
+              << "\nexp rhs: " << exp_rhs;
+    #endif
+
+    bool sign {lhs_sign != rhs_sign};
+
+    // Once we have the normalized significands and exponents all we have to do is
+    // multiply the significands and add the exponents
+    //
+    // We use a 64 bit resultant significand because the two 23-bit unsigned significands will always fit
+
+    auto res_sig {static_cast<std::uint64_t>(lhs_sig) * 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 > 9)
+    {
+        res_sig /= detail::pow10(static_cast<std::uint64_t>(sig_dig - 9));
+        res_exp += sig_dig - 9;
+    }
+
+    const auto res_sig_32 {static_cast<typename ReturnType::sig_type>(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;
+    }
+
+    return {res_sig_32, res_exp, sign};
+}
+
+} // namespace detail
+} // namespace decimal
+} // namespace boost
+
+#endif //BOOST_DECIMAL_DETAIL_MUL_IMPL_HPP

include/boost/decimal/detail/div_impl.hpp

@@ -0,0 +1,87 @@
+// 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_SUB_IMPL_HPP
+#define BOOST_DECIMAL_DETAIL_SUB_IMPL_HPP
+
+#include <boost/decimal/detail/shrink_significand.hpp>
+#include <boost/decimal/detail/apply_sign.hpp>
+#include <boost/decimal/detail/fenv_rounding.hpp>
+
+#ifndef BOOST_DECIMAL_BUILD_MODULE
+#include <cstdint>
+#endif
+
+namespace boost {
+namespace decimal {
+namespace detail {
+
+template <typename ReturnType, typename T1, typename T2>
+constexpr auto sub_impl(T1 lhs_sig, std::int32_t lhs_exp, bool lhs_sign,
+                        T2 rhs_sig, std::int32_t rhs_exp, bool rhs_sign,
+                        bool abs_lhs_bigger) noexcept -> ReturnType
+{
+    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{detail::shrink_significand(lhs_sig, lhs_exp), lhs_exp, false} :
+                                ReturnType{detail::shrink_significand(rhs_sig, rhs_exp), 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
+    std::int32_t new_sig = (rhs_sign && !lhs_sign) ?
+            static_cast<std::int32_t>(signed_sig_lhs) + static_cast<std::int32_t>(signed_sig_rhs) :
+            static_cast<std::int32_t>(signed_sig_lhs) - static_cast<std::int32_t>(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};
+}
+
+}
+}
+}
+
+#endif //BOOST_DECIMAL_DETAIL_SUB_IMPL_HPP

include/boost/decimal/detail/mul_impl.hpp

@@ -52,6 +52,7 @@ run link_1.cpp link_2.cpp link_3.cpp ;
 run quick.cpp ;
 run random_decimal32_comp.cpp ;
 run random_decimal32_fast_comp.cpp ;
+run random_decimal32_fast_math.cpp ;
 run random_decimal32_math.cpp ;
 run random_decimal64_comp.cpp ;
 run random_decimal64_math.cpp ;