5542080114

# cython: language_level=3
# distutils: language = c++
# -*- coding: utf-8 -*-
# *****************************************************************************
# Copyright (c) 2016-2023, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# - Redistributions of source code must retain the above copyright notice,
#   this list of conditions and the following disclaimer.
# - Redistributions in binary form must reproduce the above copyright notice,
#   this list of conditions and the following disclaimer in the documentation
#   and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
# THE POSSIBILITY OF SUCH DAMAGE.
# *****************************************************************************

"""
Interface of the Linear Algebra part of the DPNP

Notes
-----
This module is a face or public interface file for the library
it contains:
 - Interface functions
 - documentation for the functions
 - The functions parameters check

"""


import numpy

import dpnp
from dpnp.dpnp_algo import *
from dpnp.dpnp_utils import *
from dpnp.linalg.dpnp_algo_linalg import *

from .dpnp_utils_linalg import dpnp_eigh

__all__ = [
    "cholesky",
    "cond",
    "det",
    "eig",
    "eigh",
    "eigvals",
    "inv",
    "matrix_power",
    "matrix_rank",
    "multi_dot",
    "norm",
    "qr",
    "svd",
]


def cholesky(input):
    """
    Cholesky decomposition.

    Return the Cholesky decomposition, `L * L.H`, of the square matrix `input`,
    where `L` is lower-triangular and .H is the conjugate transpose operator
    (which is the ordinary transpose if `input` is real-valued).  `input` must be
    Hermitian (symmetric if real-valued) and positive-definite. No
    checking is performed to verify whether `a` is Hermitian or not.
    In addition, only the lower-triangular and diagonal elements of `input`
    are used. Only `L` is actually returned.

    Parameters
    ----------
    input : (..., M, M) array_like
        Hermitian (symmetric if all elements are real), positive-definite
        input matrix.

    Returns
    -------
    L : (..., M, M) array_like
        Upper or lower-triangular Cholesky factor of `input`.  Returns a
        matrix object if `input` is a matrix object.
    """

    x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)
    if x1_desc:
        if x1_desc.shape[-1] != x1_desc.shape[-2]:
            pass
        else:
            if input.dtype == dpnp.int32 or input.dtype == dpnp.int64:
                dev = x1_desc.get_array().sycl_device
                if dev.has_aspect_fp64:
                    dtype = dpnp.float64
                else:
                    dtype = dpnp.float32
                # TODO memory copy. needs to move into DPNPC
                input_ = dpnp.get_dpnp_descriptor(
                    dpnp.astype(input, dtype=dtype),
                    copy_when_nondefault_queue=False,
                )
            else:
                input_ = x1_desc
            return dpnp_cholesky(input_).get_pyobj()

    return call_origin(numpy.linalg.cholesky, input)


def cond(input, p=None):
    """
    Compute the condition number of a matrix.

    For full documentation refer to :obj:`numpy.linalg.cond`.

    Limitations
    -----------
    Input array is supported as :obj:`dpnp.ndarray`.
    Parameter p=[None, 1, -1, 2, -2, dpnp.inf, -dpnp.inf, 'fro'] is supported.

    See Also
    --------
    :obj:`dpnp.norm` : Matrix or vector norm.
    """

    if not use_origin_backend(input):
        if p in [None, 1, -1, 2, -2, dpnp.inf, -dpnp.inf, "fro"]:
            result_obj = dpnp_cond(input, p)
            result = dpnp.convert_single_elem_array_to_scalar(result_obj)

            return result
        else:
            pass

    return call_origin(numpy.linalg.cond, input, p)


def det(input):
    """
    Compute the determinant of an array.

    Parameters
    ----------
    input : (..., M, M) array_like
        Input array to compute determinants for.

    Returns
    -------
    det : (...) array_like
        Determinant of `input`.
    """

    x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)
    if x1_desc:
        if x1_desc.shape[-1] == x1_desc.shape[-2]:
            result_obj = dpnp_det(x1_desc).get_pyobj()
            result = dpnp.convert_single_elem_array_to_scalar(result_obj)

            return result

    return call_origin(numpy.linalg.det, input)


def eig(x1):
    """
    Compute the eigenvalues and right eigenvectors of a square array.

    .. seealso:: :obj:`numpy.linalg.eig`

    """

    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
    if x1_desc:
        if x1_desc.size > 0:
            return dpnp_eig(x1_desc)

    return call_origin(numpy.linalg.eig, x1)


def eigh(a, UPLO="L"):
    """
    eigh(a, UPLO="L")

    Return the eigenvalues and eigenvectors of a complex Hermitian
    (conjugate symmetric) or a real symmetric matrix.

    Returns two objects, a 1-D array containing the eigenvalues of `a`, and
    a 2-D square array or matrix (depending on the input type) of the
    corresponding eigenvectors (in columns).

    For full documentation refer to :obj:`numpy.linalg.eigh`.

    Returns
    -------
    w : (..., M) dpnp.ndarray
        The eigenvalues in ascending order, each repeated according to
        its multiplicity.
    v : (..., M, M) dpnp.ndarray
        The column ``v[:, i]`` is the normalized eigenvector corresponding
        to the eigenvalue ``w[i]``.

    Limitations
    -----------
    Parameter `a` is supported as :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
    Input array data types are limited by supported DPNP :ref:`Data types`.

    See Also
    --------
    :obj:`dpnp.eig` : eigenvalues and right eigenvectors for non-symmetric arrays.
    :obj:`dpnp.eigvals` : eigenvalues of non-symmetric arrays.

    Examples
    --------
    >>> import dpnp as dp
    >>> a = dp.array([[1, -2j], [2j, 5]])
    >>> a
    array([[ 1.+0.j, -0.-2.j],
           [ 0.+2.j,  5.+0.j]])
    >>> w, v = dp.linalg.eigh(a)
    >>> w; v
    array([0.17157288, 5.82842712]),
    array([[-0.92387953-0.j        , -0.38268343+0.j        ], # may vary
           [ 0.        +0.38268343j,  0.        -0.92387953j]]))

    """

    if UPLO not in ("L", "U"):
        raise ValueError("UPLO argument must be 'L' or 'U'")

    if not dpnp.is_supported_array_type(a):
        raise TypeError(
            "An array must be any of supported type, but got {}".format(type(a))
        )

    if a.ndim < 2:
        raise ValueError(
            "%d-dimensional array given. Array must be "
            "at least two-dimensional" % a.ndim
        )

    m, n = a.shape[-2:]
    if m != n:
        raise ValueError("Last 2 dimensions of the array must be square")

    return dpnp_eigh(a, UPLO=UPLO)


def eigvals(input):
    """
    Compute the eigenvalues of a general matrix.

    Main difference between `eigvals` and `eig`: the eigenvectors aren't
    returned.

    Parameters
    ----------
    input : (..., M, M) array_like
        A complex- or real-valued matrix whose eigenvalues will be computed.

    Returns
    -------
    w : (..., M,) ndarray
        The eigenvalues, each repeated according to its multiplicity.
        They are not necessarily ordered, nor are they necessarily
        real for real matrices.
    """

    x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)
    if x1_desc:
        if x1_desc.size > 0:
            return dpnp_eigvals(x1_desc).get_pyobj()

    return call_origin(numpy.linalg.eigvals, input)


def inv(input):
    """
    Divide arguments element-wise.

    For full documentation refer to :obj:`numpy.linalg.inv`.

    Limitations
    -----------
        Input array is supported as :obj:`dpnp.ndarray`.
        Dimension of input array is supported to be equal to ``2``.
        Shape of input array is limited by ``input.shape[0] == input.shape[1]``, ``input.shape[0] >= 2``.
        Otherwise the function will be executed sequentially on CPU.
    """

    x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)
    if x1_desc:
        if (
            x1_desc.ndim == 2
            and x1_desc.shape[0] == x1_desc.shape[1]
            and x1_desc.shape[0] >= 2
        ):
            return dpnp_inv(x1_desc).get_pyobj()

    return call_origin(numpy.linalg.inv, input)


def matrix_power(input, count):
    """
    Raise a square matrix to the (integer) power `count`.

    Parameters
    ----------
    input : sequence of array_like

    Returns
    -------
    output : array
        Returns the dot product of the supplied arrays.

    See Also
    --------
    :obj:`numpy.linalg.matrix_power`

    """

    if not use_origin_backend() and count > 0:
        result = input
        for _ in range(count - 1):
            result = dpnp.matmul(result, input)

        return result

    return call_origin(numpy.linalg.matrix_power, input, count)


def matrix_rank(input, tol=None, hermitian=False):
    """
    Return matrix rank of array.

    Rank of the array is the number of singular values of the array that are
    greater than `tol`.

    Parameters
    ----------
    M : {(M,), (..., M, N)} array_like
        Input vector or stack of matrices.
    tol : (...) array_like, float, optional
        Threshold below which SVD values are considered zero. If `tol` is
        None, and ``S`` is an array with singular values for `M`, and
        ``eps`` is the epsilon value for datatype of ``S``, then `tol` is
        set to ``S.max() * max(M.shape) * eps``.
    hermitian : bool, optional
        If True, `M` is assumed to be Hermitian (symmetric if real-valued),
        enabling a more efficient method for finding singular values.
        Defaults to False.

    Returns
    -------
    rank : (...) array_like
        Rank of M.

    """

    x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)
    if x1_desc:
        if tol is not None:
            pass
        elif hermitian:
            pass
        else:
            result_obj = dpnp_matrix_rank(x1_desc).get_pyobj()
            result = dpnp.convert_single_elem_array_to_scalar(result_obj)

            return result

    return call_origin(numpy.linalg.matrix_rank, input, tol, hermitian)


def multi_dot(arrays, out=None):
    """
    Compute the dot product of two or more arrays in a single function call

    Parameters
    ----------
    arrays : sequence of array_like
        If the first argument is 1-D it is treated as row vector.
        If the last argument is 1-D it is treated as column vector.
        The other arguments must be 2-D.
    out : ndarray, optional
        unsupported

    Returns
    -------
    output : ndarray
        Returns the dot product of the supplied arrays.

    See Also
    --------
    :obj:`numpy.multi_dot`

    """

    n = len(arrays)

    if n < 2:
        checker_throw_value_error("multi_dot", "arrays", n, ">1")

    result = arrays[0]
    for id in range(1, n):
        result = dpnp.dot(result, arrays[id])

    return result


def norm(x1, ord=None, axis=None, keepdims=False):
    """
    Matrix or vector norm.

    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter.

    Parameters
    ----------
    input : array_like
        Input array.  If `axis` is None, `x` must be 1-D or 2-D, unless `ord`
        is None. If both `axis` and `ord` are None, the 2-norm of
        ``x.ravel`` will be returned.
    ord : optional
        Order of the norm (see table under ``Notes``). inf means numpy's
        `inf` object. The default is None.
    axis : optional.
        If `axis` is an integer, it specifies the axis of `x` along which to
        compute the vector norms.  If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed.  If `axis` is None then either a vector norm (when `x`
        is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default
        is None.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one.  With this option the result will
        broadcast correctly against the original `x`.

    Returns
    -------
    n : float or ndarray
        Norm of the matrix or vector(s).
    """

    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
    if x1_desc:
        if (
            not isinstance(axis, int)
            and not isinstance(axis, tuple)
            and axis is not None
        ):
            pass
        elif keepdims is not False:
            pass
        elif ord not in [None, 0, 3, "fro", "f"]:
            pass
        else:
            result_obj = dpnp_norm(x1, ord=ord, axis=axis)
            result = dpnp.convert_single_elem_array_to_scalar(result_obj)

            return result

    return call_origin(numpy.linalg.norm, x1, ord, axis, keepdims)


def qr(x1, mode="reduced"):
    """
    Compute the qr factorization of a matrix.

    Factor the matrix `a` as *qr*, where `q` is orthonormal and `r` is
    upper-triangular.

    For full documentation refer to :obj:`numpy.linalg.qr`.

    Limitations
    -----------
    Input array is supported as :obj:`dpnp.ndarray`.
    Parameter mode='reduced' is supported.

    """

    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
    if x1_desc:
        if mode != "reduced":
            pass
        else:
            result_tup = dpnp_qr(x1_desc, mode)

            return result_tup

    return call_origin(numpy.linalg.qr, x1, mode)


def svd(x1, full_matrices=True, compute_uv=True, hermitian=False):
    """
    Singular Value Decomposition.

    For full documentation refer to :obj:`numpy.linalg.svd`.

    Examples
    --------
    >>> import dpnp as np
    >>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
    >>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)

    Reconstruction based on full SVD, 2D case:

    >>> u, s, vh = np.linalg.svd(a, full_matrices=True)
    >>> u.shape, s.shape, vh.shape
    ((9, 9), (6,), (6, 6))
    >>> np.allclose(a, np.dot(u[:, :6] * s, vh))
    True
    >>> smat = np.zeros((9, 6), dtype=complex)
    >>> smat[:6, :6] = np.diag(s)
    >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
    True

    Reconstruction based on reduced SVD, 2D case:

    >>> u, s, vh = np.linalg.svd(a, full_matrices=False)
    >>> u.shape, s.shape, vh.shape
    ((9, 6), (6,), (6, 6))
    >>> np.allclose(a, np.dot(u * s, vh))
    True
    >>> smat = np.diag(s)
    >>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
    True

    Reconstruction based on full SVD, 4D case:

    >>> u, s, vh = np.linalg.svd(b, full_matrices=True)
    >>> u.shape, s.shape, vh.shape
    ((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
    >>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))
    True
    >>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))
    True

    Reconstruction based on reduced SVD, 4D case:

    >>> u, s, vh = np.linalg.svd(b, full_matrices=False)
    >>> u.shape, s.shape, vh.shape
    ((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
    >>> np.allclose(b, np.matmul(u * s[..., None, :], vh))
    True
    >>> np.allclose(b, np.matmul(u, s[..., None] * vh))
    True

    """

    x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)
    if x1_desc:
        if not x1_desc.ndim == 2:
            pass
        elif full_matrices is not True:
            pass
        elif compute_uv is not True:
            pass
        elif hermitian is not False:
            pass
        else:
            result_tup = dpnp_svd(x1_desc, full_matrices, compute_uv, hermitian)

            return result_tup

    return call_origin(
        numpy.linalg.svd, x1, full_matrices, compute_uv, hermitian
    )

1	# cython: language_level=3
2	# distutils: language = c++
3	# -- coding: utf-8 --
4	# *****************************************************************************
5	# Copyright (c) 2016-2023, Intel Corporation
6	# All rights reserved.
7	#
8	# Redistribution and use in source and binary forms, with or without
9	# modification, are permitted provided that the following conditions are met:
10	# - Redistributions of source code must retain the above copyright notice,
11	# this list of conditions and the following disclaimer.
12	# - Redistributions in binary form must reproduce the above copyright notice,
13	# this list of conditions and the following disclaimer in the documentation
14	# and/or other materials provided with the distribution.
15	#
16	# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
17	# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18	# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
19	# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
20	# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21	# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22	# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23	# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24	# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25	# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
26	# THE POSSIBILITY OF SUCH DAMAGE.
27	# *****************************************************************************
28
29	"""	1✔
30	Interface of the Linear Algebra part of the DPNP
31
32	Notes
33	-----
34	This module is a face or public interface file for the library
35	it contains:
36	- Interface functions
37	- documentation for the functions
38	- The functions parameters check
39
40	"""
41
42
43	import numpy	1✔
44
45	import dpnp	1✔
46	from dpnp.dpnp_algo import *	1✔
47	from dpnp.dpnp_utils import *	1✔
48	from dpnp.linalg.dpnp_algo_linalg import *	1✔
49
50	from .dpnp_utils_linalg import dpnp_eigh	1✔
51
52	__all__ = [	1✔
53	"cholesky",
54	"cond",
55	"det",
56	"eig",
57	"eigh",
58	"eigvals",
59	"inv",
60	"matrix_power",
61	"matrix_rank",
62	"multi_dot",
63	"norm",
64	"qr",
65	"svd",
66	]
67
68
69	def cholesky(input):	1✔
70	"""
71	Cholesky decomposition.
72
73	Return the Cholesky decomposition, `L * L.H`, of the square matrix `input`,
74	where `L` is lower-triangular and .H is the conjugate transpose operator
75	(which is the ordinary transpose if `input` is real-valued). `input` must be
76	Hermitian (symmetric if real-valued) and positive-definite. No
77	checking is performed to verify whether `a` is Hermitian or not.
78	In addition, only the lower-triangular and diagonal elements of `input`
79	are used. Only `L` is actually returned.
80
81	Parameters
82	----------
83	input : (..., M, M) array_like
84	Hermitian (symmetric if all elements are real), positive-definite
85	input matrix.
86
87	Returns
88	-------
89	L : (..., M, M) array_like
90	Upper or lower-triangular Cholesky factor of `input`. Returns a
91	matrix object if `input` is a matrix object.
92	"""
93
94	x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)	1✔
95	if x1_desc:	1!
96	if x1_desc.shape[-1] != x1_desc.shape[-2]:	1!
97	pass	×
98	else:
99	if input.dtype == dpnp.int32 or input.dtype == dpnp.int64:	1✔
100	dev = x1_desc.get_array().sycl_device	1✔
101	if dev.has_aspect_fp64:	1!
102	dtype = dpnp.float64	1✔
103	else:
NEW 104	dtype = dpnp.float32	×
105	# TODO memory copy. needs to move into DPNPC
106	input_ = dpnp.get_dpnp_descriptor(	1✔
107	dpnp.astype(input, dtype=dtype),
108	copy_when_nondefault_queue=False,
109	)
110	else:
111	input_ = x1_desc	1✔
112	return dpnp_cholesky(input_).get_pyobj()	1✔
113
114	return call_origin(numpy.linalg.cholesky, input)	×
115
116
117	def cond(input, p=None):	1✔
118	"""
119	Compute the condition number of a matrix.
120
121	For full documentation refer to :obj:`numpy.linalg.cond`.
122
123	Limitations
124	-----------
125	Input array is supported as :obj:`dpnp.ndarray`.
126	Parameter p=[None, 1, -1, 2, -2, dpnp.inf, -dpnp.inf, 'fro'] is supported.
127
128	See Also
129	--------
130	:obj:`dpnp.norm` : Matrix or vector norm.
131	"""
132
133	if not use_origin_backend(input):	1!
134	if p in [None, 1, -1, 2, -2, dpnp.inf, -dpnp.inf, "fro"]:	1!
135	result_obj = dpnp_cond(input, p)	1✔
136	result = dpnp.convert_single_elem_array_to_scalar(result_obj)	1✔
137
138	return result	1✔
139	else:
140	pass	×
141
142	return call_origin(numpy.linalg.cond, input, p)	×
143
144
145	def det(input):	1✔
146	"""
147	Compute the determinant of an array.
148
149	Parameters
150	----------
151	input : (..., M, M) array_like
152	Input array to compute determinants for.
153
154	Returns
155	-------
156	det : (...) array_like
157	Determinant of `input`.
158	"""
159
160	x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)	1✔
161	if x1_desc:	1!
162	if x1_desc.shape[-1] == x1_desc.shape[-2]:	1!
163	result_obj = dpnp_det(x1_desc).get_pyobj()	1✔
164	result = dpnp.convert_single_elem_array_to_scalar(result_obj)	1✔
165
166	return result	1✔
167
168	return call_origin(numpy.linalg.det, input)	×
169
170
171	def eig(x1):	1✔
172	"""
173	Compute the eigenvalues and right eigenvectors of a square array.
174
175	.. seealso:: :obj:`numpy.linalg.eig`
176
177	"""
178
179	x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)	1✔
180	if x1_desc:	1!
181	if x1_desc.size > 0:	1!
182	return dpnp_eig(x1_desc)	1✔
183
184	return call_origin(numpy.linalg.eig, x1)	×
185
186
187	def eigh(a, UPLO="L"):	1✔
188	"""
189	eigh(a, UPLO="L")
190
191	Return the eigenvalues and eigenvectors of a complex Hermitian
192	(conjugate symmetric) or a real symmetric matrix.
193
194	Returns two objects, a 1-D array containing the eigenvalues of `a`, and
195	a 2-D square array or matrix (depending on the input type) of the
196	corresponding eigenvectors (in columns).
197
198	For full documentation refer to :obj:`numpy.linalg.eigh`.
199
200	Returns
201	-------
202	w : (..., M) dpnp.ndarray
203	The eigenvalues in ascending order, each repeated according to
204	its multiplicity.
205	v : (..., M, M) dpnp.ndarray
206	The column ``v[:, i]`` is the normalized eigenvector corresponding
207	to the eigenvalue ``w[i]``.
208
209	Limitations
210	-----------
211	Parameter `a` is supported as :class:`dpnp.ndarray` or :class:`dpctl.tensor.usm_ndarray`.
212	Input array data types are limited by supported DPNP :ref:`Data types`.
213
214	See Also
215	--------
216	:obj:`dpnp.eig` : eigenvalues and right eigenvectors for non-symmetric arrays.
217	:obj:`dpnp.eigvals` : eigenvalues of non-symmetric arrays.
218
219	Examples
220	--------
221	>>> import dpnp as dp
222	>>> a = dp.array([[1, -2j], [2j, 5]])
223	>>> a
224	array([[ 1.+0.j, -0.-2.j],
225	[ 0.+2.j, 5.+0.j]])
226	>>> w, v = dp.linalg.eigh(a)
227	>>> w; v
228	array([0.17157288, 5.82842712]),
229	array([[-0.92387953-0.j , -0.38268343+0.j ], # may vary
230	[ 0. +0.38268343j, 0. -0.92387953j]]))
231
232	"""
233
234	if UPLO not in ("L", "U"):	1!
235	raise ValueError("UPLO argument must be 'L' or 'U'")	×
236
237	if not dpnp.is_supported_array_type(a):	1!
238	raise TypeError(	×
239	"An array must be any of supported type, but got {}".format(type(a))
240	)
241
242	if a.ndim < 2:	1✔
243	raise ValueError(	1✔
244	"%d-dimensional array given. Array must be "
245	"at least two-dimensional" % a.ndim
246	)
247
248	m, n = a.shape[-2:]	1✔
249	if m != n:	1✔
250	raise ValueError("Last 2 dimensions of the array must be square")	1✔
251
252	return dpnp_eigh(a, UPLO=UPLO)	1✔
253
254
255	def eigvals(input):	1✔
256	"""
257	Compute the eigenvalues of a general matrix.
258
259	Main difference between `eigvals` and `eig`: the eigenvectors aren't
260	returned.
261
262	Parameters
263	----------
264	input : (..., M, M) array_like
265	A complex- or real-valued matrix whose eigenvalues will be computed.
266
267	Returns
268	-------
269	w : (..., M,) ndarray
270	The eigenvalues, each repeated according to its multiplicity.
271	They are not necessarily ordered, nor are they necessarily
272	real for real matrices.
273	"""
274
275	x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)	×
276	if x1_desc:	×
277	if x1_desc.size > 0:	×
278	return dpnp_eigvals(x1_desc).get_pyobj()	×
279
280	return call_origin(numpy.linalg.eigvals, input)	×
281
282
283	def inv(input):	1✔
284	"""
285	Divide arguments element-wise.
286
287	For full documentation refer to :obj:`numpy.linalg.inv`.
288
289	Limitations
290	-----------
291	Input array is supported as :obj:`dpnp.ndarray`.
292	Dimension of input array is supported to be equal to ``2``.
293	Shape of input array is limited by ``input.shape[0] == input.shape[1]``, ``input.shape[0] >= 2``.
294	Otherwise the function will be executed sequentially on CPU.
295	"""
296
297	x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)	1✔
298	if x1_desc:	1!
299	if (	1!
300	x1_desc.ndim == 2
301	and x1_desc.shape[0] == x1_desc.shape[1]
302	and x1_desc.shape[0] >= 2
303	):
304	return dpnp_inv(x1_desc).get_pyobj()	1✔
305
306	return call_origin(numpy.linalg.inv, input)	×
307
308
309	def matrix_power(input, count):	1✔
310	"""
311	Raise a square matrix to the (integer) power `count`.
312
313	Parameters
314	----------
315	input : sequence of array_like
316
317	Returns
318	-------
319	output : array
320	Returns the dot product of the supplied arrays.
321
322	See Also
323	--------
324	:obj:`numpy.linalg.matrix_power`
325
326	"""
327
328	if not use_origin_backend() and count > 0:	1✔
329	result = input	1✔
330	for _ in range(count - 1):	1✔
331	result = dpnp.matmul(result, input)	1✔
332
333	return result	1✔
334
335	return call_origin(numpy.linalg.matrix_power, input, count)	1✔
336
337
338	def matrix_rank(input, tol=None, hermitian=False):	1✔
339	"""
340	Return matrix rank of array.
341
342	Rank of the array is the number of singular values of the array that are
343	greater than `tol`.
344
345	Parameters
346	----------
347	M : {(M,), (..., M, N)} array_like
348	Input vector or stack of matrices.
349	tol : (...) array_like, float, optional
350	Threshold below which SVD values are considered zero. If `tol` is
351	None, and ``S`` is an array with singular values for `M`, and
352	``eps`` is the epsilon value for datatype of ``S``, then `tol` is
353	set to ``S.max() * max(M.shape) * eps``.
354	hermitian : bool, optional
355	If True, `M` is assumed to be Hermitian (symmetric if real-valued),
356	enabling a more efficient method for finding singular values.
357	Defaults to False.
358
359	Returns
360	-------
361	rank : (...) array_like
362	Rank of M.
363
364	"""
365
366	x1_desc = dpnp.get_dpnp_descriptor(input, copy_when_nondefault_queue=False)	1✔
367	if x1_desc:	1!
368	if tol is not None:	1!
369	pass	×
370	elif hermitian:	1!
371	pass	×
372	else:
373	result_obj = dpnp_matrix_rank(x1_desc).get_pyobj()	1✔
374	result = dpnp.convert_single_elem_array_to_scalar(result_obj)	1✔
375
376	return result	1✔
377
378	return call_origin(numpy.linalg.matrix_rank, input, tol, hermitian)	×
379
380
381	def multi_dot(arrays, out=None):	1✔
382	"""
383	Compute the dot product of two or more arrays in a single function call
384
385	Parameters
386	----------
387	arrays : sequence of array_like
388	If the first argument is 1-D it is treated as row vector.
389	If the last argument is 1-D it is treated as column vector.
390	The other arguments must be 2-D.
391	out : ndarray, optional
392	unsupported
393
394	Returns
395	-------
396	output : ndarray
397	Returns the dot product of the supplied arrays.
398
399	See Also
400	--------
401	:obj:`numpy.multi_dot`
402
403	"""
404
405	n = len(arrays)	1✔
406
407	if n < 2:	1!
408	checker_throw_value_error("multi_dot", "arrays", n, ">1")	×
409
410	result = arrays[0]	1✔
411	for id in range(1, n):	1✔
412	result = dpnp.dot(result, arrays[id])	1✔
413
414	return result	1✔
415
416
417	def norm(x1, ord=None, axis=None, keepdims=False):	1✔
418	"""
419	Matrix or vector norm.
420
421	This function is able to return one of eight different matrix norms,
422	or one of an infinite number of vector norms (described below), depending
423	on the value of the ``ord`` parameter.
424
425	Parameters
426	----------
427	input : array_like
428	Input array. If `axis` is None, `x` must be 1-D or 2-D, unless `ord`
429	is None. If both `axis` and `ord` are None, the 2-norm of
430	``x.ravel`` will be returned.
431	ord : optional
432	Order of the norm (see table under ``Notes``). inf means numpy's
433	`inf` object. The default is None.
434	axis : optional.
435	If `axis` is an integer, it specifies the axis of `x` along which to
436	compute the vector norms. If `axis` is a 2-tuple, it specifies the
437	axes that hold 2-D matrices, and the matrix norms of these matrices
438	are computed. If `axis` is None then either a vector norm (when `x`
439	is 1-D) or a matrix norm (when `x` is 2-D) is returned. The default
440	is None.
441	keepdims : bool, optional
442	If this is set to True, the axes which are normed over are left in the
443	result as dimensions with size one. With this option the result will
444	broadcast correctly against the original `x`.
445
446	Returns
447	-------
448	n : float or ndarray
449	Norm of the matrix or vector(s).
450	"""
451
452	x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)	1✔
453	if x1_desc:	1!
454	if (	1!
455	not isinstance(axis, int)
456	and not isinstance(axis, tuple)
457	and axis is not None
458	):
459	pass	×
460	elif keepdims is not False:	1!
461	pass	×
462	elif ord not in [None, 0, 3, "fro", "f"]:	1✔
463	pass	1✔
464	else:
465	result_obj = dpnp_norm(x1, ord=ord, axis=axis)	1✔
466	result = dpnp.convert_single_elem_array_to_scalar(result_obj)	1✔
467
468	return result	1✔
469
470	return call_origin(numpy.linalg.norm, x1, ord, axis, keepdims)	1✔
471
472
473	def qr(x1, mode="reduced"):	1✔
474	"""
475	Compute the qr factorization of a matrix.
476
477	Factor the matrix `a` as qr, where `q` is orthonormal and `r` is
478	upper-triangular.
479
480	For full documentation refer to :obj:`numpy.linalg.qr`.
481
482	Limitations
483	-----------
484	Input array is supported as :obj:`dpnp.ndarray`.
485	Parameter mode='reduced' is supported.
486
487	"""
488
489	x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)	1✔
490	if x1_desc:	1!
491	if mode != "reduced":	1✔
492	pass	1✔
493	else:
494	result_tup = dpnp_qr(x1_desc, mode)	1✔
495
496	return result_tup	1✔
497
498	return call_origin(numpy.linalg.qr, x1, mode)	1✔
499
500
501	def svd(x1, full_matrices=True, compute_uv=True, hermitian=False):	1✔
502	"""
503	Singular Value Decomposition.
504
505	For full documentation refer to :obj:`numpy.linalg.svd`.
506
507	Examples
508	--------
509	>>> import dpnp as np
510	>>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)
511	>>> b = np.random.randn(2, 7, 8, 3) + 1j*np.random.randn(2, 7, 8, 3)
512
513	Reconstruction based on full SVD, 2D case:
514
515	>>> u, s, vh = np.linalg.svd(a, full_matrices=True)
516	>>> u.shape, s.shape, vh.shape
517	((9, 9), (6,), (6, 6))
518	>>> np.allclose(a, np.dot(u[:, :6] * s, vh))
519	True
520	>>> smat = np.zeros((9, 6), dtype=complex)
521	>>> smat[:6, :6] = np.diag(s)
522	>>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
523	True
524
525	Reconstruction based on reduced SVD, 2D case:
526
527	>>> u, s, vh = np.linalg.svd(a, full_matrices=False)
528	>>> u.shape, s.shape, vh.shape
529	((9, 6), (6,), (6, 6))
530	>>> np.allclose(a, np.dot(u * s, vh))
531	True
532	>>> smat = np.diag(s)
533	>>> np.allclose(a, np.dot(u, np.dot(smat, vh)))
534	True
535
536	Reconstruction based on full SVD, 4D case:
537
538	>>> u, s, vh = np.linalg.svd(b, full_matrices=True)
539	>>> u.shape, s.shape, vh.shape
540	((2, 7, 8, 8), (2, 7, 3), (2, 7, 3, 3))
541	>>> np.allclose(b, np.matmul(u[..., :3] * s[..., None, :], vh))
542	True
543	>>> np.allclose(b, np.matmul(u[..., :3], s[..., None] * vh))
544	True
545
546	Reconstruction based on reduced SVD, 4D case:
547
548	>>> u, s, vh = np.linalg.svd(b, full_matrices=False)
549	>>> u.shape, s.shape, vh.shape
550	((2, 7, 8, 3), (2, 7, 3), (2, 7, 3, 3))
551	>>> np.allclose(b, np.matmul(u * s[..., None, :], vh))
552	True
553	>>> np.allclose(b, np.matmul(u, s[..., None] * vh))
554	True
555
556	"""
557
558	x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_nondefault_queue=False)	1✔
559	if x1_desc:	1!
560	if not x1_desc.ndim == 2:	1!
561	pass	×
562	elif full_matrices is not True:	1!
563	pass	×
564	elif compute_uv is not True:	1!
565	pass	×
566	elif hermitian is not False:	1!
567	pass	×
568	else:
569	result_tup = dpnp_svd(x1_desc, full_matrices, compute_uv, hermitian)	1✔
570
571	return result_tup	1✔
572
573	return call_origin(	×
574	numpy.linalg.svd, x1, full_matrices, compute_uv, hermitian
575	)

IntelPython / dpnp / 5542080114

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous