Review comments & cupy tests

Author: AlexanderKalistratov

dpnp/tests/helper.py

@@ -185,6 +185,19 @@ def generate_random_numpy_array(
     return a
 
 
+def factor_to_tol(dtype, factor):
+    """
+    Calculate the tolerance for comparing floating point and complex arrays.
+    The tolerance is based on the maximum resolution of the input dtype multiplied by the factor.
+    """
+
+    tol = 0
+    if numpy.issubdtype(dtype, numpy.inexact):
+        tol = numpy.finfo(dtype).resolution
+
+    return factor * tol
+
+
 def get_abs_array(data, dtype=None):
     if numpy.issubdtype(dtype, numpy.unsignedinteger):
         data = numpy.abs(data)

dpnp/tests/test_statistics.py

@@ -13,6 +13,7 @@
 
 from .helper import (
     assert_dtype_allclose,
+    factor_to_tol,
     generate_random_numpy_array,
     get_all_dtypes,
     get_complex_dtypes,
@@ -210,30 +211,30 @@ def test_convolve_random(self, a_size, v_size, mode, dtype, method):
 
                 result = result.astype(rdtype)
 
-                rtol = 1e-3
-                atol = 1e-10
-
-                if rdtype == dpnp.float64 or rdtype == dpnp.complex128:
-                    rtol = 1e-6
-                    atol = 1e-12
-                elif rdtype == dpnp.bool:
+                if rdtype == dpnp.bool:
                     result = result.astype(dpnp.int32)
                     rdtype = result.dtype
 
                 expected = expected.astype(rdtype)
 
-                diff = numpy.abs(result.asnumpy() - expected)
-                invalid = diff > atol + rtol * numpy.abs(expected)
+                factor = 1000
+                rtol = atol = factor_to_tol(rdtype, factor)
+                invalid = numpy.logical_not(
+                    numpy.isclose(
+                        result.asnumpy(), expected, rtol=rtol, atol=atol
+                    )
+                )
 
                 # When using the 'fft' method, we might encounter outliers.
                 # This usually happens when the resulting array contains values close to zero.
                 # For these outliers, the relative error can be significant.
                 # We can tolerate a few such outliers.
-                max_outliers = 8 if expected.size > 1 else 0
+                # max_outliers = 10 if expected.size > 1 else 0
+                max_outliers = 10
                 if invalid.sum() > max_outliers:
                     # we already failed check,
                     # call assert_dtype_allclose just to report error nicely
-                    assert_dtype_allclose(result, expected, factor=1000)
+                    assert_dtype_allclose(result, expected, factor=factor)
 
     def test_convolve_mode_error(self):
         a = dpnp.arange(5)
@@ -446,30 +447,30 @@ def test_correlate_random(self, a_size, v_size, mode, dtype, method):
 
                 result = result.astype(rdtype)
 
-                rtol = 1e-3
-                atol = 1e-3
-
-                if rdtype == dpnp.float64 or rdtype == dpnp.complex128:
-                    rtol = 1e-6
-                    atol = 1e-6
-                elif rdtype == dpnp.bool:
+                if rdtype == dpnp.bool:
                     result = result.astype(dpnp.int32)
                     rdtype = result.dtype
 
                 expected = expected.astype(rdtype)
 
-                diff = numpy.abs(result.asnumpy() - expected)
-                invalid = diff > atol + rtol * numpy.abs(expected)
+                factor = 1000
+                rtol = atol = factor_to_tol(rdtype, factor)
+                invalid = numpy.logical_not(
+                    numpy.isclose(
+                        result.asnumpy(), expected, rtol=rtol, atol=atol
+                    )
+                )
 
                 # When using the 'fft' method, we might encounter outliers.
                 # This usually happens when the resulting array contains values close to zero.
                 # For these outliers, the relative error can be significant.
                 # We can tolerate a few such outliers.
-                max_outliers = 10 if expected.size > 1 else 0
+                # max_outliers = 10 if expected.size > 1 else 0
+                max_outliers = 10
                 if invalid.sum() > max_outliers:
                     # we already failed check,
                     # call assert_dtype_allclose just to report error nicely
-                    assert_dtype_allclose(result, expected, factor=1000)
+                    assert_dtype_allclose(result, expected, factor=factor)
 
     def test_correlate_mode_error(self):
         a = dpnp.arange(5)

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

@@ -531,7 +531,7 @@ def test_heaviside_nan_inf(self, xp, dtype_1, dtype_2):
         }
     )
 )
-@pytest.mark.skip("convolve() is not implemented yet")
+# @pytest.mark.skip("convolve() is not implemented yet")
 class TestConvolveShapeCombination:
 
     @testing.for_all_dtypes(no_float16=True)
@@ -542,40 +542,39 @@ def test_convolve(self, xp, dtype):
         return xp.convolve(a, b, mode=self.mode)
 
 
-@pytest.mark.skip("convolve() is not implemented yet")
+# @pytest.mark.skip("convolve() is not implemented yet")
 @pytest.mark.parametrize("mode", ["valid", "same", "full"])
 class TestConvolve:
 
     @testing.for_all_dtypes(no_float16=True)
-    @testing.numpy_cupy_allclose(rtol=1e-6)
+    @testing.numpy_cupy_allclose(rtol=1e-6, type_check=has_support_aspect64())
     def test_convolve_non_contiguous(self, xp, dtype, mode):
         a = testing.shaped_arange((300,), xp, dtype)
         b = testing.shaped_arange((100,), xp, dtype)
         return xp.convolve(a[::200], b[10::70], mode=mode)
 
     @testing.for_all_dtypes(no_float16=True)
-    @testing.numpy_cupy_allclose(rtol=5e-4)
+    @testing.numpy_cupy_allclose(rtol=5e-4, type_check=has_support_aspect64())
     def test_convolve_large_non_contiguous(self, xp, dtype, mode):
         a = testing.shaped_arange((10000,), xp, dtype)
         b = testing.shaped_arange((100,), xp, dtype)
         return xp.convolve(a[200::], b[10::70], mode=mode)
 
     @testing.for_all_dtypes_combination(names=["dtype1", "dtype2"])
-    @testing.numpy_cupy_allclose(rtol=1e-2)
+    @testing.numpy_cupy_allclose(rtol=1e-2, type_check=has_support_aspect64())
     def test_convolve_diff_types(self, xp, dtype1, dtype2, mode):
         a = testing.shaped_random((200,), xp, dtype1)
         b = testing.shaped_random((100,), xp, dtype2)
         return xp.convolve(a, b, mode=mode)
 
 
-@pytest.mark.skip("convolve() is not implemented yet")
 @testing.parameterize(*testing.product({"mode": ["valid", "same", "full"]}))
 class TestConvolveInvalid:
 
     @testing.for_all_dtypes()
     def test_convolve_empty(self, dtype):
         for xp in (numpy, cupy):
-            a = xp.zeros((0,), dtype)
+            a = xp.zeros((0,), dtype=dtype)
             with pytest.raises(ValueError):
                 xp.convolve(a, a, mode=self.mode)