datatypes for math methods extended

Author: SkibidiProduction

numpower.c

@@ -3581,12 +3581,10 @@ static const char *ndarray_infer_dtype_from_string(const char *str, size_t len)
        literal contains a fractional / exponent part (→ fp128) and where
        the magnitude digits live (for the int64-vs-uint64 split). Any
        character that does not fit the grammar fails the scan. */
-    size_t k          = i;
-    int    has_sign   = 0;
-    int    is_neg     = 0;
+    size_t k      = i;
+    int    is_neg = 0;
     if (k < end && (str[k] == '+' || str[k] == '-')) {
-        has_sign = 1;
-        is_neg   = (str[k] == '-');
+        is_neg = (str[k] == '-');
         k++;
     }
     /* Mantissa integer part. */
@@ -3605,7 +3603,6 @@ static const char *ndarray_infer_dtype_from_string(const char *str, size_t len)
     }
     /* At least one digit in mantissa (integer or fractional). */
     if (mant_int_len == 0 && frac_len == 0) {
-        (void)has_sign;
         return NULL;
     }
 
@@ -3631,17 +3628,25 @@ static const char *ndarray_infer_dtype_from_string(const char *str, size_t len)
         return "float128";
     }
 
-    /* Pure integer literal. */
-    if (is_neg) {
-        return "int64";
-    }
-    /* Magnitude check on the integer digits (skip leading zeros). */
+    /* Pure integer literal — magnitude check on the digits (skip leading
+       zeros) decides int64 vs uint64 vs float128. */
     const char *p = str + mant_int_start;
     size_t      m = mant_int_len;
     while (m > 1 && *p == '0') { p++; m--; }
 
     static const char int64_max_str[]  = "9223372036854775807";   /* 19 digits */
+    static const char int64_min_mag[]  = "9223372036854775808";   /* |INT64_MIN|, 19 digits */
     static const char uint64_max_str[] = "18446744073709551615";  /* 20 digits */
+
+    if (is_neg) {
+        /* Negative magnitude: int64 holds down to -INT64_MIN = -9223372036854775808;
+           anything wider must escalate to float128 (uint64 cannot represent
+           negatives, and strtoll would silently saturate to INT64_MIN with
+           errno=ERANGE if we'd routed it through int64). */
+        if (m > 19) return "float128";
+        if (m == 19 && memcmp(p, int64_min_mag, 19) > 0) return "float128";
+        return "int64";
+    }
     if (m > 20) {
         /* Past UINT64_MAX — escalate to fp128 to keep precision rather
            than saturate the integer dtypes. */

src/debug.c

@@ -97,7 +97,9 @@ print_array_float32(float* buffer, int ndims, int* shape, int* strides, int cur_
     }
 
     if (ndims == 0) {
-        sprintf(str, "%g\n", buffer[0]);
+        float v0 = buffer[0];
+        if (isnan(v0)) sprintf(str, "nan\n");
+        else           sprintf(str, "%g\n", (double)v0);
         return str;
     }
 
@@ -114,8 +116,14 @@ print_array_float32(float* buffer, int ndims, int* shape, int* strides, int cur_
             for (int k = 0; k < ndims; k++) {
                 offset += index[k] * strides[k];
             }
-            // Print the element
-            sprintf(str + strlen(str), "%.8g", buffer[offset / sizeof(float)]);
+            // Print the element — NaN canonicalized to unsigned form to
+            // match PyTorch / Python repr (glibc `%g` emits "-nan" for
+            // sign-bit-set NaN; users wouldn't expect the sign on a
+            // numerical printout). Same normalization applies to fp64
+            // and to every dtype routed through `ndarray_element_to_string`.
+            float ve = buffer[offset / sizeof(float)];
+            if (isnan(ve)) sprintf(str + strlen(str), "nan");
+            else           sprintf(str + strlen(str), "%.8g", (double)ve);
 
             // Print a comma if this is not the last element in the dimension
             if (i < shape[cur_dim] - 1) {
@@ -234,7 +242,9 @@ print_array_float64(double* buffer, int ndims, int* shape, int* strides, int cur
     }
 
     if (ndims == 0) {
-        sprintf(str, "%g\n", buffer[0]);
+        double v0 = buffer[0];
+        if (isnan(v0)) sprintf(str, "nan\n");
+        else           sprintf(str, "%g\n", v0);
         return str;
     }
 
@@ -251,8 +261,11 @@ print_array_float64(double* buffer, int ndims, int* shape, int* strides, int cur
             for (int k = 0; k < ndims; k++) {
                 offset += index[k] * strides[k];
             }
-            // Print the element
-            sprintf(str + strlen(str), "%.16g", buffer[offset / sizeof(double)]);
+            // Print the element — NaN canonicalized to unsigned form
+            // (see analogous fp32 path above).
+            double ve = buffer[offset / sizeof(double)];
+            if (isnan(ve)) sprintf(str + strlen(str), "nan");
+            else           sprintf(str + strlen(str), "%.16g", ve);
 
             // Print a comma if this is not the last element in the dimension
             if (i < shape[cur_dim] - 1) {

src/ndarray_types.c

@@ -530,17 +530,26 @@ void ndarray_element_to_string(const char *type,
     } else if (strcmp(type, "float16") == 0) {
         uint16_t fp16;
         memcpy(&fp16, data + byte_offset, 2);
-        snprintf(buf, bufsize, "%.6g", ndarray_fp16_to_double(fp16));
+        double v = ndarray_fp16_to_double(fp16);
+        /* NaN-sign normalization: glibc `%g` prints "-nan" for a quiet
+           NaN with the sign bit set, which PyTorch / Python `repr` do
+           not (they always print "nan"). Match PyTorch parity across
+           every fp dtype — fp128 / fp8 already canonicalize the same
+           way; fp16/fp32/fp64 now follow suit. */
+        if (isnan(v)) snprintf(buf, bufsize, "nan");
+        else          snprintf(buf, bufsize, "%.6g", v);
 
     } else if (strcmp(type, "float32") == 0) {
         float v;
         memcpy(&v, data + byte_offset, 4);
-        snprintf(buf, bufsize, "%.8g", (double)v);
+        if (isnan(v)) snprintf(buf, bufsize, "nan");
+        else          snprintf(buf, bufsize, "%.8g", (double)v);
 
     } else if (strcmp(type, "float64") == 0) {
         double v;
         memcpy(&v, data + byte_offset, 8);
-        snprintf(buf, bufsize, "%.16g", v);
+        if (isnan(v)) snprintf(buf, bufsize, "nan");
+        else          snprintf(buf, bufsize, "%.16g", v);
 
     } else if (strcmp(type, "float128") == 0) {
         ndarray_fp128_t v;

src/ndmath/arithmetics.c

@@ -3667,13 +3667,31 @@ static int unary_validate_numeric_string(const char *str, const char *which) {
     return 0;
 }
 
+/**
+ * @brief Skip leading ASCII whitespace, returning the first non-space char's
+ *        pointer. Mirrors `strtoll`'s leading-whitespace handling.
+ */
+static inline const char *unary_skip_ws(const char *s) {
+    while (*s == ' ' || *s == '\t' || *s == '\n' || *s == '\r') s++;
+    return s;
+}
+
 /**
  * @brief Parse @p str into the typed scalar buffer @p out_buf for @p dt.
  *
  * Validates the string syntactically first so callers get a clean error
- * instead of a silent 0 coerced from a malformed input. Routes through
- * `ndarray_set_from_string` so `float128` / `int64` / `uint64` strings
- * preserve precision. Other dtypes route through `double`.
+ * instead of a silent 0 coerced from a malformed input. For integer
+ * dtypes the value is *saturated* to the dtype's representable range
+ * (PyTorch `clamp` semantics): a negative bound for an unsigned dtype
+ * collapses to 0; a magnitude exceeding the signed dtype's `INT*_MAX`
+ * saturates to that max (or `INT*_MIN` if negative); without this
+ * saturation, `clip(uint8 tensor, -50, 100)` would silently wrap `-50`
+ * via the modulo-2^N cast inside `ndarray_set_from_string`, then see
+ * `lo (206) > hi (100)` and collapse every element to `100`. For
+ * float dtypes (and `int64`/`uint64`/`float128` where wide-precision
+ * strings carry the only loss-free intake), the call falls through to
+ * `ndarray_set_from_string` so `strtoll`/`strtoull`/`strtoflt128` keep
+ * the full source precision.
  *
  * @param[in]  dt      Canonical dtype string.
  * @param[in]  str     Decimal literal.
@@ -3684,6 +3702,66 @@ static int unary_validate_numeric_string(const char *str, const char *which) {
 static int unary_parse_typed_scalar(const char *dt, const char *str,
                                      const char *which, void *out_buf) {
     if (unary_validate_numeric_string(str, which) < 0) return -1;
+
+    /* Narrow integer dtypes — saturate the bound to the dtype range so
+       out-of-range literals don't wrap via the implicit `(T)strtoll(...)`
+       cast inside `ndarray_set_from_string`. int64/uint64 keep the
+       wide-precision intake path (their saturating boundary is exactly
+       at the strtoll/strtoull edge already). */
+    const char *p = unary_skip_ws(str);
+    int is_neg = (*p == '-');
+    if (!strcmp(dt, "uint8")) {
+        if (is_neg) { *(uint8_t *)out_buf = 0; return 0; }
+        unsigned long long v = strtoull(p, NULL, 10);
+        *(uint8_t *)out_buf = (uint8_t)(v > 0xFFu ? 0xFFu : v);
+        return 0;
+    }
+    if (!strcmp(dt, "uint16")) {
+        if (is_neg) { *(uint16_t *)out_buf = 0; return 0; }
+        unsigned long long v = strtoull(p, NULL, 10);
+        *(uint16_t *)out_buf = (uint16_t)(v > 0xFFFFu ? 0xFFFFu : v);
+        return 0;
+    }
+    if (!strcmp(dt, "uint32")) {
+        if (is_neg) { *(uint32_t *)out_buf = 0; return 0; }
+        unsigned long long v = strtoull(p, NULL, 10);
+        *(uint32_t *)out_buf = (uint32_t)(v > 0xFFFFFFFFu ? 0xFFFFFFFFu : v);
+        return 0;
+    }
+    if (!strcmp(dt, "int8")) {
+        long long v = strtoll(str, NULL, 10);
+        if (v >  0x7F)            v =  0x7F;
+        else if (v < -0x80)       v = -0x80;
+        *(int8_t *)out_buf = (int8_t)v;
+        return 0;
+    }
+    if (!strcmp(dt, "int16")) {
+        long long v = strtoll(str, NULL, 10);
+        if (v >  0x7FFF)          v =  0x7FFF;
+        else if (v < -0x8000)     v = -0x8000;
+        *(int16_t *)out_buf = (int16_t)v;
+        return 0;
+    }
+    if (!strcmp(dt, "int32")) {
+        long long v = strtoll(str, NULL, 10);
+        if (v >  0x7FFFFFFFLL)    v =  0x7FFFFFFFLL;
+        else if (v < -0x80000000LL) v = -0x80000000LL;
+        *(int32_t *)out_buf = (int32_t)v;
+        return 0;
+    }
+    /* uint64: strtoull silently wraps a negative literal modulo 2^64
+       (`strtoull("-50")` returns `UINT64_MAX - 49`) — saturate to 0
+       explicitly. ERANGE on a positive overflow is what strtoull would
+       cap at UINT64_MAX anyway. */
+    if (!strcmp(dt, "uint64")) {
+        if (is_neg) { *(uint64_t *)out_buf = 0; return 0; }
+        /* Fall through to ndarray_set_from_string for the positive path
+           so wide-precision literals route through the same parser used
+           elsewhere. */
+    }
+    /* int64 / uint64 (positive) / float* : strtoll / strtoull / strtod /
+       strtoflt128 already saturate at the dtype's edge under ERANGE,
+       matching the behaviour we want without an explicit upper-bound check. */
     ndarray_set_from_string(dt, (char *)out_buf, 0, str);
     return 0;
 }
@@ -3912,20 +3990,14 @@ static int unary_run_cpu_inplace(void *data, long n, const char *dt,
                 }
                 default: break;
             }
-            /* Normalize NaN sign bit to canonical +NaN. libquadmath /
-               libm leak a sign-bit-set "-nan" out of `logq(-x)`,
-               `sqrtq(-x)`, `log1pq(-x)` etc. The fp64 path returns
-               NaN with the sign bit set too, but PHP's float
-               stringifier hides the sign (`var_dump(NAN)` prints
-               "NAN"); `quadmath_snprintf` honours it, so the user
-               sees the inconsistency only on fp128. Force-clear the
-               sign bit so display matches the rest of the unary
-               family. Skip on NDARRAY_UNOP_SIGN — that op uses NaN
-               propagation as a meaningful value (PyTorch parity) and
-               the input's sign bit is part of its signal. */
-            if (op != NDARRAY_UNOP_SIGN && NDARRAY_FP128_ISNAN(y)) {
-                y = NDARRAY_FP128_NAN();
-            }
+            /* NaN-sign canonicalization happens at stringification time
+               (`ndarray_fp128_to_string`) rather than here. This keeps
+               the in-memory bit pattern mathematically faithful:
+               `NumPower::negative(NaN)` flips the sign bit (matches
+               NumPy / PyTorch `neg` on NaN), `NumPower::positive(NaN)`
+               preserves the input, while `__toString` / `toArray`
+               render every NaN as the unsigned `"nan"` literal across
+               every fp dtype. */
             p[i] = y;
         }
         return 0;

tests/math/115-unary-math-explog-string-scalar.phpt

@@ -76,9 +76,15 @@ check("sign('9223372036854775808') uint64",
       is_string(NumPower::sign('9223372036854775808')),true);
 check("sign('18446744073709551615') uint64",
       is_string(NumPower::sign('18446744073709551615')),true);
-/* Negative magnitude can never fit uint64 → must stay int64 (signed). */
-check("sign('-18446744073709551615') int64",
-      is_int(NumPower::sign('-18446744073709551615')), true);
+/* Negative magnitudes up to |INT64_MIN| = 9223372036854775808 fit int64;
+   anything larger escalates to float128 to avoid the silent INT64_MIN
+   saturation a naïve `strtoll` would deliver. */
+check("sign('-9223372036854775808') int64",
+      is_int(NumPower::sign('-9223372036854775808')), true);
+check("sign('-9223372036854775809') float128",
+      is_string(NumPower::sign('-9223372036854775809')), true);
+check("sign('-18446744073709551615') float128",
+      is_string(NumPower::sign('-18446744073709551615')), true);
 
 /* ── MATHEMATICAL FUNCTIONS ───────────────────────────────────────────── */
 
@@ -220,7 +226,9 @@ OK sign('0') is int (int64)
 OK sign('9223372036854775807') int64
 OK sign('9223372036854775808') uint64
 OK sign('18446744073709551615') uint64
-OK sign('-18446744073709551615') int64
+OK sign('-9223372036854775808') int64
+OK sign('-9223372036854775809') float128
+OK sign('-18446744073709551615') float128
 OK abs('-3.5') (fp128)
 OK abs('-100') (int64)
 OK abs('18446744073709551615') (uint64)