mindspore.scipy.linalg.eigh

mindspore.scipy.linalg.eigh(a, b=None, lower=True, eigvals_only=False, overwrite_a=False, overwrite_b=False, turbo=True, eigvals=None, _type=1, check_finite=True)[source]

Solve a standard or generalized eigenvalue problem for a complex Hermitian or real symmetric matrix.

Find eigenvalues Tensor w and optionally eigenvectors Tensor v of Tensor a, where b is positive definite such that for every eigenvalue λ (i-th entry of w) and its eigenvector vi (i-th column of v) satisfies:

              a @ vi = λ * b @ vi
vi.conj().T @ a @ vi = λ
vi.conj().T @ b @ vi = 1

In the standard problem, b is assumed to be the identity matrix.

Parameters

  • a (Tensor) – A \((M, M)\) complex Hermitian or real symmetric matrix whose eigenvalues and eigenvectors will be computed.

  • b (Tensor, optional) – A \((M, M)\) complex Hermitian or real symmetric definite positive matrix in. If omitted, identity matrix is assumed. Default: None.

  • lower (bool, optional) – Whether the pertinent Tensor data is taken from the lower or upper triangle of a and, if applicable, b. Default: True.

  • eigvals_only (bool, optional) – Whether to calculate only eigenvalues and no eigenvectors. Default: False.

  • _type (int, optional) –

    For the generalized problems, this keyword specifies the problem type to be solved for w and v (only takes 1, 2, 3 as possible inputs):

    1 =>     a @ v = w @ b @ v
2 => a @ b @ v = w @ v
3 => b @ a @ v = w @ v

    This keyword is ignored for standard problems. Default: 1.

  • overwrite_a (bool, optional) – Whether to overwrite data in a (may improve performance). Default: False.

  • overwrite_b (bool, optional) – Whether to overwrite data in b (may improve performance). Default: False.

  • check_finite (bool, optional) – Whether to check that the input matrices contain 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.

  • turbo (bool, optional) – use divide and conquer algorithm (faster but expensive in memory, only for generalized eigenvalue problem and if full set of eigenvalues are requested.). Has no significant effect if eigenvectors are not requested. Default: True.

  • eigvals (tuple, optional) – Indexes of the smallest and largest (in ascending order) eigenvalues and corresponding eigenvectors to be returned: \(0 <= lo <= hi <= M-1\). If omitted, all eigenvalues and eigenvectors are returned. Default: None.

Returns

  • Tensor with shape \((N,)\), the \(N (1<=N<=M)\) selected eigenvalues, in ascending order, each repeated according to its multiplicity.

  • Tensor with shape \((M, N)\), (if eigvals_only == False)

Raises

LinAlgError – If eigenvalue computation does not converge, an error occurred, or b matrix is not definite positive. Note that if input matrices are not symmetric or Hermitian, no error will be reported but results will be wrong.

Supported Platforms:

CPU GPU

Examples

>>> import mindspore.numpy as mnp
>>> from mindspore.common import Tensor
>>> from mindspore.scipy.linalg import eigh
>>> A = Tensor([[6., 3., 1., 5.], [3., 0., 5., 1.], [1., 5., 6., 2.], [5., 1., 2., 2.]])
>>> w, v = eigh(A)
>>> mnp.sum(mnp.dot(A, v) - mnp.dot(v, mnp.diag(w))) < 1e-10
Tensor(shape=[], dtype=Bool, value= True)