Introduce dpnp.scipy submodule

.pre-commit-config.yaml

@@ -113,7 +113,7 @@ repos:
             "--disable=redefined-builtin",
             "--disable=unused-wildcard-import"
             ]
-        files: '^dpnp/(dpnp_iface.*|fft|linalg|special|dpnp_array)'
+        files: '^dpnp/(dpnp_iface.*|fft|linalg|scipy|dpnp_array)'
 -   repo: https://github.com/macisamuele/language-formatters-pre-commit-hooks
     rev: v2.15.0
     hooks:

doc/reference/scipy.rst

@@ -0,0 +1,14 @@
+.. currentmodule:: dpnp.scipy
+
+Routines (SciPy) (:mod:`dpnp.scipy`)
+=======================================
+
+The following pages describe SciPy-compatible routines.
+These functions cover a subset of
+`SciPy routines <https://docs.scipy.org/doc/scipy/reference/#api-reference>`_.
+
+.. toctree::
+   :maxdepth: 2
+
+   scipy_linalg
+   scipy_special

doc/reference/scipy_linalg.rst

@@ -0,0 +1,17 @@
+.. currentmodule:: dpnp.scipy.linalg
+
+Linear algebra (:mod:`dpnp.scipy.linalg`)
+=========================================
+
+.. Hint:: `SciPy API Reference: Linear algebra (scipy.linalg) <https://docs.scipy.org/doc/scipy/reference/linalg.html>`_
+
+Decompositions
+--------------
+
+.. autosummary::
+   :toctree: generated/
+   :nosignatures:
+
+   dpnp.scipy.linalg.lu
+   dpnp.scipy.linalg.lu_factor
+   dpnp.scipy.linalg.lu_solve

doc/reference/special.rst → doc/reference/scipy_special.rst

@@ -1,6 +1,6 @@
-.. currentmodule:: dpnp.special
+.. currentmodule:: dpnp.scipy.special
 
-Special functions (:mod:`dpnp.special`)
+Special functions (:mod:`dpnp.scipy.special`)
 =======================================
 
 .. Hint:: `SciPy API Reference: Special functions (scipy.special) <https://docs.scipy.org/doc/scipy/reference/special.html>`_

dpnp/__init__.py

@@ -26,6 +26,7 @@
 
 import os
 import sys
+from importlib import import_module
 
 mypath = os.path.dirname(os.path.realpath(__file__))
 
@@ -70,9 +71,11 @@
 from .dpnp_iface_utils import *
 from .dpnp_iface_utils import __all__ as _ifaceutils__all__
 from ._version import get_versions
+from . import scipy as scipy
 
 __all__ = _iface__all__
 __all__ += _ifaceutils__all__
+__all__ += ["scipy"]
 
 
 __version__ = get_versions()["version"]

dpnp/dpnp_iface.py

@@ -55,7 +55,6 @@
 from dpnp.linalg import *
 from dpnp.memory import *
 from dpnp.random import *
-from dpnp.special import *
 
 __all__ = [
     "are_same_logical_tensors",

dpnp/linalg/dpnp_iface_linalg.py

@@ -56,8 +56,6 @@
     dpnp_eigh,
     dpnp_inv,
     dpnp_lstsq,
-    dpnp_lu_factor,
-    dpnp_lu_solve,
     dpnp_matrix_power,
     dpnp_matrix_rank,
     dpnp_multi_dot,
@@ -81,8 +79,6 @@
     "eigvalsh",
     "inv",
     "lstsq",
-    "lu_factor",
-    "lu_solve",
     "matmul",
     "matrix_norm",
     "matrix_power",
@@ -905,149 +901,6 @@ def lstsq(a, b, rcond=None):
     return dpnp_lstsq(a, b, rcond=rcond)
 
 
-def lu_factor(a, overwrite_a=False, check_finite=True):
-    """
-    Compute the pivoted LU decomposition of `a` matrix.
-
-    The decomposition is::
-
-        A = P @ L @ U
-
-    where `P` is a permutation matrix, `L` is lower triangular with unit
-    diagonal elements, and `U` is upper triangular.
-
-    For full documentation refer to :obj:`scipy.linalg.lu_factor`.
-
-    Parameters
-    ----------
-    a : (..., M, N) {dpnp.ndarray, usm_ndarray}
-        Input array to decompose.
-    overwrite_a : {None, bool}, optional
-        Whether to overwrite data in `a` (may increase performance).
-
-        Default: ``False``.
-    check_finite : {None, bool}, optional
-        Whether to check that the input matrix contains only finite numbers.
-        Disabling may give a performance gain, but may result in problems
-        (crashes, non-termination) if the inputs do contain infinities or NaNs.
-
-        Default: ``True``.
-
-    Returns
-    -------
-    lu : (..., M, N) dpnp.ndarray
-        Matrix containing `U` in its upper triangle,
-        and `L` in its lower triangle.
-        The unit diagonal elements of `L` are not stored.
-    piv : (..., K) dpnp.ndarray
-        Pivot indices representing the permutation matrix `P`:
-        row i of matrix was interchanged with row piv[i].
-        Where ``K = min(M, N)``.
-
-    Warning
-    -------
-    This function synchronizes in order to validate array elements
-    when ``check_finite=True``.
-
-    See Also
-    --------
-    :obj:`dpnp.linalg.lu_solve` : Solve an equation system using
-                                  the LU factorization of `a` matrix.
-
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> a = np.array([[4., 3.], [6., 3.]])
-    >>> lu, piv = np.linalg.lu_factor(a)
-    >>> lu
-    array([[6.        , 3.        ],
-           [0.66666667, 1.        ]])
-    >>> piv
-    array([1, 1])
-
-    """
-
-    dpnp.check_supported_arrays_type(a)
-    assert_stacked_2d(a)
-
-    return dpnp_lu_factor(a, overwrite_a=overwrite_a, check_finite=check_finite)
-
-
-def lu_solve(lu_and_piv, b, trans=0, overwrite_b=False, check_finite=True):
-    """
-    Solve a linear system, :math:`a x = b`, given the LU factorization of `a`.
-
-    For full documentation refer to :obj:`scipy.linalg.lu_solve`.
-
-    Parameters
-    ----------
-    lu, piv : {tuple of dpnp.ndarrays or usm_ndarrays}
-        LU factorization of matrix `a` (M, M) together with pivot indices.
-    b : {(M,), (..., M, K)} {dpnp.ndarray, usm_ndarray}
-        Right-hand side
-    trans : {0, 1, 2} , optional
-        Type of system to solve:
-
-        =====  =================
-        trans  system
-        =====  =================
-        0      :math:`a x = b`
-        1      :math:`a^T x = b`
-        2      :math:`a^H x = b`
-        =====  =================
-
-        Default: ``0``.
-    overwrite_b : {None, bool}, optional
-        Whether to overwrite data in `b` (may increase performance).
-
-        Default: ``False``.
-    check_finite : {None, bool}, optional
-        Whether to check that the input matrix contains only finite numbers.
-        Disabling may give a performance gain, but may result in problems
-        (crashes, non-termination) if the inputs do contain infinities or NaNs.
-
-        Default: ``True``.
-
-    Returns
-    -------
-    x : {(M,), (M, K)} dpnp.ndarray
-        Solution to the system
-
-    Warning
-    -------
-    This function synchronizes in order to validate array elements
-    when ``check_finite=True``.
-
-    See Also
-    --------
-    :obj:`dpnp.linalg.lu_factor` : LU factorize a matrix.
-
-    Examples
-    --------
-    >>> import dpnp as np
-    >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
-    >>> b = np.array([1, 1, 1, 1])
-    >>> lu, piv = np.linalg.lu_factor(A)
-    >>> x = np.linalg.lu_solve((lu, piv), b)
-    >>> np.allclose(A @ x - b, np.zeros((4,)))
-    array(True)
-
-    """
-
-    (lu, piv) = lu_and_piv
-    dpnp.check_supported_arrays_type(lu, piv, b)
-    assert_stacked_2d(lu)
-
-    return dpnp_lu_solve(
-        lu,
-        piv,
-        b,
-        trans=trans,
-        overwrite_b=overwrite_b,
-        check_finite=check_finite,
-    )
-
-
 def matmul(x1, x2, /):
     """
     Computes the matrix product.