diff --git a/include/boost/decimal/decimal128_t.hpp b/include/boost/decimal/decimal128_t.hpp
index 7aeb9ce81..41c7bfcfd 100644
--- a/include/boost/decimal/decimal128_t.hpp
+++ b/include/boost/decimal/decimal128_t.hpp
@@ -1429,8 +1429,8 @@ constexpr auto d128_div_impl(const decimal128_t& lhs, const decimal128_t& rhs, d
     #ifndef BOOST_DECIMAL_FAST_MATH
     // Check pre-conditions
     constexpr decimal128_t zero {0, 0};
-    constexpr decimal128_t nan {boost::decimal::from_bits(boost::decimal::detail::d128_snan_mask)};
-    constexpr decimal128_t inf {boost::decimal::from_bits(boost::decimal::detail::d128_inf_mask)};
+    constexpr decimal128_t nan {from_bits(detail::d128_nan_mask)};
+    constexpr decimal128_t inf {from_bits(detail::d128_inf_mask)};
 
     const bool sign {lhs.isneg() != rhs.isneg()};
 
@@ -1447,12 +1447,28 @@ constexpr auto d128_div_impl(const decimal128_t& lhs, const decimal128_t& rhs, d
     switch (lhs_fp)
     {
         case FP_INFINITE:
-            q = sign ? -inf : inf;
-            r = zero;
+            if (rhs_fp == FP_INFINITE)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -inf : inf;
+                r = zero;
+            }
             return;
         case FP_ZERO:
-            q = sign ? -zero : zero;
-            r = sign ? -zero : zero;
+            if (rhs_fp == FP_ZERO)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -zero : zero;
+                r = sign ? -zero : zero;
+            }
             return;
         default:
             static_cast<void>(lhs);
@@ -1509,6 +1525,11 @@ 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) && isinf(rhs) && signbit(lhs) != signbit(rhs))
+        {
+            return from_bits(detail::d128_nan_mask);
+        }
+        
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1567,6 +1588,11 @@ 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) && isinf(rhs) && signbit(lhs) == signbit(rhs))
+        {
+            return from_bits(detail::d128_nan_mask);
+        }
+        
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1648,19 +1674,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>
diff --git a/include/boost/decimal/decimal32_t.hpp b/include/boost/decimal/decimal32_t.hpp
index c672c4aa0..18963f799 100644
--- a/include/boost/decimal/decimal32_t.hpp
+++ b/include/boost/decimal/decimal32_t.hpp
@@ -875,6 +875,12 @@ constexpr auto operator+(const decimal32_t lhs, const decimal32_t rhs) noexcept
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (!isfinite(lhs) || !isfinite(rhs))
     {
+        // Case from 7.2.d
+        if (isinf(lhs) && isinf(rhs) && signbit(lhs) != signbit(rhs))
+        {
+            return from_bits(detail::d32_nan_mask);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -968,6 +974,12 @@ constexpr auto operator-(const decimal32_t lhs, const decimal32_t rhs) noexcept
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (!isfinite(lhs) || !isfinite(rhs))
     {
+        // Case from 7.2.d
+        if (isinf(lhs) && isinf(rhs) && signbit(lhs) == signbit(rhs))
+        {
+            return from_bits(detail::d32_nan_mask);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1645,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
@@ -1716,8 +1733,8 @@ constexpr auto div_impl(const decimal32_t lhs, const decimal32_t rhs, decimal32_
     #ifndef BOOST_DECIMAL_FAST_MATH
     // Check pre-conditions
     constexpr decimal32_t zero {0, 0};
-    constexpr decimal32_t nan {boost::decimal::from_bits(boost::decimal::detail::d32_snan_mask)};
-    constexpr decimal32_t inf {boost::decimal::from_bits(boost::decimal::detail::d32_inf_mask)};
+    constexpr decimal32_t nan {from_bits(detail::d32_nan_mask)};
+    constexpr decimal32_t inf {from_bits(detail::d32_inf_mask)};
 
     const bool sign {lhs.isneg() != rhs.isneg()};
 
@@ -1734,12 +1751,28 @@ constexpr auto div_impl(const decimal32_t lhs, const decimal32_t rhs, decimal32_
     switch (lhs_fp)
     {
         case FP_INFINITE:
-            q = sign ? -inf : inf;
-            r = zero;
+            if (rhs_fp == FP_INFINITE)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -inf : inf;
+                r = zero;
+            }
             return;
         case FP_ZERO:
-            q = sign ? -zero : zero;
-            r = sign ? -zero : zero;
+            if (rhs_fp == FP_ZERO)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -zero : zero;
+                r = sign ? -zero : zero;
+            }
             return;
         default:
             static_cast<void>(lhs);
diff --git a/include/boost/decimal/decimal64_t.hpp b/include/boost/decimal/decimal64_t.hpp
index 52832b3f3..7391c5730 100644
--- a/include/boost/decimal/decimal64_t.hpp
+++ b/include/boost/decimal/decimal64_t.hpp
@@ -1125,6 +1125,250 @@ BOOST_DECIMAL_FORCE_INLINE constexpr auto not_finite(const decimal64_t rhs) noex
     #endif
 }
 
+constexpr auto operator==(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
+{
+    return equality_impl(lhs, rhs);
+}
+
+template <typename Integer>
+constexpr auto operator==(const decimal64_t lhs, const Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    return mixed_equality_impl(lhs, rhs);
+}
+
+template <typename Integer>
+constexpr auto operator==(const Integer lhs, const decimal64_t rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    return mixed_equality_impl(rhs, lhs);
+}
+
+constexpr auto operator!=(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
+{
+    return !(lhs == rhs);
+}
+
+template <typename Integer>
+constexpr auto operator!=(const decimal64_t lhs, const Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    return !(lhs == rhs);
+}
+
+template <typename Integer>
+constexpr auto operator!=(const Integer lhs, const decimal64_t rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    return !(lhs == rhs);
+}
+
+constexpr auto operator<(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (not_finite(lhs) || not_finite(rhs))
+    {
+        if (isnan(lhs) || isnan(rhs) ||
+            (!lhs.isneg() && rhs.isneg()))
+        {
+            return false;
+        }
+        if (lhs.isneg() && !rhs.isneg())
+        {
+            return true;
+        }
+        if (isfinite(lhs) && isinf(rhs))
+        {
+            return !rhs.isneg();
+        }
+    }
+    #endif
+
+    return sequential_less_impl(lhs, rhs);
+}
+
+template <typename Integer>
+constexpr auto operator<(const decimal64_t lhs, const Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    return less_impl(lhs, rhs);
+}
+
+template <typename Integer>
+constexpr auto operator<(const Integer lhs, const decimal64_t rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (isnan(rhs))
+    {
+        return false;
+    }
+    #endif
+
+    return !less_impl(rhs, lhs) && lhs != rhs;
+}
+
+constexpr auto operator<=(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (isnan(lhs) || isnan(rhs))
+    {
+        return false;
+    }
+    #endif
+
+    return !(rhs < lhs);
+}
+
+template <typename Integer>
+constexpr auto operator<=(const decimal64_t lhs, const Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (isnan(lhs))
+    {
+        return false;
+    }
+    #endif
+
+    return !(rhs < lhs);
+}
+
+template <typename Integer>
+constexpr auto operator<=(const Integer lhs, const decimal64_t rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (isnan(rhs))
+    {
+        return false;
+    }
+    #endif
+
+    return !(rhs < lhs);
+}
+
+constexpr auto operator>(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
+{
+    return rhs < lhs;
+}
+
+template <typename Integer>
+constexpr auto operator>(const decimal64_t lhs, const Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    return rhs < lhs;
+}
+
+template <typename Integer>
+constexpr auto operator>(const Integer lhs, const decimal64_t rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    return rhs < lhs;
+}
+
+constexpr auto operator>=(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (isnan(lhs) || isnan(rhs))
+    {
+        return false;
+    }
+    #endif
+
+    return !(lhs < rhs);
+}
+
+template <typename Integer>
+constexpr auto operator>=(const decimal64_t lhs, const Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (isnan(lhs))
+    {
+        return false;
+    }
+    #endif
+
+    return !(lhs < rhs);
+}
+
+template <typename Integer>
+constexpr auto operator>=(const Integer lhs, const decimal64_t rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
+{
+    #ifndef BOOST_DECIMAL_FAST_MATH
+    if (isnan(rhs))
+    {
+        return false;
+    }
+    #endif
+
+    return !(lhs < rhs);
+}
+
+#ifdef BOOST_DECIMAL_HAS_SPACESHIP_OPERATOR
+
+constexpr auto operator<=>(const decimal64_t lhs, const decimal64_t rhs) noexcept -> std::partial_ordering
+{
+    if (lhs < rhs)
+    {
+        return std::partial_ordering::less;
+    }
+    else if (lhs > rhs)
+    {
+        return std::partial_ordering::greater;
+    }
+    else if (lhs == rhs)
+    {
+        return std::partial_ordering::equivalent;
+    }
+
+    return std::partial_ordering::unordered;
+}
+
+template <typename Integer>
+constexpr auto operator<=>(const decimal64_t lhs, const Integer rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, std::partial_ordering)
+{
+    if (lhs < rhs)
+    {
+        return std::partial_ordering::less;
+    }
+    else if (lhs > rhs)
+    {
+        return std::partial_ordering::greater;
+    }
+    else if (lhs == rhs)
+    {
+        return std::partial_ordering::equivalent;
+    }
+
+    return std::partial_ordering::unordered;
+}
+
+template <typename Integer>
+constexpr auto operator<=>(const Integer lhs, const decimal64_t rhs) noexcept
+    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, std::partial_ordering)
+{
+    if (lhs < rhs)
+    {
+        return std::partial_ordering::less;
+    }
+    else if (lhs > rhs)
+    {
+        return std::partial_ordering::greater;
+    }
+    else if (lhs == rhs)
+    {
+        return std::partial_ordering::equivalent;
+    }
+
+    return std::partial_ordering::unordered;
+}
+
+#endif
+
 constexpr auto operator+(const decimal64_t rhs) noexcept -> decimal64_t
 {
     return rhs;
@@ -1143,8 +1387,8 @@ constexpr auto d64_div_impl(const decimal64_t lhs, const decimal64_t rhs, decima
     #ifndef BOOST_DECIMAL_FAST_MATH
     // Check pre-conditions
     constexpr decimal64_t zero {0, 0};
-    constexpr decimal64_t nan {boost::decimal::from_bits(boost::decimal::detail::d64_snan_mask)};
-    constexpr decimal64_t inf {boost::decimal::from_bits(boost::decimal::detail::d64_inf_mask)};
+    constexpr decimal64_t nan {from_bits(detail::d64_nan_mask)};
+    constexpr decimal64_t inf {from_bits(detail::d64_inf_mask)};
 
     const auto lhs_fp {fpclassify(lhs)};
     const auto rhs_fp {fpclassify(rhs)};
@@ -1159,12 +1403,28 @@ constexpr auto d64_div_impl(const decimal64_t lhs, const decimal64_t rhs, decima
     switch (lhs_fp)
     {
         case FP_INFINITE:
-            q = sign ? -inf : inf;
-            r = zero;
+            if (lhs_fp == FP_INFINITE)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -inf : inf;
+                r = zero;
+            }
             return;
         case FP_ZERO:
-            q = sign ? -zero : zero;
-            r = sign ? -zero : zero;
+            if (rhs_fp == FP_ZERO)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -zero : zero;
+                r = sign ? -zero : zero;
+            }
             return;
         default:
             static_cast<void>(lhs);
@@ -1215,6 +1475,11 @@ 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) && isinf(rhs) && signbit(lhs) != signbit(rhs))
+        {
+            return from_bits(detail::d64_nan_mask);
+        }
+        
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1269,6 +1534,11 @@ 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) && isinf(rhs) && signbit(lhs) == signbit(rhs))
+        {
+            return from_bits(detail::d64_nan_mask);
+        }
+        
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1345,16 +1615,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>
@@ -1624,250 +1897,6 @@ constexpr auto decimal64_t::operator%=(const decimal64_t rhs) noexcept -> decima
     return *this;
 }
 
-constexpr auto operator==(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
-{
-    return equality_impl(lhs, rhs);
-}
-
-template <typename Integer>
-constexpr auto operator==(const decimal64_t lhs, const Integer rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    return mixed_equality_impl(lhs, rhs);
-}
-
-template <typename Integer>
-constexpr auto operator==(const Integer lhs, const decimal64_t rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    return mixed_equality_impl(rhs, lhs);
-}
-
-constexpr auto operator!=(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
-{
-    return !(lhs == rhs);
-}
-
-template <typename Integer>
-constexpr auto operator!=(const decimal64_t lhs, const Integer rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    return !(lhs == rhs);
-}
-
-template <typename Integer>
-constexpr auto operator!=(const Integer lhs, const decimal64_t rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    return !(lhs == rhs);
-}
-
-constexpr auto operator<(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (not_finite(lhs) || not_finite(rhs))
-    {
-        if (isnan(lhs) || isnan(rhs) ||
-            (!lhs.isneg() && rhs.isneg()))
-        {
-            return false;
-        }
-        if (lhs.isneg() && !rhs.isneg())
-        {
-            return true;
-        }
-        if (isfinite(lhs) && isinf(rhs))
-        {
-            return !rhs.isneg();
-        }
-    }
-    #endif
-
-    return sequential_less_impl(lhs, rhs);
-}
-
-template <typename Integer>
-constexpr auto operator<(const decimal64_t lhs, const Integer rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    return less_impl(lhs, rhs);
-}
-
-template <typename Integer>
-constexpr auto operator<(const Integer lhs, const decimal64_t rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (isnan(rhs))
-    {
-        return false;
-    }
-    #endif
-
-    return !less_impl(rhs, lhs) && lhs != rhs;
-}
-
-constexpr auto operator<=(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (isnan(lhs) || isnan(rhs))
-    {
-        return false;
-    }
-    #endif
-
-    return !(rhs < lhs);
-}
-
-template <typename Integer>
-constexpr auto operator<=(const decimal64_t lhs, const Integer rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (isnan(lhs))
-    {
-        return false;
-    }
-    #endif
-
-    return !(rhs < lhs);
-}
-
-template <typename Integer>
-constexpr auto operator<=(const Integer lhs, const decimal64_t rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (isnan(rhs))
-    {
-        return false;
-    }
-    #endif
-
-    return !(rhs < lhs);
-}
-
-constexpr auto operator>(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
-{
-    return rhs < lhs;
-}
-
-template <typename Integer>
-constexpr auto operator>(const decimal64_t lhs, const Integer rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    return rhs < lhs;
-}
-
-template <typename Integer>
-constexpr auto operator>(const Integer lhs, const decimal64_t rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    return rhs < lhs;
-}
-
-constexpr auto operator>=(const decimal64_t lhs, const decimal64_t rhs) noexcept -> bool
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (isnan(lhs) || isnan(rhs))
-    {
-        return false;
-    }
-    #endif
-
-    return !(lhs < rhs);
-}
-
-template <typename Integer>
-constexpr auto operator>=(const decimal64_t lhs, const Integer rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (isnan(lhs))
-    {
-        return false;
-    }
-    #endif
-
-    return !(lhs < rhs);
-}
-
-template <typename Integer>
-constexpr auto operator>=(const Integer lhs, const decimal64_t rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, bool)
-{
-    #ifndef BOOST_DECIMAL_FAST_MATH
-    if (isnan(rhs))
-    {
-        return false;
-    }
-    #endif
-
-    return !(lhs < rhs);
-}
-
-#ifdef BOOST_DECIMAL_HAS_SPACESHIP_OPERATOR
-
-constexpr auto operator<=>(const decimal64_t lhs, const decimal64_t rhs) noexcept -> std::partial_ordering
-{
-    if (lhs < rhs)
-    {
-        return std::partial_ordering::less;
-    }
-    else if (lhs > rhs)
-    {
-        return std::partial_ordering::greater;
-    }
-    else if (lhs == rhs)
-    {
-        return std::partial_ordering::equivalent;
-    }
-
-    return std::partial_ordering::unordered;
-}
-
-template <typename Integer>
-constexpr auto operator<=>(const decimal64_t lhs, const Integer rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, std::partial_ordering)
-{
-    if (lhs < rhs)
-    {
-        return std::partial_ordering::less;
-    }
-    else if (lhs > rhs)
-    {
-        return std::partial_ordering::greater;
-    }
-    else if (lhs == rhs)
-    {
-        return std::partial_ordering::equivalent;
-    }
-
-    return std::partial_ordering::unordered;
-}
-
-template <typename Integer>
-constexpr auto operator<=>(const Integer lhs, const decimal64_t rhs) noexcept
-    BOOST_DECIMAL_REQUIRES_RETURN(detail::is_integral_v, Integer, std::partial_ordering)
-{
-    if (lhs < rhs)
-    {
-        return std::partial_ordering::less;
-    }
-    else if (lhs > rhs)
-    {
-        return std::partial_ordering::greater;
-    }
-    else if (lhs == rhs)
-    {
-        return std::partial_ordering::equivalent;
-    }
-
-    return std::partial_ordering::unordered;
-}
-
-#endif
-
 constexpr auto operator&(const decimal64_t lhs, const decimal64_t rhs) noexcept -> decimal64_t
 {
     return from_bits(lhs.bits_ & rhs.bits_);
diff --git a/include/boost/decimal/decimal_fast128_t.hpp b/include/boost/decimal/decimal_fast128_t.hpp
index 7ad677e11..cf32914c2 100644
--- a/include/boost/decimal/decimal_fast128_t.hpp
+++ b/include/boost/decimal/decimal_fast128_t.hpp
@@ -334,6 +334,12 @@ BOOST_DECIMAL_EXPORT class decimal_fast128_t final
     friend constexpr auto operator+(const decimal_fast128_t& rhs) noexcept -> decimal_fast128_t;
     friend constexpr auto operator-(decimal_fast128_t rhs) noexcept -> decimal_fast128_t;
 
+    // Increment and Decrement
+    constexpr auto operator++()    noexcept -> decimal_fast128_t&;
+    constexpr auto operator++(int) noexcept -> decimal_fast128_t;  // NOLINT : C++14 so constexpr implies const
+    constexpr auto operator--()    noexcept -> decimal_fast128_t&;
+    constexpr auto operator--(int) noexcept -> decimal_fast128_t;  // NOLINT : C++14 so constexpr implies const
+
     // Binary arithmetic operators
     friend constexpr auto operator+(const decimal_fast128_t& lhs, const decimal_fast128_t& rhs) noexcept -> decimal_fast128_t;
     friend constexpr auto operator-(const decimal_fast128_t& lhs, const decimal_fast128_t& rhs) noexcept -> decimal_fast128_t;
@@ -915,6 +921,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) && isinf(rhs) && signbit(lhs) != signbit(rhs))
+        {
+            return direct_init_d128(detail::d128_fast_qnan, 0, false);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -961,6 +972,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) && isinf(rhs) && signbit(lhs) == signbit(rhs))
+        {
+            return direct_init_d128(detail::d128_fast_qnan, 0, false);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1026,6 +1042,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
@@ -1070,8 +1091,8 @@ constexpr auto d128f_div_impl(const decimal_fast128_t& lhs, const decimal_fast12
     #ifndef BOOST_DECIMAL_FAST_MATH
     // Check pre-conditions
     constexpr decimal_fast128_t zero {0, 0};
-    constexpr decimal_fast128_t nan {boost::decimal::direct_init_d128(boost::decimal::detail::d128_fast_qnan, 0, false)};
-    constexpr decimal_fast128_t inf {boost::decimal::direct_init_d128(boost::decimal::detail::d128_fast_inf, 0, false)};
+    constexpr decimal_fast128_t nan {direct_init_d128(detail::d128_fast_qnan, 0, false)};
+    constexpr decimal_fast128_t inf {direct_init_d128(detail::d128_fast_inf, 0, false)};
 
     const auto lhs_fp {fpclassify(lhs)};
     const auto rhs_fp {fpclassify(rhs)};
@@ -1087,12 +1108,28 @@ constexpr auto d128f_div_impl(const decimal_fast128_t& lhs, const decimal_fast12
     switch (lhs_fp)
     {
         case FP_INFINITE:
-            q = sign ? -inf : inf;
-            r = zero;
+            if (rhs_fp == FP_INFINITE)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -inf : inf;
+                r = zero;
+            }
             return;
         case FP_ZERO:
-            q = sign ? -zero : zero;
-            r = sign ? -zero : zero;
+            if (rhs_fp == FP_ZERO)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -zero : zero;
+                r = sign ? -zero : zero;
+            }
             return;
         default:
             static_cast<void>(lhs);
@@ -1296,6 +1333,30 @@ constexpr auto decimal_fast128_t::operator/=(const Integer rhs) noexcept
     return *this;
 }
 
+constexpr auto decimal_fast128_t::operator++() noexcept -> decimal_fast128_t&
+{
+    constexpr decimal_fast128_t one {1, 0};
+    *this = *this + one;
+    return *this;
+}
+
+constexpr auto decimal_fast128_t::operator++(int) noexcept -> decimal_fast128_t
+{
+    return ++(*this);
+}
+
+constexpr auto decimal_fast128_t::operator--() noexcept -> decimal_fast128_t&
+{
+    constexpr decimal_fast128_t one {1, 0};
+    *this = *this - one;
+    return *this;
+}
+
+constexpr auto decimal_fast128_t::operator--(int) noexcept -> decimal_fast128_t
+{
+    return --(*this);
+}
+
 constexpr decimal_fast128_t::operator bool() const noexcept
 {
     constexpr decimal_fast128_t zero {0, 0};
diff --git a/include/boost/decimal/decimal_fast32_t.hpp b/include/boost/decimal/decimal_fast32_t.hpp
index 4356acb83..113241b92 100644
--- a/include/boost/decimal/decimal_fast32_t.hpp
+++ b/include/boost/decimal/decimal_fast32_t.hpp
@@ -885,6 +885,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) && isinf(rhs) && signbit(lhs) != signbit(rhs))
+        {
+            return direct_init(detail::d32_fast_qnan, UINT8_C((0)));
+        }
+        
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -930,6 +935,11 @@ constexpr auto operator-(const decimal_fast32_t lhs, decimal_fast32_t rhs) noexc
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (!isfinite(lhs) || !isfinite(rhs))
     {
+        if (isinf(lhs) && isinf(rhs) && signbit(lhs) == signbit(rhs))
+        {
+            return direct_init(detail::d32_fast_qnan, UINT8_C((0)));
+        }
+        
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -996,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
@@ -1058,12 +1073,28 @@ constexpr auto div_impl(const decimal_fast32_t lhs, const decimal_fast32_t rhs,
     switch (lhs_fp)
     {
         case FP_INFINITE:
-            q = sign ? -inf : inf;
-            r = zero;
+            if (rhs_fp == FP_INFINITE)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -inf : inf;
+                r = zero;
+            }
             return;
         case FP_ZERO:
-            q = sign ? -zero : zero;
-            r = sign ? -zero : zero;
+            if (rhs_fp == FP_ZERO)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -zero : zero;
+                r = sign ? -zero : zero;
+            }
             return;
         default:
             static_cast<void>(lhs);
diff --git a/include/boost/decimal/decimal_fast64_t.hpp b/include/boost/decimal/decimal_fast64_t.hpp
index 0b8497773..5474e43ca 100644
--- a/include/boost/decimal/decimal_fast64_t.hpp
+++ b/include/boost/decimal/decimal_fast64_t.hpp
@@ -1008,6 +1008,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) && isinf(rhs) && signbit(lhs) != signbit(rhs))
+        {
+            return direct_init_d64(detail::d64_fast_qnan, 0, false);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1053,6 +1058,11 @@ constexpr auto operator-(const decimal_fast64_t lhs, decimal_fast64_t rhs) noexc
     #ifndef BOOST_DECIMAL_FAST_MATH
     if (not_finite(lhs) || not_finite(rhs))
     {
+        if (isinf(lhs) && isinf(rhs) && signbit(lhs) == signbit(rhs))
+        {
+            return direct_init_d64(detail::d64_fast_qnan, 0, false);
+        }
+
         return detail::check_non_finite(lhs, rhs);
     }
     #endif
@@ -1119,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
@@ -1165,8 +1180,8 @@ constexpr auto d64_fast_div_impl(const decimal_fast64_t& lhs, const decimal_fast
     #ifndef BOOST_DECIMAL_FAST_MATH
     // Check pre-conditions
     constexpr decimal_fast64_t zero {0, 0};
-    constexpr decimal_fast64_t nan {boost::decimal::direct_init_d64(boost::decimal::detail::d64_fast_snan, 0, false)};
-    constexpr decimal_fast64_t inf {boost::decimal::direct_init_d64(boost::decimal::detail::d64_fast_inf, 0, false)};
+    constexpr decimal_fast64_t nan {direct_init_d64(detail::d64_fast_qnan, 0, false)};
+    constexpr decimal_fast64_t inf {direct_init_d64(detail::d64_fast_inf, 0, false)};
 
     const auto lhs_fp {fpclassify(lhs)};
     const auto rhs_fp {fpclassify(rhs)};
@@ -1181,12 +1196,28 @@ constexpr auto d64_fast_div_impl(const decimal_fast64_t& lhs, const decimal_fast
     switch (lhs_fp)
     {
         case FP_INFINITE:
-            q = sign ? -inf : inf;
-            r = zero;
+            if (rhs_fp == FP_INFINITE)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -inf : inf;
+                r = zero;
+            }
             return;
         case FP_ZERO:
-            q = sign ? -zero : zero;
-            r = sign ? -zero : zero;
+            if (rhs_fp == FP_ZERO)
+            {
+                q = nan;
+                r = nan;
+            }
+            else
+            {
+                q = sign ? -zero : zero;
+                r = sign ? -zero : zero;
+            }
             return;
         default:
             static_cast<void>(lhs);
diff --git a/include/boost/decimal/detail/comparison.hpp b/include/boost/decimal/detail/comparison.hpp
index 196f24646..4f5aa4d0d 100644
--- a/include/boost/decimal/detail/comparison.hpp
+++ b/include/boost/decimal/detail/comparison.hpp
@@ -182,6 +182,12 @@ constexpr auto equal_parts_impl(T1 lhs_sig, U1 lhs_exp, bool lhs_sign,
     BOOST_DECIMAL_ASSERT(lhs_sig >= 0U);
     BOOST_DECIMAL_ASSERT(rhs_sig >= 0U);
 
+    if (lhs_sig == 0U && rhs_sig == 0U)
+    {
+        // +0 == -0
+        return true;
+    }
+
     // We con compare signs right away
     if (lhs_sign != rhs_sign)
     {
@@ -192,10 +198,6 @@ constexpr auto equal_parts_impl(T1 lhs_sig, U1 lhs_exp, bool lhs_sign,
 
     // Check the value of delta exp to avoid to large a value for pow10
     // Also if only one of the significands is 0 then we know the values have to be mismatched
-    if (lhs_sig == 0U && rhs_sig == 0U)
-    {
-        return true;
-    }
     if (delta_exp > detail::precision_v<DecimalType> || delta_exp < -detail::precision_v<DecimalType>)
     {
         return false;
@@ -270,14 +272,20 @@ constexpr auto equal_parts_impl(T1 lhs_sig, U1 lhs_exp, bool lhs_sign,
 
 template <BOOST_DECIMAL_DECIMAL_FLOATING_TYPE DecimalType = decimal32_t, BOOST_DECIMAL_INTEGRAL T1,
           BOOST_DECIMAL_INTEGRAL U1, BOOST_DECIMAL_INTEGRAL T2, BOOST_DECIMAL_INTEGRAL U2>
-constexpr auto equal_parts_impl(T1 lhs_sig, U1 lhs_exp, bool lhs_sign,
-                                T2 rhs_sig, U2 rhs_exp, bool rhs_sign) noexcept -> std::enable_if_t<detail::is_fast_type_v<DecimalType>, bool>
+constexpr auto equal_parts_impl(T1 lhs_sig, U1 lhs_exp, const bool lhs_sign,
+                                T2 rhs_sig, U2 rhs_exp, const bool rhs_sign) noexcept -> std::enable_if_t<detail::is_fast_type_v<DecimalType>, bool>
 {
     using comp_type = std::conditional_t<(std::numeric_limits<T1>::digits10 > std::numeric_limits<T2>::digits10), T1, T2>;
 
     BOOST_DECIMAL_ASSERT(lhs_sig >= 0U);
     BOOST_DECIMAL_ASSERT(rhs_sig >= 0U);
 
+    if (lhs_sig == 0U && rhs_sig == 0U)
+    {
+        // +0 == -0
+        return true;
+    }
+
     auto new_lhs_sig {static_cast<comp_type>(lhs_sig)};
     auto new_rhs_sig {static_cast<comp_type>(rhs_sig)};
 
diff --git a/test/Jamfile b/test/Jamfile
index 424cdd8cb..918555fb8 100644
--- a/test/Jamfile
+++ b/test/Jamfile
@@ -72,6 +72,7 @@ run github_issue_1091.cpp ;
 run github_issue_1094.cpp ;
 run github_issue_1105.cpp ;
 run github_issue_1106.cpp ;
+run github_issue_1107.cpp ;
 run github_issue_1110.cpp ;
 run github_issue_1112.cpp ;
 
diff --git a/test/compare_dec128_and_fast.cpp b/test/compare_dec128_and_fast.cpp
index e1fb15b3f..974128d74 100644
--- a/test/compare_dec128_and_fast.cpp
+++ b/test/compare_dec128_and_fast.cpp
@@ -130,6 +130,13 @@ void test_sub()
         const decimal_fast128_t dec128_fast_2 {val2};
         const decimal_fast128_t dec128_fast_res {dec128_fast_1 + dec128_fast_2};
 
+        if (isinf(dec128_1) && isinf(dec128_2) && isinf(dec128_fast_1) && isinf(dec128_fast_2))
+        {
+            BOOST_TEST(isinf(dec128_res) || isnan(dec128_res));
+            BOOST_TEST(isinf(dec128_fast_res) || isnan(dec128_fast_res));
+            continue;
+        }
+
         if (!BOOST_TEST_EQ(static_cast<double>(dec128_res), static_cast<double>(dec128_fast_res)))
         {
             // LCOV_EXCL_START
@@ -272,6 +279,12 @@ void test_div()
         const decimal_fast128_t dec128_fast_2 {val2};
         const decimal_fast128_t dec128_fast_res {dec128_fast_1 / dec128_fast_2};
 
+        if (isinf(dec128_1) && isinf(dec128_2) && isinf(dec128_fast_1) && isinf(dec128_fast_2))
+        {
+            BOOST_TEST(isnan(dec128_res) && isnan(dec128_fast_res));
+            continue;
+        }
+
         if (!BOOST_TEST_EQ(static_cast<double>(dec128_res), static_cast<double>(dec128_fast_res)))
         {
             // LCOV_EXCL_START
diff --git a/test/github_issue_1106.cpp b/test/github_issue_1106.cpp
index e5bd3dc52..505169ad3 100644
--- a/test/github_issue_1106.cpp
+++ b/test/github_issue_1106.cpp
@@ -2,7 +2,7 @@
 // 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
+// See: https://github.com/cppalliance/decimal/issues/1106
 
 #include <boost/decimal.hpp>
 #include <boost/core/lightweight_test.hpp>
diff --git a/test/github_issue_1107.cpp b/test/github_issue_1107.cpp
new file mode 100644
index 000000000..b0af7290f
--- /dev/null
+++ b/test/github_issue_1107.cpp
@@ -0,0 +1,120 @@
+// 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/1107
+
+#include <boost/decimal.hpp>
+#include <boost/core/lightweight_test.hpp>
+#include <limits>
+#include <random>
+
+using namespace boost::decimal;
+
+static std::mt19937_64 rng(42);
+static std::uniform_int_distribution<int> dist(1, 10);
+
+// 7.2.b
+template <typename T>
+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));
+}
+
+// 7.2.d
+template <typename T>
+void test_add_sub()
+{
+    const T a {dist(rng) * std::numeric_limits<T>::infinity()};
+    const T b {dist(rng) * -std::numeric_limits<T>::infinity()};
+
+    BOOST_TEST(!signbit(a));
+    BOOST_TEST(signbit(b));
+
+    BOOST_TEST(isnan(b + a)); // -inf + inf
+    BOOST_TEST(isnan(a + b)); //  inf - inf
+    BOOST_TEST(isnan(b - b)); // -inf + inf
+    BOOST_TEST(isnan(a - a)); //  inf - inf
+}
+
+// 7.2.e
+template <typename T>
+void test_div()
+{
+    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 / a));
+    BOOST_TEST(isnan(b / b));
+}
+
+// 7.2.f
+template <typename T>
+void test_remainder()
+{
+    const T a {dist(rng) * 0};
+    const T b {dist(rng) * std::numeric_limits<T>::infinity()};
+    const T c {dist(rng)};
+
+    BOOST_TEST(isnan(remainder(b, c)));
+    BOOST_TEST(isnan(remainder(c, a)));
+}
+
+// 7.2.g
+template <typename T>
+void test_sqrt()
+{
+    const T val {-dist(rng)};
+    const auto sqrt_val {sqrt(val)};
+    BOOST_TEST(isnan(sqrt_val));
+}
+
+int main()
+{
+    test_add_sub<decimal32_t>();
+    test_add_sub<decimal64_t>();
+    test_add_sub<decimal128_t>();
+    test_add_sub<decimal_fast32_t>();
+    test_add_sub<decimal_fast64_t>();
+    test_add_sub<decimal_fast128_t>();
+
+    test_mul<decimal32_t>();
+    test_mul<decimal64_t>();
+    test_mul<decimal128_t>();
+    test_mul<decimal_fast32_t>();
+    test_mul<decimal_fast64_t>();
+    test_mul<decimal_fast128_t>();
+
+    test_div<decimal32_t>();
+    test_div<decimal64_t>();
+    test_div<decimal128_t>();
+    test_div<decimal_fast32_t>();
+    test_div<decimal_fast64_t>();
+    test_div<decimal_fast128_t>();
+
+    test_remainder<decimal32_t>();
+    test_remainder<decimal64_t>();
+    test_remainder<decimal128_t>();
+    test_remainder<decimal_fast32_t>();
+    test_remainder<decimal_fast64_t>();
+    test_remainder<decimal_fast128_t>();
+
+    test_sqrt<decimal32_t>();
+    test_sqrt<decimal64_t>();
+    test_sqrt<decimal128_t>();
+    test_sqrt<decimal_fast32_t>();
+    test_sqrt<decimal_fast64_t>();
+    test_sqrt<decimal_fast128_t>();
+
+    return boost::report_errors();
+}
diff --git a/test/random_decimal64_math.cpp b/test/random_decimal64_math.cpp
index a6f5efa26..545c223f6 100644
--- a/test/random_decimal64_math.cpp
+++ b/test/random_decimal64_math.cpp
@@ -379,7 +379,6 @@ void random_division(T lower, T upper)
         }
     }
 
-    BOOST_TEST(isinf(std::numeric_limits<decimal64_t>::infinity() / decimal64_t(dist(rng))));
     BOOST_TEST(!isinf(decimal64_t(dist(rng)) / std::numeric_limits<decimal64_t>::infinity()));
     BOOST_TEST(isnan(std::numeric_limits<decimal64_t>::quiet_NaN() / decimal64_t(dist(rng))));
     BOOST_TEST(isnan(decimal64_t(dist(rng)) / std::numeric_limits<decimal64_t>::quiet_NaN()));
diff --git a/test/random_mixed_decimal_math.cpp b/test/random_mixed_decimal_math.cpp
index ba371cd62..81f4efae7 100644
--- a/test/random_mixed_decimal_math.cpp
+++ b/test/random_mixed_decimal_math.cpp
@@ -179,7 +179,6 @@ void random_mixed_division(T lower, T upper)
         }
     }
 
-    BOOST_TEST(isinf(std::numeric_limits<Decimal1>::infinity() / Decimal2(dist(rng))));
     BOOST_TEST(!isinf(Decimal2(dist(rng)) / std::numeric_limits<Decimal1>::infinity()));
     BOOST_TEST(isnan(std::numeric_limits<Decimal1>::quiet_NaN() / Decimal2(dist(rng))));
     BOOST_TEST(isnan(Decimal2(dist(rng)) / std::numeric_limits<Decimal1>::quiet_NaN()));
diff --git a/test/test_cmath.cpp b/test/test_cmath.cpp
index d60098c87..787845724 100644
--- a/test/test_cmath.cpp
+++ b/test/test_cmath.cpp
@@ -60,7 +60,6 @@ void test_fmax()
     BOOST_TEST_EQ(fmax(Dec(1), std::numeric_limits<Dec>::quiet_NaN() * Dec(dist(rng))), Dec(1));
     BOOST_TEST_EQ(fmax(std::numeric_limits<Dec>::quiet_NaN() * Dec(dist(rng)), Dec(1)), Dec(1));
     BOOST_TEST(isnan(fmax(std::numeric_limits<Dec>::quiet_NaN() * Dec(dist(rng)), std::numeric_limits<Dec>::quiet_NaN() * Dec(dist(rng)))));
-    BOOST_TEST_EQ(fmax(std::numeric_limits<Dec>::infinity() * Dec(dist(rng)), -std::numeric_limits<Dec>::infinity() * Dec(dist(rng))), std::numeric_limits<Dec>::infinity());
 
     BOOST_TEST_EQ(fmax(Dec(1), Dec(0)), Dec(1));
     BOOST_TEST_EQ(fmax(Dec(-2), Dec(1)), Dec(1));