Add tests to cover

Author: antonwolfy

dpnp/tests/test_special.py

@@ -14,18 +14,19 @@
 
 
 @with_requires("scipy")
-class TestErf:
+@pytest.mark.parametrize("func", ["erf", "erfc"])
+class TestCommon:
     @pytest.mark.parametrize(
         "dt", get_all_dtypes(no_none=True, no_float16=False, no_complex=True)
     )
-    def test_basic(self, dt):
+    def test_basic(self, func, dt):
         import scipy.special
 
         a = generate_random_numpy_array((2, 5), dtype=dt)
         ia = dpnp.array(a)
 
-        result = dpnp.special.erf(ia)
-        expected = scipy.special.erf(a)
+        result = getattr(dpnp.special, func)(ia)
+        expected = getattr(scipy.special, func)(a)
 
         # scipy >= 0.16.0 returns float64, but dpnp returns float32
         to_float32 = dt in (dpnp.bool, dpnp.float16)
@@ -34,29 +35,48 @@ def test_basic(self, dt):
             result, expected, check_only_type_kind=only_type_kind
         )
 
-    def test_nan_inf(self):
+    def test_nan_inf(self, func):
         import scipy.special
 
         a = numpy.array([numpy.nan, -numpy.inf, numpy.inf])
         ia = dpnp.array(a)
 
-        result = dpnp.special.erf(ia)
-        expected = scipy.special.erf(a)
+        result = getattr(dpnp.special, func)(ia)
+        expected = getattr(scipy.special, func)(a)
         assert_allclose(result, expected)
 
-    def test_zeros(self):
+    def test_zeros(self, func):
         import scipy.special
 
         a = numpy.array([0.0, -0.0])
         ia = dpnp.array(a)
 
-        result = dpnp.special.erf(ia)
-        expected = scipy.special.erf(a)
+        result = getattr(dpnp.special, func)(ia)
+        expected = getattr(scipy.special, func)(a)
         assert_allclose(result, expected)
         assert_equal(dpnp.signbit(result), numpy.signbit(expected))
 
     @pytest.mark.parametrize("dt", get_complex_dtypes())
-    def test_complex(self, dt):
+    def test_complex(self, func, dt):
         x = dpnp.empty(5, dtype=dt)
         with pytest.raises(ValueError):
-            dpnp.special.erf(x)
+            getattr(dpnp.special, func)(x)
+
+
+class TestConsistency:
+
+    def test_erfc(self):
+        # TODO: replace with dpnp.random.RandomState, once pareto is added
+        rng = numpy.random.RandomState(1234)
+        n = 10000
+        a = rng.pareto(0.02, n) * (2 * rng.randint(0, 2, n) - 1)
+        a = dpnp.array(a)
+
+        res = 1 - dpnp.special.erf(a)
+        mask = dpnp.isfinite(res)
+        a = a[mask]
+
+        tol = 8 * dpnp.finfo(a).resolution
+        assert dpnp.allclose(
+            dpnp.special.erfc(a), res[mask], rtol=tol, atol=tol
+        )

dpnp/tests/test_strides.py

@@ -17,7 +17,7 @@
     get_integer_float_dtypes,
     numpy_version,
 )
-from .third_party.cupy.testing import installed, with_requires
+from .third_party.cupy.testing import with_requires
 
 
 @pytest.mark.usefixtures("suppress_divide_invalid_numpy_warnings")
@@ -167,20 +167,17 @@ def test_reduce_hypot(dtype, stride):
 
 
 @with_requires("scipy")
-@pytest.mark.parametrize("dtype", get_float_dtypes(no_float16=False))
+@pytest.mark.parametrize("func", ["erf", "erfc"])
 @pytest.mark.parametrize("stride", [2, -1, -3])
-def test_erf(dtype, stride):
+def test_erf_funcs(func, stride):
     import scipy.special
 
-    x = generate_random_numpy_array(10, dtype=dtype)
+    x = generate_random_numpy_array(10)
     a, ia = x[::stride], dpnp.array(x)[::stride]
 
-    result = dpnp.special.erf(ia)
-    expected = scipy.special.erf(a)
-
-    # scipy >= 0.16.0 returns float64, but dpnp returns float32
-    only_type_kind = installed("scipy>=0.16.0") and (dtype == dpnp.float16)
-    assert_dtype_allclose(result, expected, check_only_type_kind=only_type_kind)
+    result = getattr(dpnp.special, func)(ia)
+    expected = getattr(scipy.special, func)(a)
+    assert_dtype_allclose(result, expected)
 
 
 @pytest.mark.filterwarnings("ignore::RuntimeWarning")

dpnp/tests/test_sycl_queue.py

@@ -1488,11 +1488,12 @@ def test_interp(device, left, right, period):
     assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue)
 
 
+@pytest.mark.parametrize("func", ["erf", "erfc"])
 @pytest.mark.parametrize("device", valid_dev, ids=dev_ids)
-def test_erf(device):
+def test_erf_funcs(func, device):
     x = dpnp.linspace(-3, 3, num=5, device=device)
 
-    result = dpnp.special.erf(x)
+    result = getattr(dpnp.special, func)(x)
     assert_sycl_queue_equal(result.sycl_queue, x.sycl_queue)
 
 

dpnp/tests/test_usm_type.py

@@ -1296,10 +1296,11 @@ def test_choose(usm_type_x, usm_type_ind):
     assert z.usm_type == du.get_coerced_usm_type([usm_type_x, usm_type_ind])
 
 
+@pytest.mark.parametrize("func", ["erf", "erfc"])
 @pytest.mark.parametrize("usm_type", list_of_usm_types)
-def test_erf(usm_type):
+def test_erf_funcs(func, usm_type):
     x = dpnp.linspace(-3, 3, num=5, usm_type=usm_type)
-    y = dpnp.special.erf(x)
+    y = getattr(dpnp.special, func)(x)
     assert x.usm_type == y.usm_type == usm_type
 
 

dpnp/tests/third_party/cupyx/scipy_tests/special_tests/test_erf.py

@@ -19,11 +19,10 @@ def _boundary_inputs(boundary, rtol, atol):
 @testing.with_requires("scipy")
 class _TestBase:
 
-    # @testing.with_requires('scipy>=1.16.0')
+    @testing.with_requires("scipy>=1.16.0")
     def test_erf(self):
         self.check_unary("erf")
 
-    @pytest.mark.skip("erfc() is not supported yet")
     @testing.with_requires("scipy>=1.16.0")
     def test_erfc(self):
         self.check_unary("erfc")