In numerical linear algebra, the Jacobi eigenvalue algorithm is an iterative method for the calculation of the eigenvalues and eigenvectors of a real symmetric matrix (a process known as diagonalization). It is named after Carl Gustav Jacob Jacobi, who first proposed the method in 1846, but only became widely used in the 1950s with the advent of computers.

Description

Let S be a symmetric matrix, and be a Givens rotation matrix. Then: is symmetric and similar to S. Furthermore, S^\prime has entries: where and. Since G is orthogonal, S and S^\prime have the same Frobenius norm ||\cdot||_F (the square-root sum of squares of all components), however we can choose \theta such that, in which case S^\prime has a larger sum of squares on the diagonal: Set this equal to 0, and rearrange: if In order to optimize this effect, Sij should be the off-diagonal element with the largest absolute value, called the pivot. The Jacobi eigenvalue method repeatedly performs rotations until the matrix becomes almost diagonal. Then the elements in the diagonal are approximations of the (real) eigenvalues of S.

Convergence

If p = S_{kl} is a pivot element, then by definition for. Let \Gamma(S)^2 denote the sum of squares of all off-diagonal entries of S. Since S has exactly off-diagonal elements, we have or. Now. This implies or ; that is, the sequence of Jacobi rotations converges at least linearly by a factor to a diagonal matrix. A number of N Jacobi rotations is called a sweep; let S^{\sigma} denote the result. The previous estimate yields that is, the sequence of sweeps converges at least linearly with a factor ≈ e ^{1 / 2}. However the following result of Schönhage yields locally quadratic convergence. To this end let S have m distinct eigenvalues with multiplicities and let d > 0 be the smallest distance of two different eigenvalues. Let us call a number of Jacobi rotations a Schönhage-sweep. If S^ s denotes the result then Thus convergence becomes quadratic as soon as

Cost

Each Givens rotation can be done in O(n) steps when the pivot element p is known. However the search for p requires inspection of all N ≈ 1⁄2 n2 off-diagonal elements. We can reduce this to O(n) complexity too if we introduce an additional index array with the property that m_i is the index of the largest element in row i, (i = 1, ..., n − 1) of the current S. Then the indices of the pivot (k, l) must be one of the pairs (i, m_i). Also the updating of the index array can be done in O(n) average-case complexity: First, the maximum entry in the updated rows k and l can be found in O(n) steps. In the other rows i, only the entries in columns k and l change. Looping over these rows, if m_i is neither k nor l, it suffices to compare the old maximum at m_i to the new entries and update m_i if necessary. If m_i should be equal to k or l and the corresponding entry decreased during the update, the maximum over row i has to be found from scratch in O(n) complexity. However, this will happen on average only once per rotation. Thus, each rotation has O(n) and one sweep O(n3) average-case complexity, which is equivalent to one matrix multiplication. Additionally the m_i must be initialized before the process starts, which can be done in n2 steps. Typically the Jacobi method converges within numerical precision after a small number of sweeps. Note that multiple eigenvalues reduce the number of iterations since N_S < N.

Algorithm

The following algorithm is a description of the Jacobi method in math-like notation. It calculates a vector e which contains the eigenvalues and a matrix E which contains the corresponding eigenvectors; that is, e_i is an eigenvalue and the column E_i an orthonormal eigenvector for e_i, i = 1, ..., n. procedure jacobi(S ∈ Rn×n; out e ∈ Rn; out E ∈ Rn×n) var i, k, l, m, state ∈ N s, c, t, p, y, d, r ∈ R ind ∈ Nn changed ∈ Ln function maxind(k ∈ N) ∈ N ! index of largest off-diagonal element in row k m := k+1 for i := k+2 to n do if │Ski│ > │Skm│ then m := i endif endfor return m endfunc procedure update(k ∈ N; t ∈ R) ! update ek and its status y := ek; ek := y+t if changedk and (y=ek) then changedk := false; state := state−1 elsif (not changedk) and (y≠ek) then changedk := true; state := state+1 endif endproc procedure rotate(k,l,i,j ∈ N) ! perform rotation of Sij, Skl ┌ undefined┐ ┌ ┐┌ undefined┐ │Skl│ │c −s││Skl│ │ undefined│ := │ ││ undefined│ │Sij│ │s c││Sij│ └ undefined┘ └ ┘└ undefined┘ endproc ! init e, E, and arrays ind, changed E := I; state := n for k := 1 to n do indk := maxind(k); ek := Skk; changedk := true endfor while state≠0 do ! next rotation m := 1 ! find index (k,l) of pivot p for k := 2 to n−1 do if │Sk ind k │ > │Sm ind m │ then m := k endif endfor k := m; l := indm; p := Skl ! calculate c = cos φ, s = sin φ y := (el−ek)/2; d := │y│+√(p2+y2) r := √(p2+d2); c := d/r; s := p/r; t := p2/d if y<0 then s := −s; t := −t endif Skl := 0.0; update(k,−t); update(l,t) ! rotate rows and columns k and l for i := 1 to k−1 do rotate(i,k,i,l'') endfor for i := k+1 to l−1 do rotate(k,i,i,l) endfor for i := l+1 to n do rotate(k,i,l,i) endfor ! rotate eigenvectors for i := 1 to n do ┌ undefined┐ ┌ ┐┌ undefined┐ │Eik│ │c −s││Eik│ │ undefined│ := │ ││ undefined│ │Eil│ │s c││Eil│ └ undefined┘ └ ┘└ undefined┘ endfor ! update all potentially changed indi for i := 1 to n do indi := maxind(i) endfor loop endproc

Example

Let Then jacobi produces the following eigenvalues and eigenvectors after 3 sweeps (19 iterations) :

Applications for real symmetric matrices

When the eigenvalues (and eigenvectors) of a symmetric matrix are known, the following values are easily calculated.

Julia implementation

The following code is a straight-forward implementation of the mathematical description of the Jacobi eigenvalue algorithm in the Julia programming language.

Generalizations

The Jacobi Method has been generalized to complex Hermitian matrices, general nonsymmetric real and complex matrices as well as block matrices. Since singular values of a real matrix are the square roots of the eigenvalues of the symmetric matrix S = A^T A it can also be used for the calculation of these values. For this case, the method is modified in such a way that S must not be explicitly calculated which reduces the danger of round-off errors. Note that with. The Jacobi Method is also well suited for parallelism.