scipy.linalg.

eigvals#

scipy.linalg.eigvals(a, b=None, overwrite_a=False, check_finite=True, homogeneous_eigvals=False)[source]#

Compute eigenvalues from an ordinary or generalized eigenvalue problem.

Find eigenvalues, w, of a general matrix:

a @ vr[:, i] = w[i] * b  @ vr[:, i]

Parameters:

a(…, M, M) array_like

A complex or real matrix (or a stack of matrices), whose eigenvalues will be computed.

b(…, M, M) array_like, optional

Right-hand side matrix (or a stack of matrices) in a generalized eigenvalue problem. If omitted (default), identity matrix is assumed.

overwrite_abool, optional

Whether to overwrite data in a (may improve performance)

check_finitebool, 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.

homogeneous_eigvalsbool, optional

If True, return the eigenvalues in homogeneous coordinates. In this case w is a (2, M) array so that:

w[1, i] * a @ vr[:, i] = w[0, i] * b @ vr[:, i]

This option is sometimes useful for generalized eigenvalue problems, b is not None, where an eigenvalue, \(\lambda = \alpha / \beta\), can over- or underflow; typically, :math:alpha and \(\beta\) are of the order of norm(a) and norm(b), respectively.

Default is False.

Returns:

w(…, M,) or (…, 2, M) complex ndarray: The eigenvalues, each repeated according to its multiplicity but not in any specific order. The shape is (..., M) unless homogeneous_eigvals=True.

Raises:

LinAlgError: If eigenvalue computation does not converge

See also

eig: eigenvalues and right eigenvectors of general arrays.
eigvalsh: eigenvalues of symmetric or Hermitian arrays
eigvals_banded: eigenvalues for symmetric/Hermitian band matrices
eigvalsh_tridiagonal: eigenvalues of symmetric/Hermitian tridiagonal matrices

Examples

>>> import numpy as np
>>> from scipy import linalg
>>> a = np.array([[0., -1.],
...               [1.,  0.]])

Compute the eigenvalues (eigvals is the same as eig(a, right=False))

>>> linalg.eigvals(a)
array([0.+1.j, 0.-1.j])

Solve a generalized eigenvalue problem:

>>> b = np.array([[0., 1.], [1., 1.]])
>>> linalg.eigvals(a, b)
array([ 1.+0.j, -1.+0.j])

Inputs with ndim > 2 are interpreted as a batch of matrices

>>> a2 = np.stack((a, 2*a))
>>> linalg.eigvals(a2)
array([[0.+1.j, 0.-1.j],
       [0.+2.j, 0.-2.j]])

homogeneous_eigvals=True argument effectively separates each eigenvalue into a numerator-denominator pair:

>>> a = np.array([[3., 0., 0.],
...               [0., 8., 0.],
...               [0., 0., 7.]])
>>> b = 2*np.eye(3)
>>> linalg.eigvals(a, b, homogeneous_eigvals=True)
array([[3.+0.j, 8.+0.j, 7.+0.j],
       [2.+0.j, 2.+0.j, 2.+0.j]])