Implement support for 7.2.b

Author: mborland

include/boost/decimal/decimal128_t.hpp

@@ -1658,19 +1658,21 @@ constexpr auto operator*(const decimal128_t& lhs, const decimal128_t& rhs) noexc
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (not_finite(lhs) || not_finite(rhs))
     {
+        if ((isinf(lhs) && rhs == 0) || (isinf(rhs) && lhs == 0))
+        {
+            return from_bits(detail::d128_nan_mask);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
 
-    const auto lhs_sig {lhs.full_significand()};
-    const auto lhs_exp {lhs.biased_exponent()};
-
-    const auto rhs_sig {rhs.full_significand()};
-    const auto rhs_exp {rhs.biased_exponent()};
+    const auto lhs_components {lhs.to_components()};
+    const auto rhs_components {rhs.to_components()};
 
     return detail::d128_mul_impl<decimal128_t>(
-            lhs_sig, lhs_exp, lhs.isneg(),
-            rhs_sig, rhs_exp, rhs.isneg());
+            lhs_components.sig, lhs_components.exp, lhs_components.sign,
+            rhs_components.sig, rhs_components.exp, rhs_components.sign);
 }
 
 template <typename Integer>

include/boost/decimal/decimal32_t.hpp

@@ -1657,6 +1657,11 @@ constexpr auto operator*(const decimal32_t lhs, const decimal32_t rhs) noexcept
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (!isfinite(lhs) || !isfinite(rhs))
     {
+        if ((isinf(lhs) && rhs == 0) || (isinf(rhs) && lhs == 0))
+        {
+            return from_bits(detail::d32_nan_mask);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif

include/boost/decimal/decimal64_t.hpp

@@ -1355,16 +1355,19 @@ constexpr auto operator*(const decimal64_t lhs, const decimal64_t rhs) noexcept
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (not_finite(lhs) || not_finite(rhs))
     {
+        if ((isinf(lhs) && rhs == 0) || (isinf(rhs) && lhs == 0))
+        {
+            return from_bits(detail::d64_nan_mask);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
 
-    auto lhs_components {lhs.to_components()};
-    detail::expand_significand<decimal64_t>(lhs_components.sig, lhs_components.exp);
-    auto rhs_components {rhs.to_components()};
-    detail::expand_significand<decimal64_t>(rhs_components.sig, rhs_components.exp);
+    const auto lhs_components {lhs.to_components()};
+    const auto rhs_components {rhs.to_components()};
 
-    return detail::d64_mul_impl<decimal64_t>(lhs_components, rhs_components);
+    return detail::mul_impl<decimal64_t>(lhs_components, rhs_components);
 }
 
 template <typename Integer>

include/boost/decimal/decimal_fast128_t.hpp

@@ -1036,6 +1036,11 @@ constexpr auto operator*(const decimal_fast128_t& lhs, const decimal_fast128_t&
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (not_finite(lhs) || not_finite(rhs))
     {
+        if ((isinf(lhs) && rhs == 0) || (isinf(rhs) && lhs == 0))
+        {
+            return direct_init_d128(detail::d128_fast_qnan, 0, false);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif

include/boost/decimal/decimal_fast32_t.hpp

@@ -1006,6 +1006,11 @@ constexpr auto operator*(const decimal_fast32_t lhs, const decimal_fast32_t rhs)
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (!isfinite(lhs) || !isfinite(rhs))
     {
+        if ((isinf(lhs) && rhs == 0) || (isinf(rhs) && lhs == 0))
+        {
+            return direct_init(detail::d32_fast_qnan, UINT8_C(0));
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif

include/boost/decimal/decimal_fast64_t.hpp

@@ -1129,6 +1129,11 @@ constexpr auto operator*(const decimal_fast64_t lhs, const decimal_fast64_t rhs)
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (not_finite(lhs) || not_finite(rhs))
     {
+        if ((isinf(lhs) && rhs == 0) || (isinf(rhs) && lhs == 0))
+        {
+            return direct_init_d64(detail::d64_fast_qnan, 0, false);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif

test/github_issue_1107.cpp

@@ -21,6 +21,9 @@ void test_mul()
     const T a {dist(rng) * 0};
     const T b {dist(rng) * std::numeric_limits<T>::infinity()};
 
+    BOOST_TEST(a == 0);
+    BOOST_TEST(isinf(b));
+
     BOOST_TEST(isnan(a * b));
     BOOST_TEST(isnan(b * a));
 }
@@ -65,7 +68,7 @@ int main()
     test_mul<decimal_fast32_t>();
     test_mul<decimal_fast64_t>();
     test_mul<decimal_fast128_t>();
-    
+
     test_sqrt<decimal32_t>();
     test_sqrt<decimal64_t>();
     test_sqrt<decimal128_t>();