# eig

## Purpose

Eigenvalues and eigenvectors.

## Synopsis

    d = eig(A)
    [V,D] = eig(A)
    [V,D] = eig(A,'nobalance')
    d = eig(A,B)
    [V,D] = eig(A,B)

## Description

The eigenvalue problem is to determine the nontrivial solutions of the equation:

where `A` is an `n`-by-`n` matrix, `x` is a length `n` column vector, and s is a scalar. The `n` values of s that satisfy the equation are the eigenvalues and the corresponding values of `x` are the right eigenvectors. In MATLAB, the function `eig` solves for the eigenvalues s and optionally the eigenvectors `x`.

`d = eig(A)` returns a vector `d` containing the eigenvalues of matrix `A`.

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

The eigenvectors are scaled so that the norm of each is 1.0.

The left eigenvectors can be computed with the two statements:

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

The eigenvectors in `D` computed from `A` and `A'` are the same, although they can occur in different orders. The left eigenvectors satisfy `W`*`A` `=` `D`*`W`.

`[V,D] = eig(A,'nobalance')` finds eigenvalues and eigenvectors without a preliminary balancing step. Ordinarily, balancing improves the conditioning of the input matrix, enabling more accurate computation of the eigenvectors and eigenvalues. However, if a matrix contains small elements that are really due to roundoff error, balancing may scale them up to make them as significant as the other elements of the original matrix, leading to incorrect eigenvectors. Use the `nobalance` option in this event. See `balance` for more details.

When a matrix has no repeated eigenvalues, the eigenvectors are always independent and the eigenvector matrix `V` diagonalizes the original matrix `A` if applied as a similarity transformation. However, if a matrix has repeated eigenvalues, it is not similar to a diagonal matrix unless it has a full (independent) set of eigenvectors. If the eigenvectors are not independent then the original matrix is said to be defective. Even if a matrix is defective, the solution from `eig` satisfies `A*X = X*D`.

The generalized eigenvalue problem is to determine the nontrivial solutions of the equation

where both `A` and `B` are `n`-by-`n` matrices and s is a scalar. The values of s that satisfy the equation are the generalized eigenvalues and the corresponding values of `x` are the generalized right eigenvectors.

If `B` is nonsingular, the problem could be solved by reducing it to a standard eigenvalue problem

Because `B` can be singular, an alternative algorithm, called the QZ method, is necessary.

In MATLAB, the function `eig` solves for the generalized eigenvalues and eigenvectors when used with two input arguments:

`d = eig(A,B)`, if `A` and `B` are square matrices, returns a vector containing the generalized eigenvalues.

`[V,D] = eig(A,B)` produces a diagonal matrix `D` of generalized eigenvalues and a full matrix `V` whose columns are the corresponding eigenvectors so that `A*V = B*V*D`.

The eigenvectors are scaled so that the norm of each is 1.0.

## Examples

The matrix

    B = [    3       -2      -.9    2*eps
            -2        4       -1     -eps
        -eps/4    eps/2       -1        0
           -.5      -.5       .1        1];

has elements on the order of roundoff error. It is an example for which the `nobalance` option is necessary to compute the eigenvectors correctly. Try the statements

    [VB,DB] = eig(B)
    B*VB - VB*DB
    [VN,DN] = eig(B, 'nobalance')
    B*VN - VN*DN

## Algorithm

For real matrices, `eig(X)` uses the EISPACK routines `BALANC`, `BALBAK`, `ORTHES`,`ORTRAN`, and `HQR2`. `BALANC` and `BALBAK` balance the input matrix. `ORTHES` converts a real general matrix to Hessenberg form using orthogonal similarity transformations. `ORTRAN` accumulates the transformations used by `ORTHES`. `HQR2` finds the eigenvalues and eigenvectors of a real upper Hessenberg matrix by the QR method. The EISPACK subroutine `HQR2` is modified to make computation of eigenvectors optional.

When `eig` is used with two arguments, the EISPACK routines `QZHES`, `QZIT`, `QZVAL`, and `QZVEC` solve for the generalized eigenvalues via the QZ algorithm. Modifications handle the complex case.

When `eig` is used with one complex argument, the solution is computed using the QZ algorithm as `eig(X,eye(X))`. Modifications to the QZ routines handle the special case B = I.

For detailed descriptions of these algorithms, see the EISPACK Guide.

## Diagnostics

If the limit of 30`n` iterations is exhausted while seeking an eigenvalue:

    Solution will not converge.

## See Also

    balance, hess, qz, schur

## References

[1] B. T. Smith, J. M. Boyle, J. J. Dongarra, B. S. Garbow, Y. Ikebe, V. C. Klema, and C. B. Moler, Matrix Eigensystem Routines - EISPACK Guide, Lecture Notes in Computer Science, volume 6, second edition, Springer-Verlag, 1976.

[2] B. S. Garbow, J. M. Boyle, J. J. Dongarra, and C. B. Moler, Matrix Eigensystem Routines - EISPACK Guide Extension, Lecture Notes in Computer Science, volume 51, Springer-Verlag, 1977.

[3] C. B. Moler and G.W. Stewart, An Algorithm for Generalized Matrix Eigenvalue Problems, SIAM J. Numer. Anal., Vol. 10, No. 2, April 1973.

(c) Copyright 1994 by The MathWorks, Inc.