align dpnp.fix with numpy 2.2

Author: Vahid Tavanashad

dpnp/backend/extensions/ufunc/elementwise_functions/fix.cpp

@@ -60,7 +60,15 @@ template <typename T>
 struct OutputType
 {
     using value_type =
-        typename std::disjunction<td_ns::TypeMapResultEntry<T, sycl::half>,
+        typename std::disjunction<td_ns::TypeMapResultEntry<T, std::uint8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::uint64_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int8_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int16_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int32_t>,
+                                  td_ns::TypeMapResultEntry<T, std::int64_t>,
+                                  td_ns::TypeMapResultEntry<T, sycl::half>,
                                   td_ns::TypeMapResultEntry<T, float>,
                                   td_ns::TypeMapResultEntry<T, double>,
                                   td_ns::DefaultResultEntry<void>>::result_type;

dpnp/backend/kernels/elementwise_functions/fix.hpp

@@ -43,7 +43,12 @@ struct FixFunctor
 
     resT operator()(const argT &x) const
     {
-        return (x >= 0.0) ? sycl::floor(x) : sycl::ceil(x);
+        if constexpr (std::is_integral_v<argT>) {
+            return x;
+        }
+        else {
+            return (x >= 0.0) ? sycl::floor(x) : sycl::ceil(x);
+        }
     }
 };
 } // namespace dpnp::kernels::fix

dpnp/dpnp_iface_mathematical.py

@@ -1728,14 +1728,14 @@ def ediff1d(ary, to_end=None, to_begin=None):
 Round to nearest integer towards zero.
 
 Round an array of floats element-wise to nearest integer towards zero.
-The rounded values are returned as floats.
+The rounded values have the same data-type as the input.
 
 For full documentation refer to :obj:`numpy.fix`.
 
 Parameters
 ----------
 x : {dpnp.ndarray, usm_ndarray}
-    An array of floats to be rounded.
+    Input array, expected to have a real-valued data type.
 out : {None, dpnp.ndarray, usm_ndarray}, optional
     Output array to populate.
     Array must have the correct shape and the expected data type.
@@ -1749,12 +1749,11 @@ def ediff1d(ary, to_end=None, to_begin=None):
 Returns
 -------
 out : dpnp.ndarray
-    An array with the rounded values and with the same dimensions as the input.
-    The returned array will have a floating point data type that input can cast
-    to it safely considering device capabilities.
-    If `out` is ``None`` then a float array is returned with the rounded values.
-    Otherwise the result is stored there and the return value `out` is
-    a reference to that array.
+    An array with the same dimensions and data-type as the input.
+    If second argument is not supplied then a new array is returned
+    with the rounded values.
+    If a second argument is supplied the result is stored there.
+    The return value `out` is then a reference to that array.
 
 Limitations
 -----------

dpnp/tests/test_mathematical.py

@@ -750,75 +750,6 @@ def test_errors(self):
         assert_raises(ExecutionPlacementError, dpnp.ediff1d, ia, to_end=to_end)
 
 
-class TestFix:
-    def get_numpy_output_dtype(self, dtype):
-        # this is used to determine the output dtype of numpy array
-        # which is on cpu so no need for checking has_support_aspect64
-        if has_support_aspect16() and dpnp.can_cast(dtype, dpnp.float16):
-            return dpnp.float16
-        if dpnp.can_cast(dtype, dpnp.float32):
-            return dpnp.float32
-        if dpnp.can_cast(dtype, dpnp.float64):
-            return dpnp.float64
-
-    @pytest.mark.parametrize(
-        "dt", get_all_dtypes(no_none=True, no_complex=True)
-    )
-    def test_basic(self, dt):
-        a = get_abs_array([[1.0, 1.1, 1.5, 1.8], [-1.0, -1.1, -1.5, -1.8]], dt)
-        ia = dpnp.array(a)
-
-        result = dpnp.fix(ia)
-        expected = numpy.fix(a)
-        assert_array_equal(result, expected)
-
-    @pytest.mark.parametrize("xp", [numpy, dpnp])
-    @pytest.mark.parametrize("dt", get_complex_dtypes())
-    def test_complex(self, xp, dt):
-        a = xp.array([1.1, -1.1], dtype=dt)
-        with pytest.raises((ValueError, TypeError)):
-            xp.fix(a)
-
-    @pytest.mark.parametrize(
-        "dt", get_all_dtypes(no_none=True, no_complex=True)
-    )
-    def test_out(self, dt):
-        data = [[1.0, 1.1, 1.5, 1.8], [-1.0, -1.1, -1.5, -1.8]]
-        a = get_abs_array(data, dtype=dt)
-        # numpy output has the same dtype as input
-        # dpnp output always has a floating point dtype
-        dt_out = self.get_numpy_output_dtype(a.dtype)
-        out = numpy.zeros_like(a, dtype=dt_out)
-        ia, iout = dpnp.array(a), dpnp.array(out)
-
-        result = dpnp.fix(ia, out=iout)
-        expected = numpy.fix(a, out=out)
-        assert_array_equal(result, expected)
-
-    @pytest.mark.skipif(not has_support_aspect16(), reason="no fp16 support")
-    def test_out_float16(self):
-        data = [[1.0, 1.1], [1.5, 1.8], [-1.0, -1.1], [-1.5, -1.8]]
-        a = numpy.array(data, dtype=numpy.float16)
-        out = numpy.zeros_like(a, dtype=numpy.float16)
-        ia, iout = dpnp.array(a), dpnp.array(out)
-
-        result = dpnp.fix(ia, out=iout)
-        expected = numpy.fix(a, out=out)
-        assert_array_equal(result, expected)
-
-    @pytest.mark.parametrize("xp", [numpy, dpnp])
-    @pytest.mark.parametrize("dt", [bool] + get_integer_dtypes())
-    def test_out_invalid_dtype(self, xp, dt):
-        a = xp.array([[1.5, 1.8], [-1.0, -1.1]])
-        out = xp.zeros_like(a, dtype=dt)
-
-        with pytest.raises((ValueError, TypeError)):
-            xp.fix(a, out=out)
-
-    def test_scalar(self):
-        assert_raises(TypeError, dpnp.fix, -3.4)
-
-
 class TestGradient:
     @pytest.mark.parametrize("dt", get_all_dtypes(no_none=True, no_bool=True))
     def test_basic(self, dt):
@@ -2274,50 +2205,81 @@ def test_projection(self, dtype):
         assert dpnp.allclose(result, expected)
 
 
-@pytest.mark.parametrize("func", ["ceil", "floor", "trunc"])
+@pytest.mark.parametrize("func", ["ceil", "floor", "trunc", "fix"])
 class TestRoundingFuncs:
     @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_none=True, no_complex=True)
+        "dt", get_all_dtypes(no_none=True, no_complex=True)
     )
-    def test_out(self, func, dtype):
-        a = generate_random_numpy_array(10, dtype)
+    def test_basic(self, func, dt):
+        a = generate_random_numpy_array((2, 4), dt)
+        ia = dpnp.array(a)
+
+        result = getattr(dpnp, func)(ia)
         expected = getattr(numpy, func)(a)
+        assert_array_equal(result, expected)
 
-        ia = dpnp.array(a)
-        out_dt = numpy.int8 if dtype == dpnp.bool else dtype
-        iout = dpnp.empty(expected.shape, dtype=out_dt)
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
+    @pytest.mark.parametrize("dt", get_complex_dtypes())
+    def test_complex(self, func, xp, dt):
+        a = xp.array([1.1, -1.1], dtype=dt)
+        with pytest.raises((ValueError, TypeError)):
+            getattr(xp, func)(a)
+
+    @testing.with_requires("numpy>=2.1.0")
+    @pytest.mark.parametrize(
+        "dt", get_all_dtypes(no_none=True, no_complex=True)
+    )
+    def test_out(self, func, dt):
+        a = generate_random_numpy_array(10, dt)
+        dt_out = numpy.int8 if dt == dpnp.bool else dt
+        out = numpy.empty(a.shape, dtype=dt_out)
+        ia, iout = dpnp.array(a), dpnp.array(out)
+
+        expected = getattr(numpy, func)(a, out=out)
         result = getattr(dpnp, func)(ia, out=iout)
+        assert result is iout
+        assert_array_equal(result, expected)
 
+    @pytest.mark.skipif(not has_support_aspect16(), reason="no fp16 support")
+    def test_out_float16(self, func):
+        a = generate_random_numpy_array((4, 2), numpy.float16)
+        out = numpy.zeros_like(a, dtype=numpy.float16)
+        ia, iout = dpnp.array(a), dpnp.array(out)
+
+        result = getattr(dpnp, func)(ia, out=iout)
+        expected = getattr(numpy, func)(a, out=out)
         assert result is iout
-        # numpy.ceil, numpy.floor, numpy.trunc always return float dtype for
-        # NumPy < 2.1.0 while output has the dtype of input for NumPy >= 2.1.0
-        # (dpnp follows the latter behavior except for boolean dtype where it
-        # returns int8)
-        if numpy_version() < "2.1.0" or dtype == dpnp.bool:
-            check_type = False
-        else:
-            check_type = True
-        assert_dtype_allclose(result, expected, check_type=check_type)
+        assert_array_equal(result, expected)
 
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_complex=True, no_none=True)[:-1]
+        "dt_out", get_all_dtypes(no_none=True, no_complex=True)[:-1]
     )
-    def test_invalid_dtype(self, func, dtype):
-        dpnp_dtype = get_all_dtypes(no_complex=True, no_none=True)[-1]
-        ia = dpnp.arange(10, dtype=dpnp_dtype)
-        iout = dpnp.empty(10, dtype=dtype)
-
-        with pytest.raises(ValueError):
-            getattr(dpnp, func)(ia, out=iout)
+    def test_invalid_dtype(self, func, xp, dt_out):
+        dt_in = get_all_dtypes(no_none=True, no_complex=True)[-1]
+        a = xp.arange(10, dtype=dt_in)
+        out = xp.empty(10, dtype=dt_out)
+        if dt_out == numpy.float32 and dt_in == numpy.float64:
+            if xp == dpnp:
+                # NumPy allows "same_kind" casting, dpnp does not
+                assert_raises(ValueError, getattr(dpnp, func), a, out=out)
+        else:
+            numpy_error = numpy._core._exceptions._UFuncOutputCastingError
+            assert_raises(
+                (ValueError, numpy_error), getattr(xp, func), a, out=out
+            )
 
+    @pytest.mark.parametrize("xp", [numpy, dpnp])
     @pytest.mark.parametrize(
         "shape", [(0,), (15,), (2, 2)], ids=["(0,)", "(15,)", "(2, 2)"]
     )
-    def test_invalid_shape(self, func, shape):
-        ia = dpnp.arange(10, dtype=dpnp.float32)
-        iout = dpnp.empty(shape, dtype=dpnp.float32)
+    def test_invalid_shape(self, func, xp, shape):
+        a = xp.arange(10, dtype=xp.float32)
+        out = xp.empty(shape, dtype=xp.float32)
+        assert_raises(ValueError, getattr(xp, func), a, out=out)
 
-        assert_raises(ValueError, getattr(dpnp, func), ia, out=iout)
+    def test_scalar(self, func):
+        assert_raises(TypeError, getattr(dpnp, func), -3.4)
 
 
 class TestHypot: