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, [1] but only became widely used in the 1950s with the advent of computers. [2]
This algorithm is inherently a dense matrix algorithm: it draws little or no advantage from being applied to a sparse matrix, and it will destroy sparseness by creating fill-in. Similarly, it will not preserve structures such as being banded of the matrix on which it operates.
Let be a symmetric matrix, and be a Givens rotation matrix. Then:
is symmetric and similar to .
Furthermore, has entries:
where and .
Since is orthogonal, and have the same Frobenius norm (the square-root sum of squares of all components), however we can choose such that , in which case 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.
If is a pivot element, then by definition for . Let denote the sum of squares of all off-diagonal entries of . Since 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 Jacobi rotations is called a sweep; let denote the result. The previous estimate yields
that is, the sequence of sweeps converges at least linearly with a factor ≈ .
However the following result of Schönhage [3] 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 denotes the result then
Thus convergence becomes quadratic as soon as
Each Givens rotation can be done in steps when the pivot element p is known. However the search for p requires inspection of all N ≈ 1/2 n2 off-diagonal elements, which means this search dominates the overall complexity and pushes the computational complexity of a sweep in the classical Jacobi algorithm to . Competing algorithms attain complexity for a full diagonalisation.
We can reduce the complexity of finding the pivot element from O(N) to O(n) if we introduce an additional index array with the property that 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 . 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 is neither k nor l, it suffices to compare the old maximum at to the new entries and update if necessary. If 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 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 .
An alternative approach is to forego the search entirely, and simply have each sweep pivot every off-diagonal element once, in some predetermined order. It has been shown that this cyclic Jacobi attains quadratic convergence, [4] [5] just like the classical Jacobi.
The opportunity for parallelisation that is particular to Jacobi is based on combining cyclic Jacobi with the observation that Givens rotations for disjoint sets of indices commute, so that several can be applied in parallel. Concretely, if pivots between indices and pivots between indices , then from follows because in computing or the rotation only needs to access rows and the rotation only needs to access rows . Two processors can perform both rotations in parallel, because no matrix element is accessed for both.
Partitioning the set of index pairs of a sweep into classes that are pairwise disjoint is equivalent to partitioning the edge set of a complete graph into matchings, which is the same thing as edge colouring it; each colour class then becomes a round within the sweep. The minimal number of rounds is the chromatic index of the complete graph, and equals for odd but for even . A simple rule for odd is to handle the pairs and in the same round if . For even one may create rounds where a pair for goes into round and additionally a pair for goes into round . This brings the time complexity of a sweep down from to , if processors are available.
A round would consist of each processor first calculating for its rotation, and then applying the rotation from the left (rotating between rows). Next, the processors synchronise before applying the transpose rotation from the right (rotating between columns), and finally synchronising again. A matrix element may be accessed by two processors during a round, but not by both during the same half of this round.
Further parallelisation is possible by dividing the work for a single rotation between several processors, but that might be getting too fine-grained to be practical.
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, is an eigenvalue and the column an orthonormal eigenvector for , i = 1, ..., n.
procedure jacobi(S ∈ Rn×n; oute ∈ Rn; outE ∈ Rn×n) vari, k, l, m, state ∈ Ns, c, t, p, y, d, r ∈ Rind ∈ Nnchanged ∈ Lnfunction maxind(k ∈ N) ∈ N ! index of largest off-diagonal element in row km := k+1 fori := k+2 tondoif │Ski│ > │Skm│ thenm := iendifendforreturnmendfuncprocedure update(k ∈ N; t ∈ R) ! update ek and its statusy := ek; ek := y+tifchangedk and (y=ek) thenchangedk := false; state := state−1 elsif (not changedk) and (y≠ek) thenchangedk := true; state := state+1 endifendprocprocedure rotate(k,l,i,j ∈ N) ! perform rotation of Sij, Skl ┌ ┐ ┌ ┐┌ ┐ │Skl│ │c −s││Skl│ │ │ := │ ││ │ │Sij│ │sc││Sij│ └ ┘ └ ┘└ ┘ endproc ! init e, E, and arrays ind, changedE := I; state := nfork := 1 tondoindk := maxind(k); ek := Skk; changedk := true endforwhilestate≠0 do ! next rotationm := 1 ! find index (k,l) of pivot pfork := 2 ton−1 doif │Sk indk│ > │Sm indm│ thenm := kendifendfork := 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/dify<0 thens := −s; t := −tendifSkl := 0.0; update(k,−t); update(l,t) ! rotate rows and columns k and lfori := 1 tok−1 do rotate(i,k,i,l) endforfori := k+1 tol−1 do rotate(k,i,i,l) endforfori := l+1 tondo rotate(k,i,l,i) endfor ! rotate eigenvectorsfori := 1 tondo ┌ ┐ ┌ ┐┌ ┐ │Eik│ │c −s││Eik│ │ │ := │ ││ │ │Eil│ │sc││Eil│ └ ┘ └ ┘└ ┘ endfor ! update all potentially changed indifori := 1 tondoindi := maxind(i) endforloopendproc
1. The logical array changed holds the status of each eigenvalue. If the numerical value of or changes during an iteration, the corresponding component of changed is set to true, otherwise to false. The integer state counts the number of components of changed which have the value true. Iteration stops as soon as state = 0. This means that none of the approximations has recently changed its value and thus it is not very likely that this will happen if iteration continues. Here it is assumed that floating point operations are optimally rounded to the nearest floating point number.
2. The upper triangle of the matrix S is destroyed while the lower triangle and the diagonal are unchanged. Thus it is possible to restore S if necessary according to
fork := 1 ton−1 do ! restore matrix Sforl := k+1 tondoSkl := Slkendforendfor
3. The eigenvalues are not necessarily in descending order. This can be achieved by a simple sorting algorithm.
fork := 1 ton−1 dom := kforl := k+1 tondoifel > emthenm := lendifendforifk ≠ mthen swap em,ek swap Em,Ekendifendfor
4. The algorithm is written using matrix notation (1 based arrays instead of 0 based).
5. When implementing the algorithm, the part specified using matrix notation must be performed simultaneously.
6. This implementation does not correctly account for the case in which one dimension is an independent subspace. For example, if given a diagonal matrix, the above implementation will never terminate, as none of the eigenvalues will change. Hence, in real implementations, extra logic must be added to account for this case.
Let
Then jacobi produces the following eigenvalues and eigenvectors after 3 sweeps (19 iterations) :
When the eigenvalues (and eigenvectors) of a symmetric matrix are known, the following values are easily calculated.
The following code is a straight-forward implementation of the mathematical description of the Jacobi eigenvalue algorithm in the Julia programming language.
usingLinearAlgebra,Testfunctionfind_pivot(Sprime)n=size(Sprime,1)pivot_i=pivot_j=0pivot=0.0forj=1:nfori=1:(j-1)ifabs(Sprime[i,j])>pivotpivot_i=ipivot_j=jpivot=abs(Sprime[i,j])endendendreturn(pivot_i,pivot_j,pivot)end# in practice one should not instantiate explicitly the Givens rotation matrixfunctiongivens_rotation_matrix(n,i,j,θ)G=Matrix{Float64}(I,(n,n))G[i,i]=G[j,j]=cos(θ)G[i,j]=sin(θ)G[j,i]=-sin(θ)returnGend# S is a symmetric n by n matrixn=4sqrtS=randn(n,n);S=sqrtS*sqrtS';# the largest allowed off-diagonal element of U' * S * U# where U are the eigenvectorstol=1e-14Sprime=copy(S)U=Matrix{Float64}(I,(n,n))whiletrue(pivot_i,pivot_j,pivot)=find_pivot(Sprime)ifpivot<tolbreakendθ=atan(2*Sprime[pivot_i,pivot_j]/(Sprime[pivot_j,pivot_j]-Sprime[pivot_i,pivot_i]))/2G=givens_rotation_matrix(n,pivot_i,pivot_j,θ)# update Sprime and USprime.=G'*Sprime*GU.=U*Gend# Sprime is now (almost) a diagonal matrix# extract eigenvaluesλ=diag(Sprime)# sort eigenvalues (and corresponding eigenvectors U) by increasing valuesi=sortperm(λ)λ=λ[i]U=U[:,i]# S should be equal to U * diagm(λ) * U'@testS≈U*diagm(λ)*U'
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 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 .