Apply review comments

Author: AlexanderKalistratov

dpnp/dpnp_iface_statistics.py

@@ -447,7 +447,7 @@ def _get_padding(a_size, v_size, mode):
         r_pad = v_size - l_pad - 1
     elif mode == "full":
         l_pad, r_pad = v_size - 1, v_size - 1
-    else:
+    else:  # pragma: no cover
         raise ValueError(
             f"Unknown mode: {mode}. Only 'valid', 'same', 'full' are supported."
         )
@@ -458,9 +458,11 @@ def _get_padding(a_size, v_size, mode):
 def _choose_conv_method(a, v, rdtype):
     assert a.size >= v.size
     if rdtype == dpnp.bool:
+        # to avoid accuracy issues
         return "direct"
 
     if v.size < 10**4 or a.size < 10**4:
+        # direct method is faster for small arrays
         return "direct"
 
     if dpnp.issubdtype(rdtype, dpnp.integer):
@@ -470,12 +472,13 @@ def _choose_conv_method(a, v, rdtype):
 
         default_float = dpnp.default_float_type(a.sycl_device)
         if max_value > 2 ** numpy.finfo(default_float).nmant - 1:
+            # can't represent the result in the default float type
             return "direct"
 
     if dpnp.issubdtype(rdtype, dpnp.number):
         return "fft"
 
-    raise ValueError(f"Unsupported dtype: {rdtype}")
+    raise ValueError(f"Unsupported dtype: {rdtype}")  # pragma: no cover
 
 
 def _run_native_sliding_dot_product1d(a, v, l_pad, r_pad, rdtype):
@@ -485,7 +488,7 @@ def _run_native_sliding_dot_product1d(a, v, l_pad, r_pad, rdtype):
     supported_types = statistics_ext.sliding_dot_product1d_dtypes()
     supported_dtype = to_supported_dtypes(rdtype, supported_types, device)
 
-    if supported_dtype is None:
+    if supported_dtype is None:  # pragma: no cover
         raise ValueError(
             f"function does not support input types "
             f"({a.dtype.name}, {v.dtype.name}), "
@@ -676,7 +679,7 @@ def correlate(a, v, mode="valid", method="auto"):
         r = _run_native_sliding_dot_product1d(a, v, l_pad, r_pad, rdtype)
     elif method == "fft":
         r = _convolve_fft(a, v[::-1], l_pad, r_pad, rdtype)
-    else:
+    else:  # pragma: no cover
         raise ValueError(f"Unknown method: {method}")
 
     if revert:

dpnp/tests/test_statistics.py

@@ -583,6 +583,17 @@ def test_corrcoef_scalar(self):
 
 
 class TestCorrelate:
+    @staticmethod
+    def _get_kwargs(mode=None, method=None):
+        dpnp_kwargs = {}
+        numpy_kwargs = {}
+        if mode is not None:
+            dpnp_kwargs["mode"] = mode
+            numpy_kwargs["mode"] = mode
+        if method is not None:
+            dpnp_kwargs["method"] = method
+        return dpnp_kwargs, numpy_kwargs
+
     def setup_method(self):
         numpy.random.seed(0)
 
@@ -598,13 +609,7 @@ def test_correlate(self, a, v, mode, dtype, method):
         ad = dpnp.array(an)
         vd = dpnp.array(vn)
 
-        dpnp_kwargs = {}
-        numpy_kwargs = {}
-        if mode is not None:
-            dpnp_kwargs["mode"] = mode
-            numpy_kwargs["mode"] = mode
-        if method is not None:
-            dpnp_kwargs["method"] = method
+        dpnp_kwargs, numpy_kwargs = self._get_kwargs(mode, method)
 
         expected = numpy.correlate(an, vn, **numpy_kwargs)
         result = dpnp.correlate(ad, vd, **dpnp_kwargs)
@@ -621,23 +626,17 @@ def test_correlate_random(self, a_size, v_size, mode, dtype, method):
             an = numpy.random.rand(a_size) > 0.9
             vn = numpy.random.rand(v_size) > 0.9
         else:
-            an = (100 * numpy.random.rand(a_size)).astype(dtype)
-            vn = (100 * numpy.random.rand(v_size)).astype(dtype)
+            an = 100 * numpy.random.rand(a_size).astype(dtype)
+            vn = 100 * numpy.random.rand(v_size).astype(dtype)
 
             if dpnp.issubdtype(dtype, dpnp.complexfloating):
-                an = an + 1j * (100 * numpy.random.rand(a_size)).astype(dtype)
-                vn = vn + 1j * (100 * numpy.random.rand(v_size)).astype(dtype)
+                an = an + 100j * numpy.random.rand(a_size).astype(dtype)
+                vn = vn + 100j * numpy.random.rand(v_size).astype(dtype)
 
         ad = dpnp.array(an)
         vd = dpnp.array(vn)
 
-        dpnp_kwargs = {}
-        numpy_kwargs = {}
-        if mode is not None:
-            dpnp_kwargs["mode"] = mode
-            numpy_kwargs["mode"] = mode
-        if method is not None:
-            dpnp_kwargs["method"] = method
+        dpnp_kwargs, numpy_kwargs = self._get_kwargs(mode, method)
 
         result = dpnp.correlate(ad, vd, **dpnp_kwargs)
         expected = numpy.correlate(an, vn, **numpy_kwargs)