Update interp tests to consider when xp.sin(fx) uses float16 precision

Author: antonwolfy

dpnp/tests/third_party/cupy/math_tests/test_misc.py

@@ -9,6 +9,27 @@
 
 
 class TestMisc:
+    @staticmethod
+    def _interp_atol(_result_dtype, dtype_x=None, **_kwargs):
+        """Compute absolute tolerance based on intermediate computation dtype.
+
+        Args:
+            _result_dtype: Output dtype (unused - we check input dtype instead)
+            dtype_x: Input dtype for fx coordinates
+            _kwargs: Additional test parameters (unused)
+
+        When dtype_x is int8/uint8/float16, xp.sin(fx) uses float16 precision,
+        so we need relaxed tolerance even if the final result is upcasted to float64.
+        Float16 has ~3 decimal digits of precision, hence atol=1e-3.
+        """
+        if dtype_x is not None:
+            if numpy.dtype(dtype_x).type in (
+                numpy.int8,
+                numpy.uint8,
+                numpy.float16,
+            ):
+                return 1e-3
+        return 1e-5
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
@@ -401,17 +422,22 @@ def test_real_if_close_with_float_tol_false(self, xp, dtype):
 
     @testing.for_all_dtypes(name="dtype_x", no_bool=True, no_complex=True)
     @testing.for_all_dtypes(name="dtype_y", no_bool=True)
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
+        # tolerance is automatically adjusted based on dtype_x via resolver
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
         fx = xp.asarray([1, 3, 5, 7, 9], dtype=dtype_x)
         fy = xp.sin(fx).astype(dtype_y)
         return xp.interp(x, fx, fy)
 
     @testing.for_all_dtypes(name="dtype_x", no_bool=True, no_complex=True)
     @testing.for_all_dtypes(name="dtype_y", no_bool=True)
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_period(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -421,7 +447,9 @@ def test_interp_period(self, xp, dtype_y, dtype_x):
 
     @testing.for_all_dtypes(name="dtype_x", no_bool=True, no_complex=True)
     @testing.for_all_dtypes(name="dtype_y", no_bool=True)
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_left_right(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -434,7 +462,9 @@ def test_interp_left_right(self, xp, dtype_y, dtype_x):
     @testing.with_requires("numpy>=1.17.0")
     @testing.for_all_dtypes(name="dtype_x", no_bool=True, no_complex=True)
     @testing.for_dtypes("efdFD", name="dtype_y")
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_nan_fy(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -446,7 +476,9 @@ def test_interp_nan_fy(self, xp, dtype_y, dtype_x):
     @testing.with_requires("numpy>=1.17.0")
     @testing.for_float_dtypes(name="dtype_x")
     @testing.for_dtypes("efdFD", name="dtype_y")
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_nan_fx(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -458,7 +490,9 @@ def test_interp_nan_fx(self, xp, dtype_y, dtype_x):
     @testing.with_requires("numpy>=1.17.0")
     @testing.for_float_dtypes(name="dtype_x")
     @testing.for_dtypes("efdFD", name="dtype_y")
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_nan_x(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -470,7 +504,9 @@ def test_interp_nan_x(self, xp, dtype_y, dtype_x):
     @testing.with_requires("numpy>=1.17.0")
     @testing.for_all_dtypes(name="dtype_x", no_bool=True, no_complex=True)
     @testing.for_dtypes("efdFD", name="dtype_y")
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_inf_fy(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -482,7 +518,9 @@ def test_interp_inf_fy(self, xp, dtype_y, dtype_x):
     @testing.with_requires("numpy>=1.17.0")
     @testing.for_float_dtypes(name="dtype_x")
     @testing.for_dtypes("efdFD", name="dtype_y")
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_inf_fx(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -494,7 +532,9 @@ def test_interp_inf_fx(self, xp, dtype_y, dtype_x):
     @testing.with_requires("numpy>=1.17.0")
     @testing.for_float_dtypes(name="dtype_x")
     @testing.for_dtypes("efdFD", name="dtype_y")
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_inf_x(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -505,7 +545,9 @@ def test_interp_inf_x(self, xp, dtype_y, dtype_x):
 
     @testing.for_all_dtypes(name="dtype_x", no_bool=True, no_complex=True)
     @testing.for_all_dtypes(name="dtype_y", no_bool=True)
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_size1(self, xp, dtype_y, dtype_x):
         # interpolate at points on and outside the boundaries
         x = xp.asarray([0, 1, 2, 4, 6, 8, 9, 10], dtype=dtype_x)
@@ -518,7 +560,9 @@ def test_interp_size1(self, xp, dtype_y, dtype_x):
     @testing.with_requires("numpy>=1.17.0")
     @testing.for_float_dtypes(name="dtype_x")
     @testing.for_dtypes("efdFD", name="dtype_y")
-    @testing.numpy_cupy_allclose(atol=1e-5, type_check=has_support_aspect64())
+    @testing.numpy_cupy_allclose(
+        atol=_interp_atol, type_check=has_support_aspect64()
+    )
     def test_interp_inf_to_nan(self, xp, dtype_y, dtype_x):
         # from NumPy's test_non_finite_inf
         x = xp.asarray([0.5], dtype=dtype_x)

dpnp/tests/third_party/cupy/testing/_loops.py

@@ -410,7 +410,7 @@ def test_func(*args, **kw):
                         numpy_r = numpy_r[mask]
 
                 if not skip:
-                    check_func(cupy_r, numpy_r)
+                    check_func(cupy_r, numpy_r, **kw)
 
         return test_func
 
@@ -469,6 +469,9 @@ def _convert_output_to_ndarray(c_out, n_out, sp_name, check_sparse_format):
 
 def _check_tolerance_keys(rtol, atol):
     def _check(tol):
+        if callable(tol):
+            # Callable tolerance is allowed
+            return
         if isinstance(tol, dict):
             for k in tol.keys():
                 if type(k) is type:
@@ -486,9 +489,13 @@ def _check(tol):
     _check(atol)
 
 
-def _resolve_tolerance(type_check, result, rtol, atol):
+def _resolve_tolerance(type_check, result, rtol, atol, **test_kwargs):
     def _resolve(dtype, tol):
-        if isinstance(tol, dict):
+        if callable(tol):
+            # Support callable tolerance that can inspect test kwargs
+            return tol(dtype, **test_kwargs)
+        elif isinstance(tol, dict):
+            # Original dict lookup logic
             tol1 = tol.get(dtype.type)
             if tol1 is None:
                 tol1 = tol.get("default")
@@ -523,13 +530,15 @@ def numpy_cupy_allclose(
     """Decorator that checks NumPy results and CuPy ones are close.
 
     Args:
-         rtol(float or dict): Relative tolerance. Besides a float value, a
-             dictionary that maps a dtypes to a float value can be supplied to
-             adjust tolerance per dtype. If the dictionary has ``'default'``
-             string as its key, its value is used as the default tolerance in
-             case any dtype keys do not match.
-         atol(float or dict): Absolute tolerance. Besides a float value, a
-             dictionary can be supplied as ``rtol``.
+         rtol(float, dict, or callable): Relative tolerance. Can be:
+             - A float value
+             - A dictionary that maps dtypes to float values. If the dictionary
+               has ``'default'`` string as its key, its value is used as the
+               default tolerance in case any dtype keys do not match.
+             - A callable with signature ``(dtype, **test_kwargs)`` that returns
+               a float. This allows dynamic tolerance based on test parameters
+               like input dtypes.
+         atol(float, dict, or callable): Absolute tolerance. Same options as ``rtol``.
          err_msg(str): The error message to be printed in case of failure.
          verbose(bool): If ``True``, the conflicting values are
              appended to the error message.
@@ -583,8 +592,10 @@ def numpy_cupy_allclose(
     #             "must be supplied as float."
     #         )
 
-    def check_func(c, n):
-        rtol1, atol1 = _resolve_tolerance(type_check, c, rtol, atol)
+    def check_func(c, n, **test_kwargs):
+        rtol1, atol1 = _resolve_tolerance(
+            type_check, c, rtol, atol, **test_kwargs
+        )
         _array.assert_allclose(
             c, n, rtol1, atol1, err_msg=err_msg, verbose=verbose
         )
@@ -641,7 +652,7 @@ def numpy_cupy_array_almost_equal(
     .. seealso:: :func:`cupy.testing.assert_array_almost_equal`
     """
 
-    def check_func(x, y):
+    def check_func(x, y, **test_kwargs):
         _array.assert_array_almost_equal(x, y, decimal, err_msg, verbose)
 
     return _make_decorator(
@@ -684,7 +695,7 @@ def numpy_cupy_array_almost_equal_nulp(
     .. seealso:: :func:`cupy.testing.assert_array_almost_equal_nulp`
     """
 
-    def check_func(x, y):
+    def check_func(x, y, **test_kwargs):
         _array.assert_array_almost_equal_nulp(x, y, nulp)
 
     return _make_decorator(
@@ -738,7 +749,7 @@ def numpy_cupy_array_max_ulp(
 
     """
 
-    def check_func(x, y):
+    def check_func(x, y, **test_kwargs):
         _array.assert_array_max_ulp(x, y, maxulp, dtype)
 
     return _make_decorator(
@@ -787,7 +798,7 @@ def numpy_cupy_array_equal(
     .. seealso:: :func:`cupy.testing.assert_array_equal`
     """
 
-    def check_func(x, y):
+    def check_func(x, y, **test_kwargs):
         _array.assert_array_equal(
             x, y, err_msg, verbose, strides_check=strides_check
         )
@@ -826,7 +837,7 @@ def numpy_cupy_array_list_equal(
         DeprecationWarning,
     )
 
-    def check_func(x, y):
+    def check_func(x, y, **test_kwargs):
         _array.assert_array_equal(x, y, err_msg, verbose)
 
     return _make_decorator(
@@ -871,7 +882,7 @@ def numpy_cupy_array_less(
     .. seealso:: :func:`cupy.testing.assert_array_less`
     """
 
-    def check_func(x, y):
+    def check_func(x, y, **test_kwargs):
         _array.assert_array_less(x, y, err_msg, verbose)
 
     return _make_decorator(