-nan supported

Author: SwayamInSync

quaddtype/numpy_quaddtype/src/casts.cpp

@@ -85,7 +85,8 @@ quad_to_quad_same_value_check(const quad_value *in_val, QuadBackendType backend_
         // Convert longdouble back to SLEEF for comparison
         long double ld = out_val->longdouble_value;
         if (std::isnan(ld)) {
-            roundtrip.sleef_value = QUAD_PRECISION_NAN;
+            // Preserve sign of NaN
+            roundtrip.sleef_value = (!ld_signbit(&ld)) ? QUAD_PRECISION_NAN : QUAD_PRECISION_NEG_NAN;
         }
         else if (std::isinf(ld)) {
             roundtrip.sleef_value = (ld > 0) ? QUAD_PRECISION_INF : QUAD_PRECISION_NINF;
@@ -162,7 +163,7 @@ quad_to_quad_strided_loop(PyArrayMethod_Context *context, char *const data[],
             {
               long double ld = in_val.longdouble_value;
               if (std::isnan(ld)) {
-                  out_val.sleef_value = QUAD_PRECISION_NAN;
+                  out_val.sleef_value = (!ld_signbit(&ld)) ? QUAD_PRECISION_NAN : QUAD_PRECISION_NEG_NAN;
               }
               else if (std::isinf(ld)) {
                   out_val.sleef_value = (ld > 0) ? QUAD_PRECISION_INF : QUAD_PRECISION_NINF;
@@ -441,7 +442,6 @@ quad_to_string_same_value_check(const quad_value *in_val, const char *str_buf, n
 
     // Compare original and roundtripped values along with signbit
     if (backend == BACKEND_SLEEF) {
-        // NaN == NaN for same_value purposes
         bool is_sign_preserved = (quad_signbit(&in_val->sleef_value) == quad_signbit(&roundtrip.sleef_value));
         if (Sleef_iunordq1(in_val->sleef_value, roundtrip.sleef_value) && is_sign_preserved)
             return 1;

quaddtype/numpy_quaddtype/src/constants.hpp

@@ -17,6 +17,7 @@ extern "C" {
 #define QUAD_PRECISION_INF sleef_q(+0x1000000000000LL, 0x0000000000000000ULL, 16384)
 #define QUAD_PRECISION_NINF sleef_q(-0x1000000000000LL, 0x0000000000000000ULL, 16384)
 #define QUAD_PRECISION_NAN sleef_q(+0x1ffffffffffffLL, 0xffffffffffffffffULL, 16384)
+#define QUAD_PRECISION_NEG_NAN sleef_q(-0x1ffffffffffffLL, 0xffffffffffffffffULL, 16384)
 
 // Additional constants
 #define QUAD_PRECISION_MAX_FINITE SLEEF_QUAD_MAX

quaddtype/numpy_quaddtype/src/dragon4.c

@@ -974,22 +974,22 @@ PrintInfNan(char *buffer, npy_uint32 bufferSize, npy_uint64 mantissa, npy_uint32
 
     DEBUG_ASSERT(bufferSize > 0);
 
+    /* Print sign for both inf and nan values */
+    if (signbit == '+') {
+        if (pos < maxPrintLen - 1) {
+            buffer[pos++] = '+';
+        }
+    }
+    else if (signbit == '-') {
+        if (pos < maxPrintLen - 1) {
+            buffer[pos++] = '-';
+        }
+    }
+
     /* Check for infinity */
     if (mantissa == 0) {
         npy_uint32 printLen;
 
-        /* only print sign for inf values (though nan can have a sign set) */
-        if (signbit == '+') {
-            if (pos < maxPrintLen - 1) {
-                buffer[pos++] = '+';
-            }
-        }
-        else if (signbit == '-') {
-            if (pos < maxPrintLen - 1) {
-                buffer[pos++] = '-';
-            }
-        }
-
         /* copy and make sure the buffer is terminated */
         printLen = (3 < maxPrintLen - pos) ? 3 : maxPrintLen - pos;
         memcpy(buffer + pos, "inf", printLen);

quaddtype/numpy_quaddtype/src/scalar.c

@@ -186,6 +186,11 @@ QuadPrecision_from_object(PyObject *value, QuadBackendType backend)
             self->value.sleef_value = Sleef_cast_from_doubleq1(dval);
         }
         else {
+            // np.longdouble does not preserve sign of while nan construction`
+            // if (isnan(dval)) {
+            //     self->value.longdouble_value = copysignl(NAN, dval);
+            // }
+            // else
             self->value.longdouble_value = (long double)dval;
         }
     }