Kapitel 11 Jacobi–Verfahren

Kapitel 11
Jacobi–Verfahren
Im vorigen Kapitel haben wir gesehen, wie man für eine reell-symmetrische Matrix einige
wenige Eigenwerte (z.B. größten oder kleinsten) bestimmt. In den folgenden Kapiteln
wird diskutiert werden, wie man sämtliche Eigenwerte und Eigenvektoren einer Matrix
A berechnen kann.
Im Prinzip basieren solche Diagonalisierungsverfahren auf einer Reihe von orthogonalen
Ähnlichkeitstransformationen. Wir versuchen durch Transformationen der Form
A −→ P T AP (11.1)
die Matrix A auf Diagonalform zu bringen. Haben wir dies (innerhalb der gewünschten
Rechengenauigkeiten) erzielt, so enthält die Diagonale der transformierten Matrix A die
Eigenwerte. Die Eigenvektoren sind durch das Matrixprodukt der Transformationsmatrizen
P gegeben.
Die verschiedenen Diagonalisierungsverfahren unterscheiden sich durch die Wahl der P ’s.
In diesem Kapitel stellen wir das sogenannte Jacobi-Verfahren vor, dass die Matrix A
durch eine Reihe von Jacobi-Rotationen auf Diagonalform bringt. Es ist das einfachste
Verfahren zur vollständigen Diagonalisierung einer Matrix, und ist darüber hinaus
überaus stabil und einfach anzuwenden. Allerdings ist es deutlich langsamer als das im
nächsten Kapitel besprochene QL-Verfahren. In tatsächlichen Anwendungen sollte man
das Jacobi-Verfahren nur für relativ kleine Matrizen der Ordnung n ∼ 10 verwenden,
während man für größere Matrizen dem QL-Verfahren den Vorzug geben sollte.
11.1 Jacobi-Rotation
Betrachten wir die Rotationsmatrix
97

98 KAPITEL 11. JACOBI–VERFAHREN
⎛
P pq =
⎜
⎝
1 0
...
c s
...
−s c
...
0 1
⎞
, (11.2)
⎟
⎠
die aus einer Diagonalmatrix hervorgeht, wenn man die Elemente in der p-ten und q-ten
Spalte durch c ersetzt, sowie die Matrixelemente an der Position (pq) durch s und an der
Position (qp) durch −s. Hier haben wir die Abkürzung c = cos φ und s = sin φ eingeführt.
Offensichtlich ist die Matrix P pq eine verallgemeinerte Drehmatrix in n Dimensionen.
Hier ist die Strategie des Jacobiverfahrens zur Diagonalisierung der Matrix A. Wir beginnen
damit, das erste Nichtdiagonalelement a 01 auf Null zu setzen. Hierzu führen wir
die Transformation
P T 01AP 01 (11.3)
durch und wählen den Winkel φ so, dass a 01 = 0 wird (siehe Diskussion unten). Für eine
symmetrische Matrix wird dann entsprechend auch a 10 auf Null gesetzt.
Als nächstes bringen wir das Matrixelement a 02 durch eine entsprechende Ähnlichkeitstransformation
P 02 mit einem geeigneten Winkel φ auf Null. Allerdings kann diese Transformation
dazu führen, dass das zuvor auf Null gebrachte Element a 01 wieder einen von
Null verschiedenen Wert erhält. Wie jedoch weiter unten gezeigt werden wird, wird die
Summe der Absolutbeträge der Nichtdiagonalterme durch jede Transformation verringert.
Wenn wir also die Ähnlichkeitstransformationen (11.2) genügend lange durchführen,
werden die Nichtdiagonalterme innerhalb der numerischen Genauigkeit vernachlässigbar
klein und wir haben die Matrix auf die gewünschte Diagonalform gebracht.
11.2 Transformierte Matrix
Betrachten wir die Transformation
A ′ = P T pqAP pq . (11.4)
Man überzeugt sich leicht, dass diese Transformation nur die p-te und q-te Zeile bzw. p-te
und q-te Spalte der Matrix A verändert. Wenn wir diese Matrixmultiplikationen explizit
ausführen, erhalten wir für die transformierten Matrixelemente

11.2. TRANSFORMIERTE MATRIX 99
a ′ pq = (c 2 − s 2 ) a pq + sc (a pp − a qq )
a ′ pp = c 2 a pp + s 2 a qq − 2sc a pq
a ′ qq = s 2 a pp + c 2 a qq + 2sc a pq
a ′ rp = c a rp − s a rq
a ′ rq = c a rq + s a rp , (11.5)
wobei r ∈ [0, n − 1] eine Zahl ungleich p und q ist. Wir wollen c und s so bestimmen,
dass a ′ pq = 0 wird. Es folgt dann, dass
c 2 − s 2
sc
= a qq − a pp
a pq
= 2θ. (11.6)
Hier ist der Winkel θ durch die letzte Gleichung bestimmt. Unter Benutzung von t =
tan φ = s/c erhalten wir
1
t − t = 2θ, t2 + 2θt − 1 = 0. (11.7)
Wir wählen den Wert, der einer Drehung um den kleineren Winkel entspricht. Umformung
der Gleichung sowie Benutzung trigonometrischer Beziehungen liefert für t, c und s das
Ergebnis
t =
c =
sgn(θ)
|θ| 2 + √ 1 + θ 2
1
√
1 + t
2
s = tc, (11.8)
sowie
a ′ pq = 0
a ′ pp = a pp − t a pq
a ′ qq = a qq + t a pq
a ′ rp = c a rp − s a rq
a ′ rq = c a rq + s a rp (11.9)

100 KAPITEL 11. JACOBI–VERFAHREN
für die veränderten Matrixelemente.
Um zu verstehen, dass das Jacobi-Verfahren tatsächlich konvergiert, führen wir die Größe
S = ∑ r≠s
|a rs | 2 (11.10)
als Maß für den Betrag der Nichtdiagonalelement ein. Aus Glg. (11.9) erkennen wir, dass
durch die Transformation mit P pq der Betrag von S auf
S ′ = S − 2|a pq | 2 (11.11)
vermindert wird. Da die Transformation orthogonal ist, muss die Summe der Betragsquadrate
der Diagonalterme um 2|a pq | 2 erhöht werden.
11.3 Sweeps
Im Jacobi-Verfahren gehen wir nun so vor, dass wir sukzessive für die Matrixelemente
der oberen (oder unteren) Dreieckshälfte der Matrix die Nichtdiagonalelemente auf Null
setzen (ein solcher Durchlauf wird auch als sweep bezeichnet; engl. Ausdruck für Durchlauf).
Offensichtlich werden durch Hintereinanderschalten solcher Ähnlichkeitstransformationen
Matrixelemente, die zuvor bereits Null waren, wieder auf einen Wert ungleich
Null gesetzt. Die sweeps müssen daher solange wiederholt werden, bis S genügend klein
wird.
11.4 Eigenvektoren
Das soeben besprochene Verfahren bringt somit die Matrix A durch eine Ähnlichkeitstransformation
der Form
V T AV = D (11.12)
auf Diagonalform, wobei die Matrix V durch das Matrixprodukt der hintereinandergeschalteten
Jacobirotationen P i gegeben ist,
Eine Jacobirotation P pq ändert die Matrix V bezüglich
V = P 1 P 2 P 3 . . . . (11.13)

11.4. EIGENVEKTOREN 101
Jacobi-Verfahren für eine reell-symmetrische n × n-Matrix A
1. Initialisiere V = II und ɛ (z.B. ɛ = 10 −8 )
2. Sweeps
(a) Schleife p = 0, . . . n − 1 über Zeilen
(b) Schleife q = p + 1, . . . n − 1 über Spalten
i. Bestimme t, c und s entsprechend Glg. (11.8)
ii. Bestimme die neuen Matrixelemente a ′ pq, a ′ rq und a ′ rp
entsprechend Glg. (11.9)
iii. Bestimme die neuen Matrixelemente v ′ rq und v ′ rp
entsprechend Glg. (11.15)
3. Falls ∑ i |a′ ii| 2 < ɛ ∑ i≠j |a′ ij| 2 zurück zu 2.
Box 11.1. Algorithmus des Jacobi-Verfahrens zur Bestimmung der Eigenwerte und Eigenvektoren
einer Matrix A. Nach Abbruch des Algorithmus enthält die Diagonale der
veränderten Matrix A die angenäherten Eigenwerte und die Spalten von V die zugehörigen
Eigenvektoren.
V ′ = V P pq , (11.14)
wobei zu Beginn V = II gilt. Man rechnet leicht nach, dass sich bei dieser Transformation
die Matrixelemente bezüglich
v ′ rs = v rs (s ≠ p, s ≠ q)
v rp ′ = c v rp − s v rq
v rq ′ = s v rp + c v rq (11.15)
ändern. Nach Abbruch des Jacobi-Verfahrens enthalten die Spalten von V die angenäherten
Eigenvektoren der Matrix A.
In Box 11.1 ist das vollständige Jacobi-Verfahren dargestellt.

102 KAPITEL 11. JACOBI–VERFAHREN
11.5 Implementierung
Eine Vorlage zur Implementierung des Jacobi-Verfahrens ist in den Dateien
http://physik.uni-graz.at/~uxh/lineare-algebra/Jacobi.h
http://physik.uni-graz.at/~uxh/lineare-algebra/Jacobi.cc
gegeben. In Jacobi.h wird der namespace Jacobi definiert,
1 namespace Jacobi {
2
3 extern double epsilon;
4 extern double ∗e;
5 extern matrix v;
6
7 void eigenvalue(const matrix& m, bool vec=false);
8 };
der in einem aufrufenden Programm über
1 #include ”Jacobi.h”
2
3 using namespace Jacobi;
eingelesen werden kann. epsilon ist der Genauigkeitsparameter, der den Abbruch des
Jacobiverfahrens steuert (siehe Box 11.1). Nach Aufruf von
1 matrix a(”matrix.dat”);
2
3 eigenvalue(a);
enthält das Array e die angenäherten Eigenwerte. Will man auch die zugehörigen Eigenvektoren
bestimmen, sollte man die Funktion eigenvalue über
1 eigenvalue(a,true);
aufrufen, wobei die Eigenvektoren spaltenweise in v gespeichert werden.
11.5.1 Abbruchkriterium
Das Abbruchkriterium für das Jacobi-Verfahren ist in Jacobi.cc in der Funktion
1 bool isDiagonal(const matrix& a)
2 {
3 double sumDiag=0;
4 double sumOffDiag=0;

11.5. IMPLEMENTIERUNG 103
5
6 for (int i=0; i

104 KAPITEL 11. JACOBI–VERFAHREN
auch ihre gespiegelten Partner unterhalb der Diagonale denselben Wert erhalten. Offensichtlich
führt dies zu einer unnötigen Komplikation. In Jacobi.cc lösen wir dieses Problem
mit Hilfe der Definition
1 #define a(i , j ) a(min(i,j ),max(i,j))
Wenn wir später auf die Nichtdiagonalelemente von a über a(i , j) zugreifen, ist stets
gewährleistet, dass wir ausschließlich die Matrixelemente oberhalb der Diagonale verwenden.
Die Vorlage des Jacobi-Verfahrens hat dann die Form
1 void eigenvalue(const matrix& m, bool vec)
2 {
3 matrix a(m); // matrix a must be symmetric
4 int n=a.size(); // n x n matrix
5 int it ; // counter for iterations
6
7 double c,s,t,theta,dum;
8
10
9 if (vec) v=diagonal(n);
11 for ( it =0; !isDiagonal(a ); it++)
12 {
13 // sweep over upper half of matrix
14 for (int p=0; pzero)
20 {
21 #define a(i , j ) a(min(i,j ),max(i,j))
22
23 // update a(p,p), a(q,q ), and a(p,q)
24 // ...
25
26 for (int r=0; r

11.5. IMPLEMENTIERUNG 105
34 if (vec)
35 {
36 // update v(r,p) and v(r,q)
37 // ...
38 }
39 }
40
41 #undef a
42
43 } // end Jacobi rotation
44 } // end sweep
45 } // end iterations
46
47 sortEigenvalue(a,vec);
48 }
Aufgabe 11.1— Vervollständigen Sie die Funktion eigenvalue. Fügen Sie die
entsprechenden Befehle an den mit
1 // ...
gekennzeichneten Stellen ein. Benutzen Sie die Dateien
http://physik.uni-graz.at/~uxh/lineare-algebra/Jacobi.h
http://physik.uni-graz.at/~uxh/lineare-algebra/Jacobi.cc
Eine Testroutine ist in
http://physik.uni-graz.at/~uxh/lineare-algebra/test-Jacobi.cc
gegeben, bei der die Eigenwerte und Eigenvektoren der Matrix
bestimmt werden.
A =
⎛
⎜
⎝
17 3 2 13
3 11 11 8
2 11 8 12
13 8 12 2
⎞
⎟
⎠ , (11.16)