jax.scipy.linalg.eigh#

jax.scipy.linalg.eigh(a: Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex], b: Optional[Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex]] = None, lower: bool = True, eigvals_only: Literal[False] = False, overwrite_a: bool = False, overwrite_b: bool = False, turbo: bool = True, eigvals: None = None, type: int = 1, check_finite: bool = True) Tuple[jax.Array, jax.Array][source]#
jax.scipy.linalg.eigh(a: Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex], b: Optional[Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex]] = None, lower: bool = True, *, eigvals_only: Literal[True], overwrite_a: bool = 'False', overwrite_b: bool = 'False', turbo: bool = 'True', eigvals: None = 'None', type: int = '1', check_finite: bool = 'True') jax.Array
jax.scipy.linalg.eigh(a: Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex], b: Optional[Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex]], lower: bool, eigvals_only: Literal[True], overwrite_a: bool = False, overwrite_b: bool = False, turbo: bool = True, eigvals: None = None, type: int = 1, check_finite: bool = True) jax.Array
jax.scipy.linalg.eigh(a: Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex], b: Optional[Union[jax.Array, numpy.ndarray, numpy.bool_, numpy.number, bool, int, float, complex]] = None, lower: bool = True, eigvals_only: bool = False, overwrite_a: bool = False, overwrite_b: bool = False, turbo: bool = True, eigvals: None = None, type: int = 1, check_finite: bool = True) Union[jax.Array, Tuple[jax.Array, jax.Array]]

Solve a standard or generalized eigenvalue problem for a complex

LAX-backend implementation of scipy.linalg._decomp.eigh().

Does not support the Scipy argument check_finite=True, because compiled JAX code cannot perform checks of array values at runtime.

Does not support the Scipy argument overwrite_*=True.

Original docstring below.

Hermitian or real symmetric matrix.

Find eigenvalues array w and optionally eigenvectors array v of array 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 ((M, M) array_like) – A complex Hermitian or real symmetric matrix whose eigenvalues and eigenvectors will be computed.

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

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

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

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

  • eigvals (tuple (lo, hi), optional) – Deprecated since v1.5.0, use ``subset_by_index`` keyword instead. 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.

  • overwrite_a (bool) –

  • overwrite_b (bool) –

  • turbo (bool) –

  • check_finite (bool) –

Return type

Union[Array, Tuple[Array, Array]]

Returns

  • w ((N,) ndarray) – The N (1<=N<=M) selected eigenvalues, in ascending order, each repeated according to its multiplicity.

  • v ((M, N) ndarray) – (if eigvals_only == False)