Merge master into impl_unstack

Author: vlad-perevezentsev

CHANGELOG.md

@@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 
-## [0.16.0] - 09/DD/2024
+## [0.16.0] - 10/14/2024
 
 This release reaches an important milestone by making offloading fully asynchronous. Calls to `dpnp` submit tasks for execution to DPC++ runtime and return without waiting for execution of these tasks to finish. The sequential semantics a user comes to expect from execution of Python script is preserved though.
 In addition, this release completes implementation of `dpnp.fft` module and adds several new array manipulation, indexing and elementwise routines. Moreover, it adds support to build `dpnp` for Nvidia GPUs.
@@ -117,6 +117,7 @@ In addition, this release completes implementation of `dpnp.fft` module and adds
 * Updated the test suit for `dpnp.fft` module [#2071](https://github.com/IntelPython/dpnp/pull/2071)
 * Reworked `dpnp.clip` implementation to align with Python Array API 2023.12 specification [#2048](https://github.com/IntelPython/dpnp/pull/2048)
 * Skipped outdated tests for `dpnp.linalg.solve` due to compatibility issues with NumPy 2.0 [#2074](https://github.com/IntelPython/dpnp/pull/2074)
+* Updated installation instructions [#2098](https://github.com/IntelPython/dpnp/pull/2098)
 
 ### Fixed
 

doc/reference/linalg.rst

@@ -69,7 +69,6 @@ Norms and other numbers
    dpnp.trace
    dpnp.linalg.trace (Array API compatible)
 
-
 Solving linear equations
 --------------------------
 

doc/reference/ndarray.rst

@@ -92,6 +92,7 @@ Other attributes
    :nosignatures:
 
    dpnp.ndarray.T
+   dpnp.ndarray.mT
    dpnp.ndarray.real
    dpnp.ndarray.imag
    dpnp.ndarray.flat

dpnp/dpnp_array.py

@@ -108,6 +108,49 @@ def T(self):
         """View of the transposed array."""
         return self.transpose()
 
+    @property
+    def mT(self):
+        """
+        View of the matrix transposed array.
+
+        The matrix transpose is the transpose of the last two dimensions, even
+        if the array is of higher dimension.
+
+        Raises
+        ------
+        ValueError
+            If the array is of dimension less than 2.
+
+        Examples
+        --------
+        >>> import dpnp as np
+        >>> a = np.array([[1, 2], [3, 4]])
+        >>> a
+        array([[1, 2],
+               [3, 4]])
+        >>> a.mT
+        array([[1, 3],
+               [2, 4]])
+
+        >>> a = np.arange(8).reshape((2, 2, 2))
+        >>> a
+        array([[[0, 1],
+                [2, 3]],
+               [[4, 5],
+                [6, 7]]])
+        >>> a.mT
+        array([[[0, 2],
+                [1, 3]],
+               [[4, 6],
+                [5, 7]]])
+
+        """
+
+        if self.ndim < 2:
+            raise ValueError("matrix transpose with ndim < 2 is undefined")
+
+        return self._array_obj.mT
+
     def to_device(self, target_device):
         """Transfer array to target device."""
 

dpnp/dpnp_iface_manipulation.py

@@ -73,6 +73,7 @@
     "flipud",
     "hsplit",
     "hstack",
+    "matrix_transpose",
     "moveaxis",
     "ndim",
     "permute_dims",
@@ -1755,6 +1756,58 @@ def hstack(tup, *, dtype=None, casting="same_kind"):
     return dpnp.concatenate(arrs, axis=1, dtype=dtype, casting=casting)
 
 
+def matrix_transpose(x, /):
+    """
+    Transposes a matrix (or a stack of matrices) `x`.
+
+    For full documentation refer to :obj:`numpy.matrix_transpose`.
+
+    Parameters
+    ----------
+    x : (..., M, N) {dpnp.ndarray, usm_ndarray}
+        Input array with ``x.ndim >= 2`` and whose two innermost
+        dimensions form ``MxN`` matrices.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        An array containing the transpose for each matrix and having shape
+        (..., N, M).
+
+    See Also
+    --------
+    :obj:`dpnp.transpose` : Returns an array with axes transposed.
+    :obj:`dpnp.linalg.matrix_transpose` : Equivalent function.
+    :obj:`dpnp.ndarray.mT` : Equivalent method.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.matrix_transpose(a)
+    array([[1, 3],
+           [2, 4]])
+
+    >>> b = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+    >>> np.matrix_transpose(b)
+    array([[[1, 3],
+            [2, 4]],
+           [[5, 7],
+            [6, 8]]])
+
+    """
+
+    usm_x = dpnp.get_usm_ndarray(x)
+    if usm_x.ndim < 2:
+        raise ValueError(
+            "Input array must be at least 2-dimensional, "
+            f"but it is {usm_x.ndim}"
+        )
+
+    usm_res = dpt.matrix_transpose(usm_x)
+    return dpnp_array._create_from_usm_ndarray(usm_res)
+
+
 def moveaxis(a, source, destination):
     """
     Move axes of an array to new positions. Other axes remain in their original

dpnp/dpnp_utils/dpnp_utils_einsum.py

@@ -109,29 +109,6 @@ def _compute_size_by_dict(indices, idx_dict):
     return ret
 
 
-def _compute_size(start, shape):
-    """
-    Compute the total size of a multi-dimensional array starting from a given index.
-
-    Parameters
-    ----------
-    start : int
-        The starting index from which to compute the size.
-    shape : tuple
-        The shape of the multi-dimensional array.
-
-    Returns
-    -------
-    out : int
-        The total size of the array.
-
-    """
-    ret = 1
-    for i in range(start, len(shape)):
-        ret *= shape[i]
-    return ret
-
-
 def _einsum_diagonals(input_subscripts, operands):
     """
     Adopted from _einsum_diagonals in cupy/core/_einsum.py
@@ -818,11 +795,11 @@ def _parse_int_subscript(list_subscript):
                     "For this input type lists must contain "
                     "either int or Ellipsis"
                 ) from e
-            if isinstance(s, int):
-                if not 0 <= s < len(_einsum_symbols):
-                    raise ValueError(
-                        f"subscript is not within the valid range [0, {len(_einsum_symbols)})."
-                    )
+
+            if not 0 <= s < len(_einsum_symbols):
+                raise ValueError(
+                    f"subscript is not within the valid range [0, {len(_einsum_symbols)})."
+                )
             str_subscript += _einsum_symbols[s]
     return str_subscript
 
@@ -1116,12 +1093,14 @@ def dpnp_einsum(
                     f"'{_chr(label)}' which never appeared in an input."
                 )
         if len(output_subscript) != len(set(output_subscript)):
+            repeated_subscript = []
             for label in output_subscript:
                 if output_subscript.count(label) >= 2:
-                    raise ValueError(
-                        "einstein sum subscripts string includes output "
-                        f"subscript '{_chr(label)}' multiple times."
-                    )
+                    repeated_subscript.append(_chr(label))
+            raise ValueError(
+                "einstein sum subscripts string includes output "
+                f"subscript {set(repeated_subscript)} multiple times."
+            )
 
     _einsum_diagonals(input_subscripts, operands)
 

dpnp/dpnp_utils/dpnp_utils_statistics.py

@@ -25,7 +25,7 @@
 
 
 import dpnp
-from dpnp.dpnp_utils import get_usm_allocations
+from dpnp.dpnp_utils import get_usm_allocations, map_dtype_to_device
 
 __all__ = ["dpnp_cov"]
 
@@ -73,12 +73,7 @@ def _get_2dmin_array(x, dtype):
             dtypes.append(y.dtype)
         dtype = dpnp.result_type(*dtypes)
         # TODO: remove when dpctl.result_type() is returned dtype based on fp64
-        fp64 = queue.sycl_device.has_aspect_fp64
-        if not fp64:
-            if dtype == dpnp.float64:
-                dtype = dpnp.float32
-            elif dtype == dpnp.complex128:
-                dtype = dpnp.complex64
+        dtype = map_dtype_to_device(dtype, queue.sycl_device)
 
     X = _get_2dmin_array(m, dtype)
     if y is not None:

dpnp/linalg/dpnp_iface_linalg.py

@@ -81,6 +81,7 @@
     "matrix_norm",
     "matrix_power",
     "matrix_rank",
+    "matrix_transpose",
     "multi_dot",
     "norm",
     "outer",
@@ -1117,6 +1118,50 @@ def matrix_rank(A, tol=None, hermitian=False):
     return dpnp_matrix_rank(A, tol=tol, hermitian=hermitian)
 
 
+def matrix_transpose(x, /):
+    """
+    Transposes a matrix (or a stack of matrices) `x`.
+
+    For full documentation refer to :obj:`numpy.linalg.matrix_transpose`.
+
+    Parameters
+    ----------
+    x : (..., M, N) {dpnp.ndarray, usm_ndarray}
+        Input array with ``x.ndim >= 2`` and whose two innermost
+        dimensions form ``MxN`` matrices.
+
+    Returns
+    -------
+    out : dpnp.ndarray
+        An array containing the transpose for each matrix and having shape
+        (..., N, M).
+
+    See Also
+    --------
+    :obj:`dpnp.transpose` : Returns an array with axes transposed.
+    :obj:`dpnp.matrix_transpose` : Equivalent function.
+    :obj:`dpnp.ndarray.mT` : Equivalent method.
+
+    Examples
+    --------
+    >>> import dpnp as np
+    >>> a = np.array([[1, 2], [3, 4]])
+    >>> np.linalg.matrix_transpose(a)
+    array([[1, 3],
+           [2, 4]])
+
+    >>> b = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]])
+    >>> np.linalg.matrix_transpose(b)
+    array([[[1, 3],
+            [2, 4]],
+           [[5, 7],
+            [6, 8]]])
+
+    """
+
+    return dpnp.matrix_transpose(x)
+
+
 def multi_dot(arrays, *, out=None):
     """
     Compute the dot product of two or more arrays in a single function call.

tests/test_arraymanipulation.py

@@ -556,6 +556,50 @@ def test_one_element(self):
         assert_array_equal(res, a)
 
 
+# numpy.matrix_transpose() is available since numpy >= 2.0
+@testing.with_requires("numpy>=2.0")
+class TestMatrixtranspose:
+    @pytest.mark.parametrize("dtype", get_all_dtypes(no_bool=True))
+    @pytest.mark.parametrize(
+        "shape",
+        [(3, 5), (4, 2), (2, 5, 2), (2, 3, 3, 6)],
+        ids=["(3,5)", "(4,2)", "(2,5,2)", "(2,3,3,6)"],
+    )
+    def test_matrix_transpose(self, dtype, shape):
+        a = numpy.arange(numpy.prod(shape), dtype=dtype).reshape(shape)
+        dp_a = dpnp.array(a)
+
+        expected = numpy.matrix_transpose(a)
+        result = dpnp.matrix_transpose(dp_a)
+
+        assert_allclose(result, expected)
+
+    @pytest.mark.parametrize(
+        "shape",
+        [(0, 0), (1, 0, 0), (0, 2, 2), (0, 1, 0, 4)],
+        ids=["(0,0)", "(1,0,0)", "(0,2,2)", "(0, 1, 0, 4)"],
+    )
+    def test_matrix_transpose_empty(self, shape):
+        a = numpy.empty(shape, dtype=dpnp.default_float_type())
+        dp_a = dpnp.array(a)
+
+        expected = numpy.matrix_transpose(a)
+        result = dpnp.matrix_transpose(dp_a)
+
+        assert_allclose(result, expected)
+
+    def test_matrix_transpose_errors(self):
+        a_dp = dpnp.array([[1, 2], [3, 4]], dtype="float32")
+
+        # unsupported type
+        a_np = dpnp.asnumpy(a_dp)
+        assert_raises(TypeError, dpnp.matrix_transpose, a_np)
+
+        # a.ndim < 2
+        a_dp_ndim_1 = a_dp.flatten()
+        assert_raises(ValueError, dpnp.matrix_transpose, a_dp_ndim_1)
+
+
 class TestRollaxis:
     data = [
         (0, 0),