Merge branch 'master' into tests_cuda

Author: npolina4

.github/workflows/conda-package.yml

@@ -63,6 +63,7 @@ env:
       third_party/cupy/statistics_tests/test_histogram.py
       third_party/cupy/statistics_tests/test_meanvar.py
       third_party/cupy/test_ndim.py
+      third_party/cupy/test_type_routines.py
   VER_JSON_NAME: 'version.json'
   VER_SCRIPT1: "import json; f = open('version.json', 'r'); j = json.load(f); f.close(); "
   VER_SCRIPT2: "d = j['dpnp'][0]; print('='.join((d[s] for s in ('version', 'build'))))"

dpnp/dpnp_iface_logic.py

@@ -64,6 +64,7 @@
     "iscomplex",
     "iscomplexobj",
     "isfinite",
+    "isfortran",
     "isinf",
     "isnan",
     "isneginf",
@@ -991,6 +992,76 @@ def iscomplexobj(x):
 )
 
 
+def isfortran(a):
+    """
+    Check if the array is Fortran contiguous but *not* C contiguous.
+
+    This function is obsolete. If you only want to check if an array is Fortran
+    contiguous use ``a.flags.f_contiguous`` instead.
+
+    For full documentation refer to :obj:`numpy.isfortran`.
+
+    Parameters
+    ----------
+    a : {dpnp.ndarray, usm_ndarray}
+        Input array.
+
+    Returns
+    -------
+    isfortran : bool
+        Returns ``True`` if the array is Fortran contiguous
+        but *not* C contiguous.
+
+    Examples
+    --------
+    :obj:`dpnp.array` allows to specify whether the array is written in
+    C-contiguous order (last index varies the fastest), or FORTRAN-contiguous
+    order in memory (first index varies the fastest).
+
+    >>> import dpnp as np
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(a)
+    False
+
+    >>> b = np.array([[1, 2, 3], [4, 5, 6]], order='F')
+    >>> b
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(b)
+    True
+
+    The transpose of a C-ordered array is a FORTRAN-ordered array.
+
+    >>> a = np.array([[1, 2, 3], [4, 5, 6]], order='C')
+    >>> a
+    array([[1, 2, 3],
+           [4, 5, 6]])
+    >>> np.isfortran(a)
+    False
+    >>> b = a.T
+    >>> b
+    array([[1, 4],
+           [2, 5],
+           [3, 6]])
+    >>> np.isfortran(b)
+    True
+
+    C-ordered arrays evaluate as ``False`` even if they are also
+    FORTRAN-ordered.
+
+    >>> np.isfortran(np.array([1, 2], order='F'))
+    False
+
+    """
+
+    dpnp.check_supported_arrays_type(a)
+
+    return a.flags.fnc
+
+
 _ISINF_DOCSTRING = """
 Test if each element of input array is an infinity.
 

dpnp/dpnp_iface_statistics.py

@@ -370,7 +370,7 @@ def correlate(x1, x2, mode="valid"):
     -----------
     Input arrays are supported as :obj:`dpnp.ndarray`.
     Size and shape of input arrays are supported to be equal.
-    Parameter `mode` is supported only with default value ``"valid``.
+    Parameter `mode` is supported only with default value ``"valid"``.
     Otherwise the function will be executed sequentially on CPU.
     Input array data types are limited by supported DPNP :ref:`Data types`.
 

dpnp/dpnp_utils/dpnp_utils_einsum.py

@@ -33,9 +33,8 @@
 from dpctl.utils import ExecutionPlacementError
 
 import dpnp
-from dpnp.dpnp_utils import get_usm_allocations
-
-from ..dpnp_array import dpnp_array
+from dpnp.dpnp_array import dpnp_array
+from dpnp.dpnp_utils import get_usm_allocations, map_dtype_to_device
 
 _einsum_symbols = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
@@ -1027,17 +1026,16 @@ def dpnp_einsum(
                 "Input and output allocation queues are not compatible"
             )
 
-    result_dtype = dpnp.result_type(*arrays) if dtype is None else dtype
     for id, a in enumerate(operands):
         if dpnp.isscalar(a):
+            scalar_dtype = map_dtype_to_device(type(a), exec_q.sycl_device)
             operands[id] = dpnp.array(
-                a, dtype=result_dtype, usm_type=res_usm_type, sycl_queue=exec_q
+                a, dtype=scalar_dtype, usm_type=res_usm_type, sycl_queue=exec_q
             )
+            arrays.append(operands[id])
     result_dtype = dpnp.result_type(*arrays) if dtype is None else dtype
-    if order in ["a", "A"]:
-        order = (
-            "F" if not any(arr.flags.c_contiguous for arr in arrays) else "C"
-        )
+    if order in "aA":
+        order = "F" if all(arr.flags.fnc for arr in arrays) else "C"
 
     input_subscripts = [
         _parse_ellipsis_subscript(sub, idx, ndim=arr.ndim)

tests/test_linalg.py

@@ -1139,14 +1139,12 @@ def check_einsum_sums(self, dtype, do_opt=False):
         result = inp.einsum(*args, dtype="?", casting="unsafe", optimize=do_opt)
         assert_dtype_allclose(result, expected)
 
-        # with an scalar, NumPy < 2.0.0 uses the other input arrays to
-        # determine the output type while for NumPy > 2.0.0 the scalar
-        # with default machine dtype is used to determine the output
-        # data type
+        # NumPy >= 2.0 follows NEP-50 to determine the output dtype when one of
+        # the inputs is a scalar while NumPy < 2.0 does not
         if numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0":
-            check_type = True
-        else:
             check_type = False
+        else:
+            check_type = True
         a = numpy.arange(9, dtype=dtype)
         a_dp = inp.array(a)
         expected = numpy.einsum(",i->", 3, a)
@@ -1712,7 +1710,7 @@ def test_broadcasting_dot_cases(self):
 
     def test_output_order(self):
         # Ensure output order is respected for optimize cases, the below
-        # conraction should yield a reshaped tensor view
+        # contraction should yield a reshaped tensor view
         a = inp.ones((2, 3, 5), order="F")
         b = inp.ones((4, 3), order="F")
 

tests/test_logic.py

@@ -434,6 +434,34 @@ def test_finite(op, data, dtype):
     assert_equal(dpnp_res, np_res)
 
 
+class TestIsFortran:
+    @pytest.mark.parametrize(
+        "array, expected",
+        [
+            (dpnp.ones((2, 4), order="C"), True),
+            (dpnp.ones((2, 4), order="F"), False),
+        ],
+    )
+    def test_isfortran_transpose(self, array, expected):
+        assert dpnp.isfortran(array.T) == expected
+
+    @pytest.mark.parametrize(
+        "array, expected",
+        [
+            (dpnp.ones((2, 4), order="C"), False),
+            (dpnp.ones((2, 4), order="F"), True),
+        ],
+    )
+    def test_isfortran_usm_ndarray(self, array, expected):
+        assert dpnp.isfortran(array.get_array()) == expected
+
+    def test_isfortran_errors(self):
+        # unsupported type
+        a_np = numpy.ones((2, 3))
+        assert_raises(TypeError, dpnp.isfortran, a_np)
+        assert_raises(TypeError, dpnp.isfortran, [1, 2, 3])
+
+
 @pytest.mark.parametrize("func", ["isneginf", "isposinf"])
 @pytest.mark.parametrize(
     "data",

tests/third_party/cupy/linalg_tests/test_einsum.py

@@ -475,13 +475,12 @@ def test_einsum_binary(self, xp, dtype_a, dtype_b):
 
 
 class TestEinSumBinaryOperationWithScalar:
-    # with an scalar, NumPy < 2.0.0 uses the other input arrays to determine
-    # the output type while for NumPy > 2.0.0 the scalar with default machine
-    # dtype is used to determine the output type
+    # NumPy >= 2.0 follows NEP-50 to determine the output dtype when one of
+    # the inputs is a scalar while NumPy < 2.0 does not
     if numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0":
-        type_check = has_support_aspect64()
-    else:
         type_check = False
+    else:
+        type_check = has_support_aspect64()
 
     @testing.for_all_dtypes()
     @testing.numpy_cupy_allclose(contiguous_check=False, type_check=type_check)

tests/third_party/cupy/logic_tests/test_type_test.py

@@ -72,7 +72,6 @@ def setUp(self):
 )
 class TestIsFortran(unittest.TestCase):
 
-    @pytest.mark.skip("isfortran not implemented")
     @testing.numpy_cupy_equal()
     def test(self, xp):
         return xp.isfortran(xp.asarray(self.value))

tests/third_party/cupy/test_type_routines.py

@@ -34,11 +34,13 @@ class TestCanCast(unittest.TestCase):
     @testing.for_all_dtypes_combination(names=("from_dtype", "to_dtype"))
     @testing.numpy_cupy_equal()
     def test_can_cast(self, xp, from_dtype, to_dtype):
-        if self.obj_type == "scalar":
+        if (
+            self.obj_type == "scalar"
+            and numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0"
+        ):
             pytest.skip("to be aligned with NEP-50")
 
         from_obj = _generate_type_routines_input(xp, from_dtype, self.obj_type)
-
         ret = xp.can_cast(from_obj, to_dtype)
         assert isinstance(ret, bool)
         return ret
@@ -92,37 +94,40 @@ class TestResultType(unittest.TestCase):
     @testing.for_all_dtypes_combination(names=("dtype1", "dtype2"))
     @testing.numpy_cupy_equal()
     def test_result_type(self, xp, dtype1, dtype2):
-        if "scalar" in {self.obj_type1, self.obj_type2}:
+        if (
+            "scalar" in {self.obj_type1, self.obj_type2}
+            and numpy.lib.NumpyVersion(numpy.__version__) < "2.0.0"
+        ):
             pytest.skip("to be aligned with NEP-50")
 
         input1 = _generate_type_routines_input(xp, dtype1, self.obj_type1)
-
         input2 = _generate_type_routines_input(xp, dtype2, self.obj_type2)
 
-        flag1 = isinstance(input1, (numpy.ndarray, cupy.ndarray))
-        flag2 = isinstance(input2, (numpy.ndarray, cupy.ndarray))
-        dt1 = cupy.dtype(input1) if not flag1 else None
-        dt2 = cupy.dtype(input2) if not flag2 else None
-        # dpnp takes into account device capabilities only if one of the
-        # inputs is an array, for such a case, if the other dtype is not
-        # supported by device, dpnp raise ValueError. So, we skip the test.
-        if flag1 or flag2:
-            if (
-                dt1 in [cupy.float64, cupy.complex128]
-                or dt2 in [cupy.float64, cupy.complex128]
-            ) and not has_support_aspect64():
-                pytest.skip("No fp64 support by device.")
+        # dpnp.result_type takes into account device capabilities, when one of
+        # the inputs is an array. If dtype is `float32` and the object is
+        # primitive, the final dtype is `float` which needs a device with
+        # double precision support. So we have to skip the test for such a case
+        # on a device that does not support fp64
+        flag1 = self.obj_type1 == "array" or self.obj_type2 == "array"
+        flag2 = (self.obj_type1 == "primitive" and input1 == float) or (
+            self.obj_type2 == "primitive" and input2 == float
+        )
+        if flag1 and flag2 and not has_support_aspect64():
+            pytest.skip("No fp64 support by device.")
 
         ret = xp.result_type(input1, input2)
 
-        # dpnp takes into account device capabilities if one of the inputs
-        # is an array, for such a case, we have to modify the results for
-        # NumPy to align it with device capabilities.
-        if (flag1 or flag2) and xp == numpy and not has_support_aspect64():
-            ret = numpy.dtype(numpy.float32) if ret == numpy.float64 else ret
-            ret = (
-                numpy.dtype(numpy.complex64) if ret == numpy.complex128 else ret
-            )
+        # dpnp.result_type takes into account device capabilities, when one of the inputs
+        # is an array.
+        # So, we have to modify the results for NumPy to align it with
+        # device capabilities.
+        flag1 = isinstance(input1, numpy.ndarray)
+        flag2 = isinstance(input2, numpy.ndarray)
+        if (flag1 or flag2) and not has_support_aspect64():
+            if ret == numpy.float64:
+                ret = numpy.dtype(numpy.float32)
+            elif ret == numpy.complex128:
+                ret = numpy.dtype(numpy.complex64)
 
         assert isinstance(ret, numpy.dtype)
         return ret