Update decimal64_t / and % non-finite value handling

Author: mborland

include/boost/decimal/decimal64_t.hpp

@@ -1568,67 +1568,85 @@ constexpr auto d64_div_impl(const decimal64_t lhs, const decimal64_t rhs, decima
     const auto lhs_fp {fpclassify(lhs)};
     const auto rhs_fp {fpclassify(rhs)};
 
-    if (lhs_fp == FP_NAN || rhs_fp == FP_NAN)
+    if (lhs_fp != FP_NORMAL || rhs_fp != FP_NORMAL)
     {
-        // Operations on an SNAN return a QNAN with the same payload
-        decimal64_t return_nan {};
-        if (lhs_fp == FP_NAN)
+        if (lhs_fp == FP_NAN || rhs_fp == FP_NAN)
         {
-            return_nan = issignaling(lhs) ? nan_conversion(lhs) : lhs;
-        }
-        else
-        {
-            return_nan = issignaling(rhs) ? nan_conversion(rhs) : rhs;
-        }
-
-        q = return_nan;
-        r = return_nan;
-
-        return;
-    }
-
-    switch (lhs_fp)
-    {
-        case FP_INFINITE:
-            if (lhs_fp == FP_INFINITE)
-            {
-                q = nan;
-                r = nan;
-            }
-            else
+            // Operations on an SNAN return a QNAN with the same payload
+            decimal64_t return_nan {};
+            if (lhs_fp == rhs_fp)
             {
-                q = sign ? -inf : inf;
-                r = zero;
+                // They are both NANs
+                const bool lhs_signaling {issignaling(lhs)};
+                const bool rhs_signaling {issignaling(rhs)};
+
+                if (!lhs_signaling && rhs_signaling)
+                {
+                    return_nan = nan_conversion(rhs);
+                }
+                else
+                {
+                    return_nan = lhs_signaling ? nan_conversion(lhs) : lhs;
+                }
             }
-            return;
-        case FP_ZERO:
-            if (rhs_fp == FP_ZERO)
+            else if (lhs_fp == FP_NAN)
             {
-                q = nan;
-                r = nan;
+                return_nan = issignaling(lhs) ? nan_conversion(lhs) : lhs;
             }
             else
             {
-                q = sign ? -zero : zero;
-                r = sign ? -zero : zero;
+                return_nan = issignaling(rhs) ? nan_conversion(rhs) : rhs;
             }
-            return;
-        default:
-            static_cast<void>(lhs);
-    }
 
-    switch (rhs_fp)
-    {
-        case FP_ZERO:
-            q = inf;
-            r = zero;
-            return;
-        case FP_INFINITE:
-            q = sign ? -zero : zero;
-            r = lhs;
+            q = return_nan;
+            r = return_nan;
+
             return;
-        default:
-            static_cast<void>(rhs);
+        }
+
+        switch (lhs_fp)
+        {
+            case FP_INFINITE:
+                if (lhs_fp == FP_INFINITE)
+                {
+                    q = nan;
+                    r = nan;
+                }
+                else
+                {
+                    q = sign ? -inf : inf;
+                    r = zero;
+                }
+                return;
+            case FP_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);
+        }
+
+        switch (rhs_fp)
+        {
+            case FP_ZERO:
+                q = inf;
+                r = zero;
+                return;
+            case FP_INFINITE:
+                q = sign ? -zero : zero;
+                r = lhs;
+                return;
+            default:
+                static_cast<void>(rhs);
+        }
     }
 
     #else
@@ -1956,7 +1974,11 @@ constexpr auto operator%(const decimal64_t lhs, const decimal64_t rhs) noexcept
     decimal64_t q {};
     decimal64_t r {};
     d64_div_impl(lhs, rhs, q, r);
-    d64_mod_impl(lhs, rhs, q, r);
+
+    if (BOOST_DECIMAL_LIKELY(!isnan(q)))
+    {
+        d64_mod_impl(lhs, rhs, q, r);
+    }
 
     return r;
 }