egttools.analytical.sed_analytical.eig

eig(a, b=None, left=False, right=True, overwrite_a=False, overwrite_b=False, check_finite=True, homogeneous_eigvals=False)[source]

Solve an ordinary or generalized eigenvalue problem of a square matrix.

Find eigenvalues w and right or left eigenvectors of a general matrix:

a   @ vr[:, i] = w[i]        * b   @ vr[:, i]
a.H @ vl[:, i] = w[i].conj() * b.H @ vl[:, i]

where .H is the Hermitian conjugation.

Parameters:
  • a ((..., M, M) array_like) – A complex or real matrix whose eigenvalues and eigenvectors will be computed.

  • b ((..., M, M) array_like, optional) – Right-hand side matrix in a generalized eigenvalue problem. Default is None, identity matrix is assumed.

  • left (bool, optional) – Whether to calculate and return left eigenvectors. Default is False.

  • right (bool, optional) – Whether to calculate and return right eigenvectors. Default is True.

  • overwrite_a (bool, optional) – Whether to overwrite a; may improve performance. Default is False. See overwrite_* arguments for details.

  • overwrite_b (bool, optional) – Whether to overwrite b; may improve performance. Default is False. See overwrite_* arguments for details.

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

  • homogeneous_eigvals (bool, 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. The shape is (..., M) unless homogeneous_eigvals=True.

  • vl ((…, M, M) double or complex ndarray) – The left eigenvector corresponding to the eigenvalue w[i] is the column vl[:, i]. Only returned if left=True. The left eigenvector is not normalized.

  • vr ((…, M, M) double or complex ndarray) – The normalized right eigenvector corresponding to the eigenvalue w[i] is the column vr[:, i]. Only returned if right=True (default).

Raises:

LinAlgError – If eigenvalue computation does not converge.

See also

eigvals

eigenvalues of general arrays

eigh

Eigenvalues and right eigenvectors for symmetric/Hermitian arrays.

eig_banded

eigenvalues and right eigenvectors for symmetric/Hermitian band matrices

eigh_tridiagonal

eigenvalues and right eigenvectors for symmetric/Hermitian tridiagonal matrices

Notes

Array arguments of this function, a and b, may have additional “batch” dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see Batched Linear Operations for details.

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]])

Eigenvectors: by default, eig returns normalized right eigenvectors in columns of the second return array

>>> a = np.array([[0., -1.],
...               [1., 0.]])
>>> w, vr = linalg.eig(a)
>>> w      # eigenvalues
array([0. + 1.j, 0. - 1.j])
>>> vr     # normalized right eigenvectors
array([[0.70710678 + 0.j        , 0.70710678 - 0.j        ],
       [0.         - 0.70710678j, 0.         + 0.70710678j]])

Verify that columns of vr are indeed eigenvectors:

>>> a @ vr[:, 0] - w[0] * vr[:, 0]
array([0.+0.j, 0.+0.j])
>>> a @ vr[:, 1] - w[1] * vr[:, 1]
array([0.+0.j, 0.+0.j])

To compute the normalized left eigenvectors, use left=True:

>>> w, vl, vr = linalg.eig(a, left=True, right=True)
>>> vl * np.sqrt(2)   # ``vl`` is normalized left eigenvectors
array([[-1. + 0.j, -1. - 0.j],
       [ 0. + 1.j,  0. - 1.j]])
>>> vr * np.sqrt(2)   # ``vr`` is normalized right eigenvectors
array([[1. + 0.j, 1. + 0.j],
       [0. - 1.j, 0. + 1.j]])