Add more tests to cover function

Author: antonwolfy

dpnp/dpnp_iface_statistics.py

@@ -782,13 +782,17 @@ def cov(
     fweights : {None, dpnp.ndarray, usm_ndarray}, optional
         1-D array of integer frequency weights; the number of times each
         observation vector should be repeated.
+        It is required that ``fweights >= 0``. However, the function will not
+        error when ``fweights < 0`` for performance reasons.
 
         Default: ``None``.
     aweights : {None, dpnp.ndarray, usm_ndarray}, optional
         1-D array of observation vector weights. These relative weights are
         typically large for observations considered "important" and smaller for
         observations considered less "important". If ``ddof=0`` the array of
         weights can be used to assign probabilities to observation vectors.
+        It is required that ``aweights >= 0``. However, the function will not
+        error when ``aweights < 0`` for performance reasons.
 
         Default: ``None``.
     dtype : data-type, optional
@@ -895,7 +899,7 @@ def cov(
         fweights = dpnp.astype(fweights, dtype=def_float)
 
     if aweights is not None:
-        dpnp.check_supported_arrays_type(fweights)
+        dpnp.check_supported_arrays_type(aweights)
         if aweights.ndim > 1:
             raise ValueError("cannot handle multidimensional aweights")
 

dpnp/dpnp_utils/dpnp_utils_statistics.py

@@ -141,8 +141,7 @@ def _get_2dmin_array(x):
             x = dpnp.reshape(x, (1, 1))
         elif x.ndim == 1:
             x = x[dpnp.newaxis, :]
-
-        if not rowvar and x.ndim != 1:
+        elif not rowvar:
             x = x.T
 
         if x.dtype != dtype:

dpnp/tests/test_statistics.py

@@ -5,6 +5,7 @@
 from numpy.testing import (
     assert_allclose,
     assert_array_equal,
+    assert_raises,
     assert_raises_regex,
 )
 
@@ -14,7 +15,9 @@
     assert_dtype_allclose,
     generate_random_numpy_array,
     get_all_dtypes,
+    get_complex_dtypes,
     get_float_complex_dtypes,
+    get_float_dtypes,
     has_support_aspect64,
     numpy_version,
 )
@@ -337,14 +340,197 @@ def test_correlate_unkown_method(self):
 
 class TestCov:
     @pytest.mark.parametrize(
-        "dtype", get_all_dtypes(no_bool=True, no_none=True, no_complex=True)
+        "dt", get_all_dtypes(no_none=True, no_complex=True)
     )
-    def test_false_rowvar_dtype(self, dtype):
-        a = numpy.array([[0, 2], [1, 1], [2, 0]], dtype=dtype)
+    def test_basic(self, dt):
+        a = numpy.array([[0, 2], [1, 1], [2, 0]], dtype=dt)
         ia = dpnp.array(a)
 
-        assert_allclose(dpnp.cov(ia.T), dpnp.cov(ia, rowvar=False))
-        assert_allclose(dpnp.cov(ia, rowvar=False), numpy.cov(a, rowvar=False))
+        expected = numpy.cov(a.T)
+        result = dpnp.cov(ia.T)
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize("dt", get_complex_dtypes())
+    def test_complex(self, dt):
+        a = numpy.array([[1, 2, 3], [1j, 2j, 3j]], dtype=dt)
+        ia = dpnp.array(a)
+
+        expected = numpy.cov(a)
+        result = dpnp.cov(ia)
+        assert_allclose(result, expected)
+
+        expected = numpy.cov(a, aweights=numpy.ones(3))
+        result = dpnp.cov(ia, aweights=dpnp.ones(3))
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize(
+        "dt", get_all_dtypes(no_none=True, no_complex=True)
+    )
+    @pytest.mark.parametrize("y_dt", get_complex_dtypes())
+    def test_y(self, dt, y_dt):
+        a = numpy.array([[1, 2, 3]], dtype=dt)
+        y = numpy.array([[1j, 2j, 3j]], dtype=y_dt)
+        ia, iy = dpnp.array(a), dpnp.array(y)
+
+        expected = numpy.cov(a, y)
+        result = dpnp.cov(ia, iy)
+        assert_allclose(result, expected)
+
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    @pytest.mark.parametrize("sh", [None, (0, 2), (2, 0)])
+    def test_empty(self, sh):
+        a = numpy.array([]).reshape(sh)
+        ia = dpnp.array(a)
+
+        expected = numpy.cov(a)
+        result = dpnp.cov(ia)
+        assert_allclose(result, expected)
+
+    @pytest.mark.filterwarnings("ignore::RuntimeWarning")
+    def test_wrong_ddof(self):
+        a = numpy.array([[0, 2], [1, 1], [2, 0]])
+        ia = dpnp.array(a)
+
+        expected = numpy.cov(a.T, ddof=5)
+        result = dpnp.cov(ia.T, ddof=5)
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize("dt", get_float_dtypes())
+    @pytest.mark.parametrize("rowvar", [True, False])
+    def test_1D_rowvar(self, dt, rowvar):
+        a = numpy.array([0.3942, 0.5969, 0.7730, 0.9918, 0.7964], dtype=dt)
+        y = numpy.array([0.0780, 0.3107, 0.2111, 0.0334, 0.8501])
+        ia, iy = dpnp.array(a), dpnp.array(y)
+
+        expected = numpy.cov(a, rowvar=rowvar)
+        result = dpnp.cov(ia, rowvar=rowvar)
+        assert_allclose(result, expected)
+
+        expected = numpy.cov(a, y, rowvar=rowvar)
+        result = dpnp.cov(ia, iy, rowvar=rowvar)
+        assert_allclose(result, expected)
+
+    def test_1D_variance(self):
+        a = numpy.array([0.3942, 0.5969, 0.7730, 0.9918, 0.7964])
+        ia = dpnp.array(a)
+
+        expected = numpy.cov(a, ddof=1)
+        result = dpnp.cov(ia, ddof=1)
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize("freq_data", [[1, 4, 1], [1, 1, 1]])
+    def test_fweights(self, freq_data):
+        a = numpy.array([0.0, 1.0, 2.0], ndmin=2)
+        freq = numpy.array(freq_data)
+        ia, ifreq = dpnp.array(a), dpnp.array(freq_data)
+
+        expected = numpy.cov(a, fweights=freq)
+        result = dpnp.cov(ia, fweights=ifreq)
+        assert_allclose(result, expected)
+
+        a = numpy.array([[0, 2], [1, 1], [2, 0]])
+        ia = dpnp.array(a)
+
+        expected = numpy.cov(a.T, fweights=freq)
+        result = dpnp.cov(ia.T, fweights=ifreq)
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize("xp", [dpnp, numpy])
+    def test_float_fweights(self, xp):
+        a = xp.array([[0, 2], [1, 1], [2, 0]])
+        freq = xp.array([1, 4, 1]) + 0.5
+        assert_raises(TypeError, xp.cov, a, fweights=freq)
+
+    @pytest.mark.parametrize("xp", [dpnp, numpy])
+    @pytest.mark.parametrize("sh", [(2, 3), 2])
+    def test_fweights_wrong_shapes(self, xp, sh):
+        a = xp.array([[0, 2], [1, 1], [2, 0]])
+        freq = xp.ones(sh, dtype=xp.int_)
+        assert_raises((ValueError, RuntimeError), xp.cov, a.T, fweights=freq)
+
+    @pytest.mark.parametrize("freq", [numpy.array([1, 4, 1]), 2])
+    def test_fweights_wrong_type(self, freq):
+        a = dpnp.array([[0, 2], [1, 1], [2, 0]]).T
+        assert_raises(TypeError, dpnp.cov, a, fweights=freq)
+
+    @pytest.mark.parametrize("weights_data", [[1.0, 4.0, 1.0], [1.0, 1.0, 1.0]])
+    def test_aweights(self, weights_data):
+        a = numpy.array([[0, 2], [1, 1], [2, 0]])
+        weights = numpy.array(weights_data)
+        ia, iweights = dpnp.array(a), dpnp.array(weights_data)
+
+        expected = numpy.cov(a.T, aweights=weights)
+        result = dpnp.cov(ia.T, aweights=iweights)
+        assert_allclose(result, expected)
+
+        expected = numpy.cov(a.T, aweights=3.0 * weights)
+        result = dpnp.cov(ia.T, aweights=3.0 * iweights)
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize("xp", [dpnp, numpy])
+    @pytest.mark.parametrize("sh", [(2, 3), 2])
+    def test_aweights_wrong_shapes(self, xp, sh):
+        a = xp.array([[0, 2], [1, 1], [2, 0]])
+        weights = xp.ones(sh)
+        assert_raises((ValueError, RuntimeError), xp.cov, a.T, aweights=weights)
+
+    @pytest.mark.parametrize("weights", [numpy.array([1.0, 4.0, 1.0]), 2.0])
+    def test_aweights_wrong_type(self, weights):
+        a = dpnp.array([[0, 2], [1, 1], [2, 0]]).T
+        assert_raises(TypeError, dpnp.cov, a, aweights=weights)
+
+    def test_unit_fweights_and_aweights(self):
+        a = numpy.array([0.0, 1.0, 2.0], ndmin=2)
+        freq = numpy.array([1, 4, 1])
+        weights = numpy.ones(3)
+        ia, ifreq, iweights = (
+            dpnp.array(a),
+            dpnp.array(freq),
+            dpnp.array(weights),
+        )
+
+        # unit weights
+        expected = numpy.cov(a, fweights=freq, aweights=weights)
+        result = dpnp.cov(ia, fweights=ifreq, aweights=iweights)
+        assert_allclose(result, expected)
+
+        a = numpy.array([[0, 2], [1, 1], [2, 0]])
+        ia = dpnp.array(a)
+
+        # unit weights
+        expected = numpy.cov(a.T, fweights=freq, aweights=weights)
+        result = dpnp.cov(ia.T, fweights=ifreq, aweights=iweights)
+        assert_allclose(result, expected)
+
+        freq = numpy.ones(3, dtype=numpy.int_)
+        ifreq = dpnp.array(freq)
+
+        # unit frequencies and weights
+        expected = numpy.cov(a.T, fweights=freq, aweights=weights)
+        result = dpnp.cov(ia.T, fweights=ifreq, aweights=iweights)
+        assert_allclose(result, expected)
+
+        weights = numpy.array([1.0, 4.0, 1.0])
+        iweights = dpnp.array(weights)
+
+        # unit frequencies
+        expected = numpy.cov(a.T, fweights=freq, aweights=weights)
+        result = dpnp.cov(ia.T, fweights=ifreq, aweights=iweights)
+        assert_allclose(result, expected)
+
+        expected = numpy.cov(a.T, fweights=freq, aweights=3.0 * weights)
+        result = dpnp.cov(ia.T, fweights=ifreq, aweights=3.0 * iweights)
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize("dt", get_float_complex_dtypes())
+    def test_dtype(self, dt):
+        a = numpy.array([[0, 2], [1, 1], [2, 0]])
+        ia = dpnp.array(a)
+
+        expected = numpy.cov(a.T, dtype=dt)
+        result = dpnp.cov(ia.T, dtype=dt)
+        assert_allclose(result, expected)
+        assert result.dtype == dt
 
     # numpy 2.2 properly transposes 2d array when rowvar=False
     @with_requires("numpy>=2.2")