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)[源代码]

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.

Note

  • eigh is not supported on Windows platform yet.

  • Only float32, float64, int32, int64 are supported Tensor dtypes. If Tensor with dtype int32 or int64 is passed, it will be cast to mstype.float64.

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

  • RuntimeError – 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.

  • TypeError – If a is not Tensor.

  • TypeError – If lower is not bool.

  • TypeError – If eigvals_only is not bool.

  • TypeError – If overwrite_a is not bool.

  • TypeError – If overwrite_b is not bool.

  • TypeError – If turbo is not bool.

  • TypeError – If check_finite is not bool.

  • ValueError – If a is not square matrix.

  • ValueError – If b is not None.

  • ValueError – If eigvals is not None.

Supported Platforms:

CPU GPU

Examples

>>> import numpy as onp
>>> import mindspore.numpy as mnp
>>> from mindspore.common import Tensor, dtype
>>> from mindspore.scipy.linalg import eigh
>>> a = Tensor([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]], dtype.float64)
>>> w, v = eigh(a)
>>> print(onp.allclose(mnp.dot(a, v).asnumpy(), mnp.dot(v, mnp.diag(w)).asnumpy(), 1e-5, 1e-8))
True