# eig

Eigenvalues and eigenvectors

## Syntax

• `e = eig(A)` example
• ```[V,D] = eig(A)``` example
• ```[V,D,W] = eig(A)``` example
• `e = eig(A,B)` example
• ```[V,D] = eig(A,B)``` example
• ```[V,D,W] = eig(A,B)```
• `[___] = eig(A,balanceOption)` example
• `[___] = eig(A,B,algorithm)` example
• `[___] = eig(___,eigvalOption)` example

## Description

example

````e = eig(A)` returns a column vector containing the eigenvalues of square matrix `A`.```

example

``````[V,D] = eig(A)``` returns diagonal matrix `D` of eigenvalues and matrix `V` whose columns are the corresponding right eigenvectors, so that `A*V = V*D`.```

example

``````[V,D,W] = eig(A)``` also returns full matrix `W` whose columns 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 is a column vector of length `n`, and λ is a scalar. The values of λ that satisfy the equation are the eigenvalues. The corresponding values of v that satisfy the equation are the right eigenvectors. The left eigenvectors, w, satisfy the equation w'A = λw'.```

example

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

example

``````[V,D] = eig(A,B)``` returns diagonal matrix `D` of generalized eigenvalues and full matrix `V` whose columns are the corresponding right eigenvectors, so that `A*V = B*V*D`.```
``````[V,D,W] = eig(A,B)``` also returns full matrix `W` whose columns are the corresponding left eigenvectors, so that `W'*A = D*W'*B`.The generalized eigenvalue problem is to determine the solution to the equation Av = λBv, where A and B are `n`-by-`n` matrices, v is a column vector of length `n`, and λ is a scalar. The values of λ that satisfy the equation are the generalized eigenvalues. The corresponding values of v are the generalized right eigenvectors. The left eigenvectors, w, satisfy the equation w'A = λw'B.```

example

````[___] = 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 generally `'qz'`, which uses the QZ algorithm.If `A` is Hermitian and `B` is Hermitian positive definite, then the default for `algorithm` is `'chol'`.```

example

````[___] = eig(___,eigvalOption)` returns the eigenvalues in the form specified by `eigvalOption` using any of the input or output arguments in previous syntaxes. Specify `eigvalOption` 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

Use `gallery` to create a symmetric positive definite matrix.

`A = gallery('lehmer',4)`
```A = 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 = 0.2078 0.4078 0.8482 2.5362 ```

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

```D = eig(A,'matrix') ```
```D = 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

Use `gallery` to create a circulant matrix.

`A = gallery('circul',3)`
```A = 1 2 3 3 1 2 2 3 1 ```

Calculate the eigenvalues and right eigenvectors of `A`.

`[V,D] = eig(A)`
```V = -0.5774 + 0.0000i 0.2887 - 0.5000i 0.2887 + 0.5000i -0.5774 + 0.0000i -0.5774 + 0.0000i -0.5774 + 0.0000i -0.5774 + 0.0000i 0.2887 + 0.5000i 0.2887 - 0.5000i D = 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 = 1.0e-14 * -0.2665 + 0.0000i -0.0444 + 0.0222i -0.0444 - 0.0222i 0.0888 + 0.0000i 0.0111 + 0.0777i 0.0111 - 0.0777i -0.0444 + 0.0000i -0.0111 + 0.0833i -0.0111 - 0.0833i```

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

### Eigenvalues of a Matrix Whose Elements Differ Dramatically in Scale

```A = [ 3.0 -2.0 -0.9 2*eps; -2.0 4.0 1.0 -eps; -eps/4 eps/2 -1.0 0; -0.5 -0.5 0.1 1.0];```

Calculate the eigenvalues and right eigenvectors using the default (balancing) behavior.

`[VB,DB] = eig(A)`
```VB = 0.6153 -0.4176 -0.0000 -0.1437 -0.7881 -0.3261 -0.0000 0.1264 -0.0000 -0.0000 -0.0000 -0.9196 0.0189 0.8481 1.0000 0.3432 DB = 5.5616 0 0 0 0 1.4384 0 0 0 0 1.0000 0 0 0 0 -1.0000```

Verify that the results satisfy `A*VB = VB*DB`.

`A*VB - VB*DB`
```ans = 0.0000 0.0000 -0.0000 0.0000 0 -0.0000 0.0000 -0.0000 0.0000 -0.0000 0.0000 0.0000 0 0.0000 0.0000 0.6031```

This result does not satisfy `A*VB = VB*DB`. Ideally, the eigenvalue decomposition satisfies this 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`.

Now, try calculating the eigenvalues and right eigenvectors without the balancing step.

`[VN,DN] = eig(A,'nobalance')`
```VN = 0.6153 -0.4176 -0.0000 -0.1528 -0.7881 -0.3261 0 0.1345 -0.0000 -0.0000 -0.0000 -0.9781 0.0189 0.8481 -1.0000 0.0443 DN = 5.5616 0 0 0 0 1.4384 0 0 0 0 1.0000 0 0 0 0 -1.0000```

Verify that the results satisfy `A*VN = VN*DN`.

`A*VN - VN*DN`
```ans = 1.0e-14 * -0.1776 -0.0111 -0.0559 -0.0167 0.3553 0.1055 0.0336 -0.0194 0.0017 0.0002 0.0007 0 0.0264 -0.0222 0.0222 0.0097```

`A*VN - VN*DN` is much closer to `0`, so the `'nobalance'` option produces more accurate results in this case.

### Left Eigenvectors

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 = -0.2610 -0.9734 0.1891 -0.5870 0.2281 -0.5816 -0.7663 -0.0198 0.7912 D = 25.5548 0 0 0 -0.5789 0 0 0 -7.9759 W = -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 = 1.0e-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

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 = 1.0000 -1.0000 1.0000 0 0.0000 -0.0000 0 0 0.0000 D = 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 = 1.0e-15 * 0 0.8882 -0.8882 0 0 0.0000 0 0 0```

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

### Generalized Eigenvalues

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 = 1.0000 + 0.0000i 1.0000 + 0.0000i 0.0000 - 0.7071i 0.0000 + 0.7071i D = 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 = 0 0 0 0```

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

### Generalized Eigenvalues Using QZ Algorithm for Badly Conditioned Matrices

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

```format long e A = diag([10^-16, 10^-15])```
```A = 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 = 1.000000000000000e+08 0 0 3.162277660168380e+07 D1 = 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 = 1 0 0 1 D2 = 1 0 0 1 ```

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

```format short A*V1 - A*V1*D1```
```ans = 1.0e-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 = 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

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

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

Try to calculate the generalized eigenvalues of the matrix, B-1A.

```[V,D] = eig(B\A) ```
```Warning: Matrix is singular to working precision. Error using eig Input to EIG must not contain NaN or Inf.```

Now calculate the generalized eigenvalues and right eigenvectors by passing both matrices to the `eig` function.

```[V,D] = eig(A,B) ```
```V = -0.7500 -1.0000 -1.0000 0.5000 D = 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)` returned a set of eigenvectors and at least one real eigenvalue, even though `B` is not invertible.

Verify Av = λBv for the first eigenvalue and the first eigenvector.

```eigval = D(1,1); eigvec = V(:,1); A*eigvec - eigval*B*eigvec```
```ans = 1.0e-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 matrixsquare matrix

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

Data Types: `double` | `single`
Complex Number Support: Yes

### `B` — Generalized eigenvalue problem input matrixsquare matrix

Generalized eigenvalue problem input matrix, specified as a square matrix of real or complex values. `B` must be the same size as `A`.

Data Types: `double` | `single`
Complex Number Support: Yes

### `balanceOption` — Balance option`'balance'` (default) | `'nobalance'`

Balance option, specified as one of two strings: `'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`.

Data Types: `char`

### `algorithm` — Generalized eigenvalue algorithm`'chol'` | `'qz'`

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

algorithmDescription
`'chol'`Computes the generalized eigenvalues of `A` and `B` using the Cholesky factorization of `B`.
`'qz'`Uses the QZ algorithm, also known as the generalized Schur decomposition. This algorithm ignores the symmetry of `A` and `B`.

In general, the two algorithms return the same result. The QZ algorithm can be more stable for certain problems, such as those involving badly conditioned matrices.

When you omit the `algorithm` argument, the `eig` function selects an algorithm based on the properties of `A` and `B`. It uses the `'chol'` algorithm for symmetric (Hermitian) `A` and symmetric (Hermitian) positive definite `B`. Otherwise, it uses the `'qz'` algorithm.

Regardless of the algorithm you specify, the `eig` function always uses the QZ algorithm when `A` or `B` are not symmetric.

### `eigvalOption` — Eigenvalue option`'vector'` | `'matrix'`

Eigenvalue option, 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.

Data Types: `char`

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

• When `A` is real and symmetric or complex Hermitian, the values of `e` that satisfy Av = λv are real.

• When `A` is real and skew-symmetric or skew-Hermitian, the values of `e` that satisfy Av = λv are purely imaginary or zero.

### `V` — Right eigenvectorssquare matrix

Right eigenvectors, returned as a square matrix whose columns are the right eigenvectors of `A` or generalized right eigenvectors of the pair, `(A,B)`. The form and normalization of `V` depends on the combination of input arguments:

• `[V,D] = eig(A)` returns matrix `V`, whose columns are the right eigenvectors of `A` such that `A*V = V*D`. The eigenvectors in `V` are normalized so that the 2-norm of each is 1.

If `A` is real symmetric, 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)``` returns `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.

If `A` is symmetric and `B` is symmetric positive definite, then the eigenvectors in `V` are normalized so that the `B`-norm of each is 1.

### `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.

• When `A` is real and symmetric or complex Hermitian, the values of `D` that satisfy Av = λv are real.

• When `A` is real and skew-symmetric or skew-Hermitian, the values of `D` that satisfy Av = λv are purely imaginary or zero.

### `W` — Left eigenvectorssquare matrix

Left eigenvectors, returned as a square matrix whose columns are the left eigenvectors of `A` or generalized left eigenvectors of the pair, `(A,B)`. The form and normalization of `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 matrix whose columns are the generalized left eigenvectors that satisfy ```W'*A = D*W'*B```. 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.

If `A` and `B` are symmetric, then `W` is the same as `V`.

collapse all

### Tips

• The `eig` function can calculate the eigenvalues of sparse matrices that are real and symmetric. To calculate the eigenvectors of a sparse matrix, or to calculate the eigenvalues of a sparse matrix that is not real and symmetric, use the `eigs` function.