Wrap out-of-range float-to-integer astype casts to match NumPy (#3033)

Casting an out-of-range floating-point value to an integer type is
undefined behavior in C++. SYCL devices resolve it by saturating to the
destination's min/max, whereas NumPy emits a plain C cast that, for
narrow integer targets, truncates toward zero and wraps modulo the
destination width (e.g. `float32(128)` becomes `int8(-128)`).

`convert_impl` (used by `astype` and every copy-and-cast kernel) only
normalized this to NumPy's wrapping behavior for *unsigned*
destinations. Signed narrow integer targets fell through to a raw
`static_cast` and therefore *saturated* on device, diverging from NumPy.
The same inconsistency showed up within a single operation:
`dpnp.tensor.linalg.trace` with an `int8` output dtype produced
different results depending on whether the value went through the
element-wise `astype` path (saturated) or the reduction path (wrapped).

This PR generalizes the float-to-integer branch of `convert_impl` to
funnel every conversion through a wider signed integer, relying on the
well-defined integer narrowing to perform the modular wrap for both
signed and unsigned narrow integer targets. 64-bit destinations keep
their existing handling (unsigned routes negatives through `int64`;
signed casts directly).

Author: antonwolfy

CHANGELOG.md

@@ -89,6 +89,7 @@ This release is compatible with NumPy 2.5.
 * Fixed `dpnp.ndarray.view` ignoring the USM element offset of a sliced array, which also caused `dpnp.einsum` to silently return wrong results for a single sliced operand with no summed index [#3037](https://github.com/IntelPython/dpnp/pull/3037)
 * Fixed `dpnp.all` and `dpnp.any` aborting when reducing over an empty axis (e.g. an array with a zero-length dimension) [#3021](https://github.com/IntelPython/dpnp/pull/3021)
 * Released the GIL before the blocking OneMKL DFT calls in the FFT extension [#3040](https://github.com/IntelPython/dpnp/pull/3040)
+* Fixed `astype` casting an out-of-range floating point value to a signed narrow integer type saturating to the destination min/max instead of wrapping like NumPy, generalizing the earlier unsigned-only fix [#3033](https://github.com/IntelPython/dpnp/pull/3033)
 
 ### Security
 

dpnp/tensor/libtensor/include/utils/type_utils.hpp

@@ -98,15 +98,24 @@ dstTy convert_impl(const srcTy &v)
     }
     else if constexpr (!std::is_integral_v<srcTy> &&
                        !std::is_same_v<dstTy, bool> &&
-                       std::is_integral_v<dstTy> && std::is_unsigned_v<dstTy>) {
-        // for negative values, cast through signed integer to get two's
-        // complement wrapping
-        using intermediateT =
-            std::conditional_t<sizeof(dstTy) < sizeof(std::int32_t),
-                               std::int32_t, std::int64_t>;
-        return (v < srcTy{0})
-                   ? static_cast<dstTy>(static_cast<intermediateT>(v))
-                   : static_cast<dstTy>(v);
+                       std::is_integral_v<dstTy>) {
+        // Out-of-range float-to-int casts are UB; SYCL saturates while NumPy
+        // wraps. Funnel through a wider signed integer so the well-defined
+        // integer narrowing reproduces NumPy's wrapping, e.g. f32(128) ->
+        // i8(-128).
+        if constexpr (sizeof(dstTy) < sizeof(std::int64_t)) {
+            return static_cast<dstTy>(static_cast<std::int64_t>(v));
+        }
+        else if constexpr (std::is_unsigned_v<dstTy>) {
+            // uint64: no wider signed type, so only negatives need int64
+            return (v < srcTy{0})
+                       ? static_cast<dstTy>(static_cast<std::int64_t>(v))
+                       : static_cast<dstTy>(v);
+        }
+        else {
+            // int64: nothing wider to funnel through
+            return static_cast<dstTy>(v);
+        }
     }
     else {
         return static_cast<dstTy>(v);

dpnp/tests/tensor/test_usm_ndarray_ctor.py

@@ -39,28 +39,12 @@
 import dpnp.tensor as dpt
 from dpnp.tensor import Device
 
+from .elementwise.utils import _all_dtypes, _integral_dtypes, _real_fp_dtypes
 from .helper import (
     get_queue_or_skip,
     skip_if_dtype_not_supported,
 )
 
-_all_dtypes = [
-    "b1",
-    "i1",
-    "u1",
-    "i2",
-    "u2",
-    "i4",
-    "u4",
-    "i8",
-    "u8",
-    "f2",
-    "f4",
-    "f8",
-    "c8",
-    "c16",
-]
-
 
 @pytest.mark.parametrize(
     "shape",
@@ -1039,6 +1023,22 @@ def test_astype_gh_2882():
     assert dpt.all(r == expected)
 
 
+@pytest.mark.usefixtures("suppress_overflow_encountered_in_cast_numpy_warnings")
+@pytest.mark.parametrize("dst_dtype", _integral_dtypes)
+@pytest.mark.parametrize("src_dtype", _real_fp_dtypes)
+def test_astype_out_of_range_float_to_int(src_dtype, dst_dtype):
+    q = get_queue_or_skip()
+    skip_if_dtype_not_supported(src_dtype, q)
+
+    values = [0, 1, -1, 127, 128, -129, 255, 256, -256, 300, 60000, -60000]
+    x_np = np.asarray(values, dtype=src_dtype)
+    x = dpt.asarray(x_np, sycl_queue=q)
+
+    expected = x_np.astype(dst_dtype)
+    res = dpt.astype(x, dst_dtype)
+    assert dpt.all(res == dpt.asarray(expected, sycl_queue=q))
+
+
 def test_copy():
     try:
         X = dpt.usm_ndarray((5, 5), "i4")[2:4, 1:4]
@@ -1350,7 +1350,7 @@ def test_full_dtype_inference():
     assert np.issubdtype(dpt.full(10, 0.3 - 2j, dtype=rdt).dtype, np.floating)
 
 
-@pytest.mark.parametrize("dt", ["f2", "f4", "f8"])
+@pytest.mark.parametrize("dt", _real_fp_dtypes)
 def test_full_special_fp(dt):
     """See gh-1314"""
     q = get_queue_or_skip()
@@ -1434,7 +1434,7 @@ def test_full_strides():
     assert np.array_equal(dpt.asnumpy(X), Xnp)
 
 
-@pytest.mark.parametrize("dt", ["i1", "u1", "i2", "u2", "i4", "u4", "i8", "u8"])
+@pytest.mark.parametrize("dt", _integral_dtypes)
 def test_full_gh_1230(dt):
     get_queue_or_skip()
     dtype = dpt.dtype(dt)
@@ -1551,7 +1551,7 @@ def test_linspace_fp():
     assert X.strides == (1,)
 
 
-@pytest.mark.parametrize("dtype", ["f2", "f4", "f8"])
+@pytest.mark.parametrize("dtype", _real_fp_dtypes)
 def test_linspace_fp_max(dtype):
     q = get_queue_or_skip()
     skip_if_dtype_not_supported(dtype, q)