Merge branch 'master' into impl-bitwise_count

Author: vtavana

.github/CODEOWNERS

@@ -1 +1 @@
-* @antonwolfy @AlexanderKalistratov @vlad-perevezentsev @vtavana
+* @antonwolfy @AlexanderKalistratov @vlad-perevezentsev @vtavana @ndgrigorian

conda-recipe/meta.yaml

@@ -69,8 +69,8 @@ about:
 
 extra:
     recipe-maintainers:
-        - oleksandr-pavlyk
         - antonwolfy
         - AlexanderKalistratov
         - vtavana
         - vlad-perevezentsev
+        - ndgrigorian

dpnp/dpnp_iface_histograms.py

@@ -225,17 +225,23 @@ def _get_bin_edges(a, bins, range, usm_type):
 
 
 def _bincount_validate(x, weights, minlength):
+    dpnp.check_supported_arrays_type(x)
     if x.ndim > 1:
         raise ValueError("object too deep for desired array")
+
     if x.ndim < 1:
         raise ValueError("object of too small depth for desired array")
+
     if not dpnp.issubdtype(x.dtype, dpnp.integer) and not dpnp.issubdtype(
         x.dtype, dpnp.bool
     ):
         raise TypeError("x must be an integer array")
+
     if weights is not None:
+        dpnp.check_supported_arrays_type(weights)
         if x.shape != weights.shape:
             raise ValueError("The weights and x don't have the same length.")
+
         if not (
             dpnp.issubdtype(weights.dtype, dpnp.integer)
             or dpnp.issubdtype(weights.dtype, dpnp.floating)
@@ -245,10 +251,12 @@ def _bincount_validate(x, weights, minlength):
                 f"Weights must be integer or float. Got {weights.dtype}"
             )
 
-    if minlength is not None:
-        minlength = int(minlength)
-        if minlength < 0:
-            raise ValueError("minlength must be non-negative")
+    if minlength is None:
+        raise TypeError("use 0 instead of None for minlength")
+
+    minlength = int(minlength)
+    if minlength < 0:
+        raise ValueError("minlength must be non-negative")
 
 
 def _bincount_run_native(
@@ -262,9 +270,7 @@ def _bincount_run_native(
     if min_v < 0:
         raise ValueError("x argument must have no negative arguments")
 
-    size = int(dpnp.max(max_v)) + 1
-    if minlength is not None:
-        size = max(size, minlength)
+    size = max(int(max_v) + 1, minlength)
 
     # bincount implementation uses atomics, but atomics doesn't work with
     # host usm memory
@@ -299,9 +305,9 @@ def _bincount_run_native(
     return n_casted
 
 
-def bincount(x, weights=None, minlength=None):
+def bincount(x, weights=None, minlength=0):
     """
-    bincount(x, /, weights=None, minlength=None)
+    bincount(x, /, weights=None, minlength=0)
 
     Count number of occurrences of each value in array of non-negative ints.
 
@@ -313,10 +319,12 @@ def bincount(x, weights=None, minlength=None):
         Input 1-dimensional array with non-negative integer values.
     weights : {None, dpnp.ndarray, usm_ndarray}, optional
         Weights, array of the same shape as `x`.
+
         Default: ``None``
-    minlength : {None, int}, optional
+    minlength : int, optional
         A minimum number of bins for the output array.
-        Default: ``None``
+
+        Default: ``0``
 
     Returns
     -------
@@ -416,6 +424,7 @@ def digitize(x, bins, right=False):
         increasing or decreasing.
     right : bool, optional
         Indicates whether the intervals include the right or the left bin edge.
+
         Default: ``False``.
 
     Returns
@@ -675,6 +684,7 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
         given range.
         If `bins` is a sequence, it defines the bin edges, including the
         rightmost edge, allowing for non-uniform bin widths.
+
         Default: ``10``.
     range : {None, 2-tuple of float}, optional
         The lower and upper range of the bins. If not provided, range is simply
@@ -683,12 +693,14 @@ def histogram_bin_edges(a, bins=10, range=None, weights=None):
         affects the automatic bin computation as well. While bin width is
         computed to be optimal based on the actual data within `range`, the bin
         count will fill the entire range including portions containing no data.
+
         Default: ``None``.
     weights : {None, dpnp.ndarray, usm_ndarray}, optional
         An array of weights, of the same shape as `a`. Each value in `a` only
         contributes its associated weight towards the bin count (instead of 1).
         This is currently not used by any of the bin estimators, but may be in
         the future.
+
         Default: ``None``.
 
     Returns

dpnp/linalg/dpnp_utils_linalg.py

@@ -449,13 +449,15 @@ def _batched_qr(a, mode="reduced"):
             a_t,
             shape=(batch_size, m, m),
             dtype=res_type,
+            order="C",
         )
     else:
         mc = k
         q = dpnp.empty_like(
             a_t,
             shape=(batch_size, n, m),
             dtype=res_type,
+            order="C",
         )
 
     # use DPCTL tensor function to fill the matrix array `q[..., :n, :]`
@@ -2532,13 +2534,15 @@ def dpnp_qr(a, mode="reduced"):
             a_t,
             shape=(m, m),
             dtype=res_type,
+            order="C",
         )
     else:
         mc = k
         q = dpnp.empty_like(
             a_t,
             shape=(n, m),
             dtype=res_type,
+            order="C",
         )
 
     # use DPCTL tensor function to fill the matrix array `q[:n]`

dpnp/tests/helper.py

@@ -6,7 +6,8 @@
 from numpy.testing import assert_allclose, assert_array_equal
 
 import dpnp
-from dpnp.tests import config
+
+from . import config
 
 
 def assert_dtype_allclose(
@@ -86,14 +87,14 @@ def assert_dtype_allclose(
                 assert dpnp_arr.dtype == numpy_arr.dtype
 
 
-def get_integer_dtypes(no_unsigned=False):
+def get_integer_dtypes(all_int_types=False, no_unsigned=False):
     """
     Build a list of integer types supported by DPNP.
     """
 
     dtypes = [dpnp.int32, dpnp.int64]
 
-    if config.all_int_types:
+    if config.all_int_types or all_int_types:
         dtypes += [dpnp.int8, dpnp.int16]
         if not no_unsigned:
             dtypes += [dpnp.uint8, dpnp.uint16, dpnp.uint32, dpnp.uint64]

dpnp/tests/test_histogram.py

@@ -7,7 +7,6 @@
     assert_array_equal,
     assert_raises,
     assert_raises_regex,
-    suppress_warnings,
 )
 
 import dpnp
@@ -19,6 +18,7 @@
     get_float_dtypes,
     get_integer_dtypes,
     has_support_aspect64,
+    numpy_version,
 )
 
 
@@ -282,9 +282,10 @@ def test_weights(self, density):
         assert_dtype_allclose(result_hist, expected_hist)
         assert_dtype_allclose(result_edges, expected_edges)
 
-    def test_integer_weights(self):
+    @pytest.mark.parametrize("dt", get_integer_dtypes(all_int_types=True))
+    def test_integer_weights(self, dt):
         v = numpy.array([1, 2, 2, 4])
-        w = numpy.array([4, 3, 2, 1])
+        w = numpy.array([4, 3, 2, 1], dtype=dt)
 
         iv = dpnp.array(v)
         iw = dpnp.array(w)
@@ -602,19 +603,42 @@ def test_different_bins_amount(self, bins_count):
     @pytest.mark.parametrize(
         "array",
         [[1, 2, 3], [1, 2, 2, 1, 2, 4], [2, 2, 2, 2]],
-        ids=["[1, 2, 3]", "[1, 2, 2, 1, 2, 4]", "[2, 2, 2, 2]"],
+        ids=["size=3", "size=6", "size=4"],
     )
-    @pytest.mark.parametrize(
-        "minlength", [0, 1, 3, 5], ids=["0", "1", "3", "5"]
-    )
-    def test_bincount_minlength(self, array, minlength):
+    @pytest.mark.parametrize("minlength", [0, 1, 3, 5])
+    def test_minlength(self, array, minlength):
         np_a = numpy.array(array)
         dpnp_a = dpnp.array(array)
 
         expected = numpy.bincount(np_a, minlength=minlength)
         result = dpnp.bincount(dpnp_a, minlength=minlength)
         assert_allclose(expected, result)
 
+    @pytest.mark.filterwarnings("ignore::DeprecationWarning")
+    @pytest.mark.parametrize(
+        "xp",
+        [
+            dpnp,
+            pytest.param(
+                numpy,
+                marks=pytest.mark.xfail(
+                    numpy_version() < "2.3.0",
+                    reason="numpy deprecates but accepts that",
+                    strict=True,
+                ),
+            ),
+        ],
+    )
+    def test_minlength_none(self, xp):
+        a = xp.array([1, 2, 3])
+        assert_raises_regex(
+            TypeError,
+            "use 0 instead of None for minlength",
+            xp.bincount,
+            a,
+            minlength=None,
+        )
+
     @pytest.mark.parametrize(
         "array", [[1, 2, 2, 1, 2, 4]], ids=["[1, 2, 2, 1, 2, 4]"]
     )
@@ -623,7 +647,7 @@ def test_bincount_minlength(self, array, minlength):
         [None, [0.3, 0.5, 0.2, 0.7, 1.0, -0.6], [2, 2, 2, 2, 2, 2]],
         ids=["None", "[0.3, 0.5, 0.2, 0.7, 1., -0.6]", "[2, 2, 2, 2, 2, 2]"],
     )
-    def test_bincount_weights(self, array, weights):
+    def test_weights(self, array, weights):
         np_a = numpy.array(array)
         np_weights = numpy.array(weights) if weights is not None else weights
         dpnp_a = dpnp.array(array)
@@ -633,6 +657,20 @@ def test_bincount_weights(self, array, weights):
         result = dpnp.bincount(dpnp_a, weights=dpnp_weights)
         assert_allclose(expected, result)
 
+    @pytest.mark.parametrize(
+        "data",
+        [numpy.arange(5), 3, [2, 1]],
+        ids=["numpy.ndarray", "scalar", "list"],
+    )
+    def test_unsupported_data_weights(self, data):
+        # check input array
+        msg = "An array must be any of supported type"
+        assert_raises_regex(TypeError, msg, dpnp.bincount, data)
+
+        # check array of weights
+        a = dpnp.ones(5, dtype=dpnp.int32)
+        assert_raises_regex(TypeError, msg, dpnp.bincount, a, weights=data)
+
 
 class TestHistogramDd:
     @pytest.mark.usefixtures("suppress_complex_warning")

dpnp/tests/test_linalg.py

@@ -2372,12 +2372,24 @@ class TestQr:
     @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
     @pytest.mark.parametrize(
         "shape",
-        [(2, 2), (3, 4), (5, 3), (16, 16), (2, 2, 2), (2, 4, 2), (2, 2, 4)],
+        [
+            (2, 1),
+            (2, 2),
+            (3, 4),
+            (5, 3),
+            (16, 16),
+            (3, 3, 1),
+            (2, 2, 2),
+            (2, 4, 2),
+            (2, 2, 4),
+        ],
         ids=[
+            "(2, 1)",
             "(2, 2)",
             "(3, 4)",
             "(5, 3)",
             "(16, 16)",
+            "(3, 3, 1)",
             "(2, 2, 2)",
             "(2, 4, 2)",
             "(2, 2, 4)",

dpnp/tests/test_mathematical.py

@@ -2309,35 +2309,27 @@ def test_float_remainder_fmod_nans_inf(func, dtype, lhs, rhs):
     assert_equal(result, expected)
 
 
+@testing.with_requires("numpy>=2.0.0")
 @pytest.mark.parametrize(
-    "data",
-    [[2, 0, -2], [1.1, -1.1]],
-    ids=["[2, 0, -2]", "[1.1, -1.1]"],
-)
-@pytest.mark.parametrize(
-    "dtype", get_all_dtypes(no_bool=True, no_unsigned=True)
+    "dtype", get_all_dtypes(no_none=True, no_unsigned=True)
 )
-def test_sign(data, dtype):
-    np_a = numpy.array(data, dtype=dtype)
-    dpnp_a = dpnp.array(data, dtype=dtype)
+def test_sign(dtype):
+    a = generate_random_numpy_array((2, 3), dtype=dtype)
+    ia = dpnp.array(a, dtype=dtype)
 
-    result = dpnp.sign(dpnp_a)
-    expected = numpy.sign(np_a)
-    assert_dtype_allclose(result, expected)
-
-    # out keyword
-    if dtype is not None:
-        dp_out = dpnp.empty(expected.shape, dtype=expected.dtype)
-        result = dpnp.sign(dpnp_a, out=dp_out)
-        assert dp_out is result
+    if dtype == dpnp.bool:
+        assert_raises(TypeError, dpnp.sign, ia)
+        assert_raises(TypeError, numpy.sign, a)
+    else:
+        result = dpnp.sign(ia)
+        expected = numpy.sign(a)
         assert_dtype_allclose(result, expected)
 
-
-def test_sign_boolean():
-    dpnp_a = dpnp.array([True, False])
-
-    with pytest.raises(TypeError):
-        dpnp.sign(dpnp_a)
+        # out keyword
+        iout = dpnp.empty(expected.shape, dtype=expected.dtype)
+        result = dpnp.sign(ia, out=iout)
+        assert iout is result
+        assert_dtype_allclose(result, expected)
 
 
 @pytest.mark.parametrize(