bundles / scipy 1.18.0 / scipy / linalg / _decomp / eig

function

`scipy.linalg._decomp:eig`

source: /scipy/linalg/_decomp.py:67

Signature

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

Summary

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

Extended Summary

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 tutorial_linalg_overwrite for details.

overwrite_b : bool, optional

Whether to overwrite b; may improve performance. Default is False. See tutorial_linalg_overwrite 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, $λ = α / β$ , can over- or underflow; typically, :mth:`\alpha` and $β$ 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.

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 linalg_batch 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
vr     # normalized right eigenvectors

✗

array([[0.71+0.j  , 0.71-0.j  ],
       [0.  -0.71j, 0.  +0.71j]])

Verify that columns of ``vr`` are indeed eigenvectors:

a @ vr[:, 0] - w[0] * vr[:, 0]
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
vr * np.sqrt(2)   # ``vr`` is normalized right eigenvectors

✗

array([[1.+0.j, 1.+0.j],
       [0.-1.j, 0.+1.j]])

Aliases

scipy.linalg.eig

Referenced by

This package

release:1.18.0-notes

Other packages

numpyreference:routines.linalg