Eigenvalues and eigenvectors - MATLAB eig- MathWorks Deutschland (2024)

Eigenvalues and eigenvectors

collapse all in page

Syntax

e = eig(A)

[V,D] =eig(A)

[V,D,W]= eig(A)

e = eig(A,B)

[V,D] =eig(A,B)

[V,D,W]= eig(A,B)

[___] = eig(A,balanceOption)

[___] = eig(A,B,algorithm)

[___] = eig(___,outputForm)

Description

example

e = eig(A) returnsa column vector containing the eigenvalues of square matrix A.

example

[V,D] =eig(A) returns diagonal matrix D ofeigenvalues and matrix V whose columns are thecorresponding right eigenvectors, so that A*V = V*D.

example

[V,D,W]= eig(A) also returns full matrix W whosecolumns are the corresponding left eigenvectors, so that W'*A= D*W'.

The eigenvalue problem is to determine the solution to the equation Av = λv,where A is an n-by-n matrix, v isa column vector of length n, and λ isa scalar. The values of λ that satisfy theequation are the eigenvalues. The corresponding values of v thatsatisfy the equation are the right eigenvectors. The left eigenvectors, w,satisfy the equation w’A = λw’.

example

e = eig(A,B) returnsa column vector containing the generalized eigenvalues of square matrices A and B.

example

[V,D] =eig(A,B) returnsdiagonal matrix D of generalized eigenvalues andfull matrix V whose columns are the correspondingright eigenvectors, so that A*V = B*V*D.

[V,D,W]= eig(A,B) alsoreturns full matrix W whose columns are the correspondingleft eigenvectors, so that W'*A = D*W'*B.

The generalized eigenvalue problem is to determine the solutionto the equation Av = λBv,where A and B are n-by-n matrices, v isa column vector of length n, and λ isa scalar. The values of λ that satisfy theequation are the generalized eigenvalues. The corresponding valuesof v are the generalized right eigenvectors. Theleft eigenvectors, w, satisfy the equation w’A = λw’B.

[___] = eig(A,balanceOption), where balanceOption is "nobalance", disables the preliminary balancing step in the algorithm. The default for balanceOption is "balance", which enables balancing. The eig function can return any of the output arguments in previous syntaxes.

example

[___] = eig(A,B,algorithm), where algorithm is "chol", uses the Cholesky factorization of B to compute the generalized eigenvalues. The default for algorithm depends on the properties of A and B, but is "qz", which uses the QZ algorithm, when A or B are not symmetric.

example

[___] = eig(___,outputForm) returns the eigenvalues in the form specified by outputForm using any of the input or output arguments in previous syntaxes. Specify outputForm as "vector" to return the eigenvalues in a column vector or as "matrix" to return the eigenvalues in a diagonal matrix.

Examples

collapse all

Eigenvalues of Matrix

Open Live Script

Use gallery to create a symmetric positive definite matrix.

A = gallery("lehmer",4)

A = 4×4 1.0000 0.5000 0.3333 0.2500 0.5000 1.0000 0.6667 0.5000 0.3333 0.6667 1.0000 0.7500 0.2500 0.5000 0.7500 1.0000

Calculate the eigenvalues of A. The result is a column vector.

e = eig(A)

e = 4×1 0.2078 0.4078 0.8482 2.5362

Alternatively, use outputForm to return the eigenvalues in a diagonal matrix.

D = eig(A,"matrix")

D = 4×4 0.2078 0 0 0 0 0.4078 0 0 0 0 0.8482 0 0 0 0 2.5362

Eigenvalues and Eigenvectors of Matrix

Open Live Script

Use gallery to create a circulant matrix.

A = gallery("circul",3)

A = 3×3 1 2 3 3 1 2 2 3 1

Calculate the eigenvalues and right eigenvectors of A.

[V,D] = eig(A)

V = 3×3 complex -0.5774 + 0.0000i 0.5774 + 0.0000i 0.5774 + 0.0000i -0.5774 + 0.0000i -0.2887 - 0.5000i -0.2887 + 0.5000i -0.5774 + 0.0000i -0.2887 + 0.5000i -0.2887 - 0.5000i

D = 3×3 complex 6.0000 + 0.0000i 0.0000 + 0.0000i 0.0000 + 0.0000i 0.0000 + 0.0000i -1.5000 + 0.8660i 0.0000 + 0.0000i 0.0000 + 0.0000i 0.0000 + 0.0000i -1.5000 - 0.8660i

Verify that the results satisfy A*V = V*D.

A*V - V*D

ans = 3×3 complex10^-14 × -0.2665 + 0.0000i -0.0888 - 0.0111i -0.0888 + 0.0111i 0.0888 + 0.0000i 0.0000 + 0.0833i 0.0000 - 0.0833i -0.0444 + 0.0000i -0.1157 + 0.0666i -0.1157 - 0.0666i

Ideally, the eigenvalue decomposition satisfies the relationship. Since eig performs the decomposition using floating-point computations, then A*V can, at best, approach V*D. In other words, A*V - V*D is close to, but not exactly, 0.

Sorted Eigenvalues and Eigenvectors

Open Live Script

By default eig does not always return the eigenvalues and eigenvectors in sorted order. Use the sort function to put the eigenvalues in ascending order and reorder the corresponding eigenvectors.

Calculate the eigenvalues and eigenvectors of a 5-by-5 magic square matrix.

A = magic(5)

Left Eigenvectors

Open Live Script

Create a 3-by-3 matrix.

 A = [1 7 3; 2 9 12; 5 22 7];

Calculate the right eigenvectors, V, the eigenvalues, D, and the left eigenvectors, W.

[V,D,W] = eig(A)

V = 3×3 -0.2610 -0.9734 0.1891 -0.5870 0.2281 -0.5816 -0.7663 -0.0198 0.7912

D = 3×3 25.5548 0 0 0 -0.5789 0 0 0 -7.9759

W = 3×3 -0.1791 -0.9587 -0.1881 -0.8127 0.0649 -0.7477 -0.5545 0.2768 0.6368

Verify that the results satisfy W'*A = D*W'.

W'*A - D*W'

ans = 3×310^-13 × -0.0444 -0.1066 -0.0888 -0.0011 0.0442 0.0333 0 0.0266 0.0178

Ideally, the eigenvalue decomposition satisfies the relationship. Since eig performs the decomposition using floating-point computations, then W'*A can, at best, approach D*W'. In other words, W'*A - D*W' is close to, but not exactly, 0.

Eigenvalues of Nondiagonalizable (Defective) Matrix

Open Live Script

Create a 3-by-3 matrix.

A = [3 1 0; 0 3 1; 0 0 3];

Calculate the eigenvalues and right eigenvectors of A.

[V,D] = eig(A)

V = 3×3 1.0000 -1.0000 1.0000 0 0.0000 -0.0000 0 0 0.0000

D = 3×3 3 0 0 0 3 0 0 0 3

A has repeated eigenvalues and the eigenvectors are not independent. This means that A is not diagonalizable and is, therefore, defective.

Verify that V and D satisfy the equation, A*V = V*D, even though A is defective.

A*V - V*D

ans = 3×310^-15 × 0 0.8882 -0.8882 0 0 0.0000 0 0 0

Generalized Eigenvalues

Open Live Script

Create two matrices, A and B, then solve the generalized eigenvalue problem for the eigenvalues and right eigenvectors of the pair (A,B).

A = [1/sqrt(2) 0; 0 1];B = [0 1; -1/sqrt(2) 0];[V,D]=eig(A,B)

V = 2×2 complex 1.0000 + 0.0000i 1.0000 + 0.0000i 0.0000 - 0.7071i 0.0000 + 0.7071i

D = 2×2 complex 0.0000 + 1.0000i 0.0000 + 0.0000i 0.0000 + 0.0000i 0.0000 - 1.0000i

Verify that the results satisfy A*V = B*V*D.

A*V - B*V*D

ans = 2×2 0 0 0 0

The residual error A*V - B*V*D is exactly zero.

Generalized Eigenvalues Using QZ Algorithm for Badly Conditioned Matrices

Open Live Script

Create a badly conditioned symmetric matrix containing values close to machine precision.

format long eA = diag([10^-16, 10^-15])

A = 2×2 1.000000000000000e-16 0 0 1.000000000000000e-15

Calculate the generalized eigenvalues and a set of right eigenvectors using the default algorithm. In this case, the default algorithm is "chol".

[V1,D1] = eig(A,A)

V1 = 2×2 1.000000000000000e+08 0 0 3.162277660168380e+07

D1 = 2×2 9.999999999999999e-01 0 0 1.000000000000000e+00

Now, calculate the generalized eigenvalues and a set of right eigenvectors using the "qz" algorithm.

[V2,D2] = eig(A,A,"qz")

V2 = 2×2 1 0 0 1

D2 = 2×2 1 0 0 1

Check how well the "chol" result satisfies A*V1 = A*V1*D1.

format shortA*V1 - A*V1*D1

ans = 2×210^-23 × 0.1654 0 0 -0.6617

Now, check how well the "qz" result satisfies A*V2 = A*V2*D2.

A*V2 - A*V2*D2

ans = 2×2 0 0 0 0

When both matrices are symmetric, eig uses the "chol" algorithm by default. In this case, the QZ algorithm returns more accurate results.

Generalized Eigenvalues Where One Matrix Is Singular

Open Live Script

Create a 2-by-2 identity matrix, A, and a singular matrix, B.

A = eye(2);B = [3 6; 4 8];

If you attempt to calculate the generalized eigenvalues of the matrix $B^{- 1} A$ with the command [V,D] = eig(B\A), then MATLAB® returns an error because B\A produces Inf values.

Instead, calculate the generalized eigenvalues and right eigenvectors by passing both matrices to the eig function.

[V,D] = eig(A,B)

V = 2×2 -0.7500 -1.0000 -1.0000 0.5000

D = 2×2 0.0909 0 0 Inf

It is better to pass both matrices separately, and let eig choose the best algorithm to solve the problem. In this case, eig(A,B) returns a set of eigenvectors and at least one real eigenvalue, even though B is not invertible.

Verify $A v = λ B v$ for the first eigenvalue and the first eigenvector.

eigval = D(1,1);eigvec = V(:,1);A*eigvec - eigval*B*eigvec

ans = 2×110^-15 × 0.1110 0.2220

Ideally, the eigenvalue decomposition satisfies the relationship. Since the decomposition is performed using floating-point computations, then A*eigvec can, at best, approach eigval*B*eigvec, as it does in this case.

Input Arguments

collapse all

`A` — Input matrix
square matrix

Input matrix, specified as a real or complex square matrix.

Data Types: double | single
Complex Number Support: Yes

`B` — Generalized eigenvalue problem input matrix
square matrix

Generalized eigenvalue problem input matrix, specified as asquare matrix of real or complex values. B mustbe the same size as A.

Data Types: double | single
Complex Number Support: Yes

`balanceOption` — Balance option
`"balance"` (default) | `"nobalance"`

Balance option, specified as: "balance", which enables a preliminary balancing step, or "nobalance" which disables it. In most cases, the balancing step improves the conditioning of A to produce more accurate results. However, there are cases in which balancing produces incorrect results. Specify "nobalance" when A contains values whose scale differs dramatically. For example, if A contains nonzero integers, as well as very small (near zero) values, then the balancing step might scale the small values to make them as significant as the integers and produce inaccurate results.

"balance" is the default behavior. For more information about balancing, see balance.

`algorithm` — Generalized eigenvalue algorithm
`"chol"` (default) | `"qz"`

Generalized eigenvalue algorithm, specified as "chol" or "qz", which selects the algorithm to use for calculating the generalized eigenvalues of a pair.

algorithm	Description
`"chol"`	Computes the generalized eigenvalues of `A` and `B` using the Cholesky factorization of `B`. If `A` is not symmetric (Hermitian) or if `B` is not symmetric (Hermitian) positive definite, `eig` uses the QZ algorithm instead.
`"qz"`	Uses the QZ algorithm, also known as the generalized Schurdecomposition. This algorithm ignores the symmetry of `A` and `B`.

In general, the two algorithms return the same result. The QZalgorithm can be more stable for certain problems, such as those involvingbadly conditioned matrices.

Regardless of the algorithm you specify, the eig functionalways uses the QZ algorithm when A or B arenot symmetric.

`outputForm` — Output format of eigenvalues
`"vector"` | `"matrix"`

Output format of eigenvalues, specified as "vector" or "matrix". This option allows you to specify whether the eigenvalues are returned in a column vector or a diagonal matrix. The default behavior varies according to the number of outputs specified:

If you specify one output, such as e = eig(A), then the eigenvalues are returned as a column vector by default.
If you specify two or three outputs, such as [V,D] = eig(A), then the eigenvalues are returned as a diagonal matrix, D, by default.

Example: D = eig(A,"matrix") returns a diagonal matrix of eigenvalues with the one output syntax.

Output Arguments

collapse all

`e` — Eigenvalues (returned as vector)
column vector

Eigenvalues, returned as a column vector containing the eigenvalues (or generalized eigenvalues of a pair) with multiplicity. Each eigenvalue e(k) corresponds with the right eigenvector V(:,k) and the left eigenvector W(:,k).

When A is real symmetric or complex Hermitian, the values of e that satisfy Av = λv are real.
When A is real skew-symmetric or complex skew-Hermitian, the values of e that satisfy Av = λv are imaginary.

`V` — Right eigenvectors
square matrix

Right eigenvectors, returned as a square matrix whose columnsare the right eigenvectors of A or generalizedright eigenvectors of the pair, (A,B). The formand normalization of V depends on the combinationof input arguments:

[V,D] = eig(A) returns matrix V,whose columns are the right eigenvectors of A suchthat A*V = V*D. The eigenvectors in V arenormalized so that the 2-norm of each is 1.
If A is real symmetric, Hermitian, or skew-Hermitian, then the right eigenvectors V are orthonormal.
[V,D] = eig(A,"nobalance") also returns matrix V. However, the 2-norm of each eigenvector is not necessarily 1.
[V,D] = eig(A,B) and [V,D] = eig(A,B,algorithm) return V as a matrix whose columns are the generalized right eigenvectors that satisfy A*V = B*V*D. The 2-norm of each eigenvector is not necessarily 1. In this case, D contains the generalized eigenvalues of the pair, (A,B), along the main diagonal.
When eig uses the "chol" algorithm with symmetric (Hermitian) A and symmetric (Hermitian) positive definite B, it normalizes the eigenvectors in V so that the B-norm of each is 1.

Different machines and releases of MATLAB^® can produce different eigenvectors that are still numerically accurate:

For real eigenvectors, the sign of the eigenvectors can change.
For complex eigenvectors, the eigenvectors can be multiplied by any complex number of magnitude 1.
For a multiple eigenvalue, its eigenvectors can be recombined through linear combinations. For example, if Ax = λx and Ay = λy, then A(x+y) = λ(x+y), so x+y also is an eigenvector of A.

`D` — Eigenvalues (returned as matrix)
diagonal matrix

Eigenvalues, returned as a diagonal matrix with the eigenvalues of A on the main diagonal or the eigenvalues of the pair, (A,B), with multiplicity, on the main diagonal. Each eigenvalue D(k,k) corresponds with the right eigenvector V(:,k) and the left eigenvector W(:,k).

When A is real symmetric or complex Hermitian, the values of D that satisfy Av = λv are real.
When A is real skew-symmetric or complex skew-Hermitian, the values of D that satisfy Av = λv are imaginary.

`W` — Left eigenvectors
square matrix

Left eigenvectors, returned as a square matrix whose columnsare the left eigenvectors of A or generalized lefteigenvectors of the pair, (A,B). The form and normalizationof W depends on the combination of input arguments:

[V,D,W] = eig(A) returns matrix W, whose columns are the left eigenvectors of A such that W'*A = D*W'. The eigenvectors in W are normalized so that the 2-norm of each is 1. If A is symmetric, then W is the same as V.
[V,D,W] = eig(A,"nobalance") also returns matrix W. However, the 2-norm of each eigenvector is not necessarily 1.
[V,D,W] = eig(A,B) and [V,D,W]= eig(A,B,algorithm) returns W as a matrixwhose columns are the generalized left eigenvectors that satisfy W'*A= D*W'*B. The 2-norm of each eigenvector is not necessarily1. In this case, D contains the generalized eigenvaluesof the pair, (A,B), along the main diagonal.
If A and B are symmetric, then W is the same as V.

Different machines and releases of MATLAB can produce different eigenvectors that are still numerically accurate:

For real eigenvectors, the sign of the eigenvectors can change.
For complex eigenvectors, the eigenvectors can be multiplied by any complex number of magnitude 1.
For a multiple eigenvalue, its eigenvectors can be recombined through linear combinations. For example, if Ax = λx and Ay = λy, then A(x+y) = λ(x+y), so x+y also is an eigenvector of A.

More About

collapse all

Symmetric Matrix

A square matrix, A, is symmetric if it is equal to its nonconjugate transpose, A = A.'.
In terms of the matrix elements, this means that
$a_{i, j} = a_{j, i} .$
Since real matrices are unaffected by complex conjugation, a real matrix that is symmetric is also Hermitian. For example, the matrix
$A = [\begin{matrix} \begin{matrix} \begin{matrix} 1 \\ 0 \end{matrix} & \begin{matrix} 0 \\ 2 \end{matrix} \end{matrix} & \begin{matrix} 1 \\ 0 \end{matrix} \\ \begin{matrix} 1 & 0 \end{matrix} & 1 \end{matrix}]$
is both symmetric and Hermitian.

Skew-Symmetric Matrix

A square matrix, A, is skew-symmetric if it is equal to the negation of its nonconjugate transpose, A = -A.'.
In terms of the matrix elements, this means that
$a_{i, j} = - a_{j, i} .$
Since real matrices are unaffected by complex conjugation, a real matrix that is skew-symmetric is also skew-Hermitian. For example, the matrix
$A = [\begin{matrix} 0 & - 1 \\ 1 & 0 \end{matrix}]$
is both skew-symmetric and skew-Hermitian.

Hermitian Matrix

A square matrix, A, is Hermitian if it is equal to its complex conjugate transpose, A = A'.
In terms of the matrix elements,
$a_{i, j} = {\bar{a}}_{j, i} .$
The entries on the diagonal of a Hermitian matrix are always real. Because real matrices are unaffected by complex conjugation, a real matrix that is symmetric is also Hermitian. For example, this matrix is both symmetric and Hermitian.
$A = [\begin{matrix} \begin{matrix} 1 \\ 0 \end{matrix} & \begin{matrix} \begin{matrix} 0 \\ 2 \end{matrix} & \begin{matrix} 1 \\ 0 \end{matrix} \end{matrix} \\ 1 & \begin{matrix} 0 & 1 \end{matrix} \end{matrix}]$
The eigenvalues of a Hermitian matrix are real.

Skew-Hermitian Matrix

A square matrix, A, is skew-Hermitian if it is equal to the negation of its complex conjugate transpose, A = -A'.
In terms of the matrix elements, this means that
$a_{i, j} = - {\bar{a}}_{j, i} .$
The entries on the diagonal of a skew-Hermitian matrix are always pure imaginary or zero. Since real matrices are unaffected by complex conjugation, a real matrix that is skew-symmetric is also skew-Hermitian. For example, the matrix
$A = [\begin{matrix} 0 & - 1 \\ 1 & 0 \end{matrix}]$
is both skew-Hermitian and skew-symmetric.
The eigenvalues of a skew-Hermitian matrix are purely imaginary or zero.

Tips

The eig function can calculatethe eigenvalues of sparse matrices that are real and symmetric. Tocalculate the eigenvectors of a sparse matrix, or to calculate theeigenvalues of a sparse matrix that is not real and symmetric, usethe eigs function.

Extended Capabilities

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

V might represent a different basis of eigenvectors. This representation means that the eigenvector calculated by the generated code might be different in C and C++ code than in MATLAB. The eigenvalues in D might not be in the same order as in MATLAB. You can verify the V and D values by using the eigenvalue problem equation A*V = V*D.
If you specify the LAPACK library callback class, then the code generator supports these options:
- The computation of left eigenvectors.
Outputs are complex.
Code generation does not support sparse matrix inputs for this function.

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool`.

This function fully supports thread-based environments. For more information, see Run MATLAB Functions in Thread-Based Environment.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

The eig function partially supports GPU arrays. Some syntaxes of the function run on a GPU when you specify the input data as a gpuArray (Parallel Computing Toolbox). Usage notes and limitations:

For the generalized case, eig(A,B), A and B must be real symmetric or complex Hermitian. Additionally, B must be positive definite.
The QZ algorithm, eig(A,B,"qz"), is not supported.

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Distributed Arrays
Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

Usage notes and limitations:

For the generalized case, eig(A,B), A and B must be real symmetric or complex Hermitian. Additionally, B must be positive definite.
These syntaxes are not supported for full distributed arrays:
[__] = eig(A,B,"qz")
[V,D,W] = eig(A,B)

For more information, see Run MATLAB Functions with Distributed Arrays (Parallel Computing Toolbox).

Version History

Introduced before R2006a

expand all

R2021b: `eig` returns `NaN` for nonfinite inputs

eig returns NaN values when the input contains nonfinite values (Inf or NaN). Previously, eig threw an error when the input contained nonfinite values.

R2021a: Improved algorithm for skew-Hermitian matrices

The algorithm for input matrices that are skew-Hermitian was improved. With the function call [V,D] = eig(A), where A is skew-Hermitian, eig now guarantees that the matrix of eigenvectors V is unitary and the diagonal matrix of eigenvalues D is purely imaginary.

MATLAB-Befehl

Sie haben auf einen Link geklickt, der diesem MATLAB-Befehl entspricht:

Führen Sie den Befehl durch Eingabe in das MATLAB-Befehlsfenster aus. Webbrowser unterstützen keine MATLAB-Befehle.

Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

Americas

América Latina (Español)
Canada (English)
United States (English)

Europe

Belgium (English)
Denmark (English)
Deutschland (Deutsch)
España (Español)
Finland (English)
France (Français)
Ireland (English)
Italia (Italiano)
Luxembourg (English)

Netherlands (English)
Norway (English)
Österreich (Deutsch)
Portugal (English)
Sweden (English)
Switzerland
- Deutsch
- English
- Français
United Kingdom (English)

Asia Pacific

Australia (English)
India (English)
New Zealand (English)
中国
- 简体中文
- English
日本 (日本語)
한국 (한국어)

Contact your local office

Eigenvalues and eigenvectors - MATLAB eig - MathWorks Deutschland (2024)

Syntax

Description

Examples

Eigenvalues of Matrix

Eigenvalues and Eigenvectors of Matrix

Sorted Eigenvalues and Eigenvectors

Left Eigenvectors

Eigenvalues of Nondiagonalizable (Defective) Matrix

Generalized Eigenvalues

Generalized Eigenvalues Using QZ Algorithm for Badly Conditioned Matrices

Generalized Eigenvalues Where One Matrix Is Singular

Input Arguments

A — Input matrix square matrix

B — Generalized eigenvalue problem input matrix square matrix

balanceOption — Balance option "balance" (default) | "nobalance"

algorithm — Generalized eigenvalue algorithm "chol" (default) | "qz"

outputForm — Output format of eigenvalues "vector" | "matrix"

Output Arguments

e — Eigenvalues (returned as vector) column vector

V — Right eigenvectors square matrix

D — Eigenvalues (returned as matrix) diagonal matrix

W — Left eigenvectors square matrix

More About

Symmetric Matrix

Skew-Symmetric Matrix

Hermitian Matrix

Skew-Hermitian Matrix

Tips

Extended Capabilities

C/C++ Code Generation Generate C and C++ code using MATLAB® Coder™.

Thread-Based Environment Run code in the background using MATLAB® backgroundPool or accelerate code with Parallel Computing Toolbox™ ThreadPool.

GPU Arrays Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Distributed Arrays Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

Version History

R2021b: eig returns NaN for nonfinite inputs

R2021a: Improved algorithm for skew-Hermitian matrices

See Also

Topics

MATLAB-Befehl

Americas

Europe

Asia Pacific

`A` — Input matrix
square matrix

`B` — Generalized eigenvalue problem input matrix
square matrix

`balanceOption` — Balance option
`"balance"` (default) | `"nobalance"`

`algorithm` — Generalized eigenvalue algorithm
`"chol"` (default) | `"qz"`

`outputForm` — Output format of eigenvalues
`"vector"` | `"matrix"`

`e` — Eigenvalues (returned as vector)
column vector

`V` — Right eigenvectors
square matrix

`D` — Eigenvalues (returned as matrix)
diagonal matrix

`W` — Left eigenvectors
square matrix

C/C++ Code Generation
Generate C and C++ code using MATLAB® Coder™.

Thread-Based Environment
Run code in the background using MATLAB® `backgroundPool` or accelerate code with Parallel Computing Toolbox™ `ThreadPool`.

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Distributed Arrays
Partition large arrays across the combined memory of your cluster using Parallel Computing Toolbox™.

R2021b: `eig` returns `NaN` for nonfinite inputs