Ziborius

Lösung linearer
Gleichungssysteme
Seminar “Parallele Programmierung“
Nico Ziborius
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
2
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
3
1. Einleitung
• linearer Gleichungssysteme Kern vieler numerischer
Anwendungen (z.B numerische Lösung partieller
Differentialgleichungen)
• Gesucht Lösung für Ax =b
– nichtsinguläre Matrix ARnn
– Vektor bRn und Lösungsvektor xRn
• Direkte-Verfahren
– exakte Lösung
– z.B. Gauß-Elimination, zyklische Reduktion
• Iterative-Verfahren
– Näherung an die Lösung
– z.B. Jacobi-Verfahren, Gauß-Seidel-Verfahren, Methode der
konjugierten Gradienten
4
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
5
2.1 Gauß-Elimination
Idee:
• Transformiere Ax=b in äquivalentes Gleichungssystem
A‘x = b‘, so dass A‘ eine obere Dreiecksmatrix bildet.
6
2.1 Gauß-Elimination
• Transformation benötigt n-1 Schritte
a a
a
• Schritt k , 1 k  n-1
•
A(k+1),
b(k+1)
aus A(k),


0


(k )

 




0

A
b
(k)
11
a
a
22

a
a
1, k 1
( 2)
12
( 2)
1k
( 2)
2, k 1
 
a
( k 1)
a
a
k 1, k 1
0


2k

( k 1)
k 1, k
(k )
kk

a
 0
(k )
nk




2n 


( k 1) 

k 1, n 
(k ) 


kn

 
(k ) 

nn 

a
a
1n
( 2)
a
a
a
berechnen:
– Eliminationsfaktoren berechnen:
l
ik

a
a
(k )
für k  i  n
ik
(k )
kk
– Elemente von A und b für k< j  n und k <i  n neu berechnen:
a
( k 1)
ij

(k )
a
ij

l
ik
*
(k )
a
kj
( k 1)
b
i

(k )
b
i

(k )
l b
ik
*
k
7
2.1 Gauß-Elimination
• Lösung durch Rückwärtseinsetzen, für k = n,n-1,...,1:
x
k

1 
(n) 
kk 
a
( n)
b
k
n

a x
j  k 1
(n)
kj


j

• sequentielle Implementierung Θ(n3)
(drei ineinander verschachtelte Schleifen)
8
2.1 Gauß-Elimination
• Elemente auf der Diagonalen gleich Null
 Fehler, da Division durch Null
• sehr kleine Elemente auf der Diagonalen
 Rundungsfehler
• daher Elemente auf der Diagonalen durch ein andere,
sogenannte Pivotelemente, ersetzten:
– Spaltenpivotsuche:
– betragsgrößte ark(k) aus akk(k),..,ank(k) suchen
– vertauschen der Zeilen k und r , falls r  k.
9
2.1 Gauß-Elimination
parallelen Implementierung: (Hypercube)
• zeilenblockweise Aufteilung der Matrix A und des Vektor b
• mit p = Anzahl Prozessoren, wird Pi für 1  i  p, ein n/p großer
Zeilenblock zugewiesen
• Jeder Prozessor Pi hat
– ein 2-dimensionales Array a[n/p][n]
– Array b[n/p]
– Array marked[n/p]
– Array pivot[n/p],
(Koeffizienten Matrix A)
(Werten des Vektors b)
(markieren der Pivotzeile)
(wann war Zeile Pivotzeile)
10
2.1 Gauß-Elimination
• zunächst Array marked mit 0 initialisieren
• dann in n-1 Schritten die obere Dreiecksmatrix
berechnen:
1. lokales Pivotelement
bestimmen:
Pi ermittelt unter den
Elementen a[r][k], mit
r= 1...n/p und marked[r]=0
das lokale Maximum
b marked pivot
a
P1
P2
1
2
3
-4
-6
1
1
0
4
4
-1
14
0
-
0
-8 -2 10
3
0
-
0
-1 -5 11
7
0
11
2.1 Gauß-Elimination
2. globales Pivotelement bestimmen: Aus den lokalen Maxima wird
das globale Maximum, durch Auruf der Funktion
MAX_TOURNAMENT(int i, int value, int winner) ermittelt
int MAX_TOURNAMENT(int i, int value, int winner){
int j,k;
for(k=0; k<log p-1; k++){
j=i^(1<<k);
[j]tmp_value  value;
[j]tmp_winner  winner;
if(tmp_value>value){
value = tmp_value; winner = tmp_winner;
}
}
return winner;}
12
2.1 Gauß-Elimination
a
3. Pivotzeile Markieren &
Verteilen: wenn Pi Gewinner,
dann marked[r]=1, pivot[r]=k,
Elemente a[r][k]... a[r][n] und
b[r] in Hilfsvektor kopieren und
an alle andere Prozessoren
senden
4. Berechnung der
Eliminationsfaktoren:
Pi berechnet für seine lokalen
Zeilen i, mit i =1,...n/p, mit
marked[i]=0, die
Eliminationsfaktoren
P1
P2
P1
P2
b marked pivot
1
2
3 -4
-6
1
1
0
4
4 -1
14
0
-
0 -8 -2 10
3
10
2-
0 -1 -5 11
7
0
-
1
2
3
-4
-6
1
1
0
4
4
-1
14
0
-
0
-8 -2 10
3
10
2-
0
-1 -5 11
7
0
13
2.1 Gauß-Elimination
5. Neu Berechnung Matrixelemente:
Pi berechnet seine Elemente a[i][j], und b[i], i=1...n/p,
j=k+1...n, mit marked[i]=0, neu.
a
b marked pivot
P1
P2
1
2
3
-4
0
04
54
-1
4 15,5
14
0
-8 -2 10
0
9,75
-1
0 -4,75
-5 11
6,625
-6
1
1
0
-
3
10
2-
7
0
-
• jeder Prozessor sucht in seinem Array marked nach marked[j]=0 und
setzt pivot[j]=n
• Lösung des Gleichungssystems durch Rückwärtseinsetzten
14
2.1 Gauß-Elimination
Pivotzeile kopieren
Berechnungsaufwand:
 n n 1  n
 n 
n

  (n  i )  (n  i )   .
t1 (n, p )   
p
p
p
 p 
i 1 

 n3

t1 (n, p)  
 n2 
 p



pivot

Initialisierung marked
Pivotzeile ermitteln
Eliminationsfaktoren
& Elemente von A, b
neu berechnen
Kommunikationsaufwand:

t 2 ( n, p )  


n 1
 log
i 1

p  ( n  i ) log p   log p ,


n 1

  n( n  1)



t 2 ( n, p )   log p
1  ( n  i )   log p   
log p    n 2 log p

 
2

i 1





15
2.1 Gauß-Elimination
• Vorteile:
– Vorhersagbarkeit der Laufzeit, des Speicherbedarfs
– Berechnung einer exakten Lösung
• Nacheilt:
– bei dünnbesetzten Matrizen entsteht fill-in
16
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
17
2.2 zyklische Reduktion
• Eine Matrix A mit A= (aji) i,j=1,...,n Rnn heißt Bandmatrix
mit halber Bandbreite r, falls aij = 0 für |i-j| >r.
• Falls r = 1 , so heißt A Tridiagonalmatrix
b1
a
 2

A



0
c1
b2
a3






c n 1 

bn 
0
c2
b3



an
• Gauß-Elimination hier nicht Sinnvoll!
18
2.2 zyklische Reduktion
• Falls A symmetrisch und positiv definit Lösung mittels
– rekursiven Verdoppelns oder zyklischer Reduktion
• Ausgangspunkt beider Verfahren:
b1x1  c1x 2  y1
ai x i -1
 bi x i  ci x i 1  yi
a n x n -1  bn x n
für i  2, , n - 1
 yn
Idee:
• xi-1 und xi+1 aus der i-ten Gleichung, durch einsetzen von
geeigneten Vielfachen der Gleichungen i+1 und i-1, zu
eliminieren
19
2.2 zyklische Reduktion
(1)
A
b1(1)

0
a (1)
 3




0
0
b2(1)
0

c1(1)
0
b3





cn(1) 2 

0

bn 

0
c 2(1)


a n(1)
0
• Nach log n  Schritten, nur noch Elemente der
Hauptdiagonalen ungleich Null
 Lösung ist einfach abzulesen
• Pro Schritt werden O(n) Werte berechnet:
 O(nlog n) gegenüber O(n) für Gauß-Elimination
aber Berechnung der Werte innerhalb eines Schrittes parallel möglich
20
2.2 zyklische Reduktion
rekursives Verdoppeln :
• Diagonalmatrix in log n Schritten ermitteln
zyklische Reduktion :
• die Zahl der berechneten Werte in jedem
Schritt halbiert
• erfordert abschließende
Substitutionsphase
21
2.2 zyklische Reduktion
parallele Implementierung:
• Zeilen der Tridiagonalmatrix A blockweise auf p Prozessoren
aufgeteilen
• Zur Vereinfachung:
– n = pq mit q 
– q = 2Q mit Q  N
– Pi speichert Zeilenblock der Größe q,
mit den Zeilen (i-1)q+1,...,i*q, für 1  i  p
22
2.2 zyklische Reduktion
Q Stufen
log p
Stufen
Q Stufen
parallele Implementierung:
x1
1. zyklische Reduktion:
x2
bis nur noch eine Gleichung pro
Prozessor vorhanden
2. rekursives Verdoppeln:
x3
x4
das nur noch p-dimensionale
Gleichungssystem wird nun
mittels rekursiven Verdoppeln in
gelöst
3. Substitutionsphase:
x5
x6
x7
x8
Ermittlung der noch fehlenden
Werte des Lösungsvektors x
23
2.2 zyklische Reduktion
• Aufwand Phase 1:
Q
T1 (n, p)  4top 
2
k 1
4q
k
16
n
 top
p
C1 (n, p)  2Q  t s 2 s (4)  2  log
n
 t s 2 s (4)
p
• Aufwand Phase 2:
T2 (n, p)  4t op  4log p   t op  16 log p   t op  t op
C2 (n, p)  2log p  t s 2s (4)
• Aufwand Phase 3:
T3 (n, p)  5top 
Q 1
n 
2 k  5top  (2Q  1)  5top  (q  1)  5top    1
p 
k 0

C3 (n, p)  2  t s 2 s (1)
24
2.2 zyklische Reduktion
• Aufwand Insgesamt:
 n

n
T (n, p)  16  16  log p   5  4   top
p
 p

 n

  21  16  log p   t op
 p



n
C (n, p)   2  log  log p   2t s 2s (1)
p


 2  log n  t s 2s (4)  2  t s 2s (1)
25
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
26
3.1 klassische iterative Verfahren
• Berechnen Folge von Approximationsvektoren {x(k)}k=1,2,...,,
die gegen die gesuchte Lösung x*Rn konvergieren
• Zerlegung der Matrix A in A=M-N mit M,N Rnn
– M nichtsinguläre Matrix
– M-1 leicht zu berechnen, z.B. Diagonalmatrix
• x* erfüllt Gleichung: Mx* = Nx* +b.
Iterationsvorschrift: Mx(k+1) = Nx(k) + b
27
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
28
3.1.1 Jacobi-Verfahren
• Zerlegung von A in A=D-L-R mit (D,L,R Rnn),
– D Diagonalmatrix, L untere Dreiecksmatrix, R obere
Dreiecksmatrix (jeweils ohne Diagonale)
• Iterationsvorschrift: Dx(k+1) =(L+R)x(k) + b
• In Komponentenschreibweise:
xi( k 1)
1

aii

b 
 i

n

aij x (jk )
j 1, j  i

 , i  1,... , n


29
3.1.1 Jacobi-Verfahren
• Abbruchkriterium: relativer Fehler
x ( k 1)  x ( k )   x ( k 1)
||.|| Vektornorm, z.B. ||x|| = max i=1,...,n|xi| oder ||x||2=(n i=1|x|2)½ .
30
3.1.1 Jacobi-Verfahren
parallel Implementierung:
• Pi mit i=1,...,p speichert die Werte xi(n/p),..., x(i+1)(n/p)-1
inklusive dazugehörige Zeilen von A und der Werte von b
• jeder Pi führt nun alternierend folgende Aktionen aus, bis
Abbruchkriterium erfüllt:
1. Pi sendet seine lokal gehaltenen Elemente des Vektors x(k) an
alle anderen Prozessoren (All-to-All Broadcast)
2. Pi berechnet x(k+1) für seine Elemente xj(k+1) mit
j=i(n/p),...,(i+1)(n/p)-1
3. Test des Abbruchkriterium
31
3.1.1 Jacobi-Verfahren
• Aufwand :
– In Schritt 1. sendet Pi n/p Werte an p-1 Prozessoren
Kommunikationsaufwand Θ((p-1)  (n/p)).
– In Schritt 2. n/p Elemente des Vektors x(k+1) berechnen, mit
Rechenaufwand von Θ(n (n/p))
– Der Test auf Abbruch in 3. erfordert einen Aufwand von Θ (log p).
• Bewertung:
– Konvergenz nicht gesichert , niedrige Konvergenzrate
• es gezeigt, dass e(n2/2) Iterationen notwendig sind damit der
Fehler um 10-e sinkt
• Für n= 64 wären ca. 3(642/2)= 6144 Iterationen notwendig um
den Fehler um 10-3 zu reduzieren
– kein fill-in, geringer Speicherbedarf bei dünnbesetzten Matrizen
32
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
33
3.1.2 Gauß-Seidel-Verfahren
• Zerlegung der Matrix A anlog zum Jacobi-Verfahren,
A=D-L-R (D,L,R Rnn)
• Iterationsschritt: (D-L)x(k+1)=Rx(k)+b.
• in Komponentenschreibweise
i 1
n


1
xi(k 1)   bi  aij x (jk 1)  aij x (jk )  , i  1, , n

aii 
j 1
j i 1




34
3.1.2 Gauß-Seidel-Verfahren
xi( k 1)
1 

bi 
aii 

i 1

j 1
aij x (jk 1)
n



aij x (jk ) 

j i 1

, i  1, , n
• Einbeziehung der neu Berechneten Approximation
 deutlich verbesserte Konvergenzrate
 Konvergenzrate: n(e/3) Iterationen um den Fehler um den Faktor
10-e zu senken
 aber Datenabhängigkeiten, die eine Parallelisierung des Verfahrens
erschweren
35
3.1.2 Gauß-Seidel-Verfahren
• In Dünnbesetzte Matrizen weniger Datenabhängigkeiten
• Eine Möglichkeit Rot-Schwarz-Anordnung, für
Gleichungssysteme, die von einer Gitterstruktur herrühren
• Bsp. Temperaturverlauf im Wasserbad
xi,j= (xi-1,j + xi+1,j + xi,j-i + x i,j+1) / 4
36
3.1.2 Gauß-Seidel-Verfahren
• Für n = 16 Punkte ergibt sich folgendes Gitter und Matrix
A
1
5
9
13
2
6
10
14
3
7
11
15
4
8
12
16
x
x




x


















x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x

















x




x

x
37
3.1.2 Gauß-Seidel-Verfahren
• Rote-Schwarz-Anordnung :
1
92
23
– rot Punkt nur schwarze Nachbarn
und umgekehrt
– Die Rote von 1,...,nS, numerieren
10
4
11
5
36
12
7
48
59
13
10
6
11
14
12
– die Schwarze von nS+1,... ,nR+nS
numerieren (nR+nS=n)
15
13
7
14
16
15
8
16
• neue Matrix  (Permutation von A)
• Die Zerlegung von  in  =D-L-R
(D,L,R Rnn) mit
D
D   R
 0
0 

DS 
 0
L  
- E
0

0
 0 - F

R  
0 0 
x












x


x








x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x
x








x
x

x












x
38
3.1.2 Gauß-Seidel-Verfahren
D
  xˆ   R
 E
F   xˆ R   bˆ1 
.    
DS   x̂ S   bˆ2 
• Iterationsschritt:
D R  xR(k 1)  bˆ1  F  xS(k)
D  x (k 1)  bˆ  E  x (k 1)
S
2
S
R
• in Komponentenschreibweise:
x
x

( k 1)
R
i

( k 1)
S
i


1
aˆ ii

b 
 i

1
aˆ i  ns ,i  ns


j

, i  1,... , n S ,
 aˆ



j


  
aˆ ij x S( k )
jN ( i )


 bi  ns 


n
jN ( i )
i  ns , j
x
( k 1)
R

, i  1,... , n R
39
3.1.2 Gauß-Seidel-Verfahren
parallel Implementierung:
• maximal p=nr (bzw. p=ns) Prozessoren
• Aufteilung anhand des Gitters vorgenommen
– wird Pj Gitterpunkt i zugeordnet, dann Pj für Berechnung der
Approximationen von xi zuständig
– Aufteilung z.B. zeilenblockweise
– bei p Prozessoren erhält jeder Prozessor n / p Gitterzeilen
(½(n / p) rote und schwarze Punkte)
40
3.1.2 Gauß-Seidel-Verfahren
• wähle beliebigen Startvektor
• Prozessoren iterieren folgende Schritte bis der Test auf
Abbruch erfolgreich
1. Pi sendet seine lokal Elemente von xS(k) an alle anderen
Prozessoren (All-to-All Broadcast)
2. Pi berechnet die neue Approximation xR(k+1) für seine Elemente
von xR(k)
3. Pi sendet seine Elemente von xR(k+1) an alle anderen
Prozessoren (All-to-All Broadcast)
4. Pi berechnet die neue Approximation xS(k+1) für seine Elemente
von xS(k)
5. Test auf Abbruch
41
3.1.2 Gauß-Seidel-Verfahren
Aufwand:
• Der Rechenaufwand fast identisch zu dem des JacodiVerfahrens
– In Schritt 2 und 4 jeweils n/2p Elemente der neuen Approximation
berechnen,
 insgesamt die gleiche Anzahl, wie beim Jacobi-Verfahrens
• eine All-to-All Broadcastoperation mehr erforderlich
(Schritt 1 und 3)
• zusätzlicher Aufwand durch verbessertes
Konvergenzverhalten kompensiert
42
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
43
3.2 Methode der konjugierten Gradienten
• Voraussetzung: Matrix ARnn positiv definit und
symmetrisch
• Lösung x* des Gleichungssystems entspricht dem
Minimum der Funktion:
f ( x) 
1 T
x Ax  bT x
2
• f(x) ist konvex und besitzt eindeutiges Minimum x*
44
3.2 Methode der konjugierten Gradienten
• Iterationsschritt:
x (k 1)  x (k )   (k ) p (k )
– (k) Schrittweite , p(k) Richtungsänderung
• Bestimmung von (k) bei bekanntem p(k) :
f ( x   (k ) p ( k ) )  min R ( f ( x ( k )  p ( k ) )
– Notwendige Bedingung, mit r = Ax-b :
df ( x  p)
 pT ( Ax  b)  pT r
T
T
 p Ap  p ( Ax  b)  0   min 
 T
T
da
p Ap
p Ap
– Hinreichende Bedingung:
df 2 ( x  p)
da
2
 p T Ap  0 immer
erfüllt !
45
3.2 Methode der konjugierten Gradienten
• Wahl des Richtungsvektors p(k) :
– die Richtungsvektoren p(k) sind so zu wählen, dass sie konjugierte
Basis des Rn bzgl. A bilden:
• Zwei Vektoren p,q Rn sind bzgl. einer symmetrischen, nicht
singulären Matrix A konjugiert falls gilt qTAp=0.
• Ist A positiv definit so bilden die linear unabhängigen Vektoren
p1,...,pn, mit pi 0, i=1,...,n und (pi)TApj=0 für alle i,j eine
konjugierte Basis des Rn bzgl. A.
– Falls die Richtungsvektoren eine konjugierte Basis des Rn bzgl. A
bilden, dann liegt die exakte Lösung nach maximal n Schritten vor.
46
3.2 Methode der konjugierten Gradienten
Der Algorithmus:
– Initialisierung: wähle Startvektor x(0) und setzte p(0) =-r(0) =b-Ax(0)
sowie k=0
– Iteration: solange ||r(k)||>
berechne
1. q(k) =Ap(k)
2. k = [(r(k))T r(k)] / [ (p(k))T q(k) ]
3. x(k+1) =x(k) + kp(k)
4. r(k+1) =r(k) + kq(k)
5. k= [(r(k+1))T r(k+1)]/ [(r(k))T r(k)]
6. p(k+1) =-r(k+1)+ kp(k)
7. k++
Basisoperationen:
Matrix-Vektor-Multiplikation
ein inneres Produkt
eine Vektor-Addition
eine Vektor-Addition
ein inneres Produkt
eine Vektor-Addition
47
3.2 Methode der konjugierten Gradienten
parallele Implementierung:
 zeilenblockweise Aufteilung von A und
blockweise Aufteilung der Vektoren
 durch Parallelisierung der verwendeten
Basisoperationen
n
n
n2
 ( p  n)  (n  )
p
p
p
• eine Matrix-Vektor-Multiplikation
TMVM
• zwei innere Produkte
n

Tip    log p 
p

• drei Vektor-Additionen
n
Tsaxpy   
 p
48
3.2 Methode der konjugierten Gradienten
Rechenaufwand:

TCG   TMVM  2  Tip  3  Tsaxpy

2

n
  n 
n

  n
 2  log p   3  


p
p
  p 

 n2

n


 5  n  log p 
 p

p


49
Gliederung
1. Einleitung
2. Direkte Verfahren
2.1 Gauß-Elimination
2.2 zyklische Reduktion
3. Iterative Verfahren
3.1 klassische iterative Verfahren
3.1.1 Jacobi-Verfahren
3.1.2 Gauß-Seidel-Verfahren
3.2 Methode der konjugierte Gradienten
4. Zusammenfassung
50
4. Zusammenfassung
• Das Gauß-Eliminations-Verfahren
– exakte Lösung
– Vorhersagbare Rechenzeit
– auf fast alle linearen Gleichungssystem Anwendbar
– Nachteil fill-in
 nur für fast voll besetze Matrizen geeignet
• zyklische Reduktion
– für Matrizen mit spezieller Struktur
– exakte Lösung
– Vorhersagbare Rechenzeit
51
4. Zusammenfassung
• Iterative Verfahren
– kein fill-in
– Rechenzeit nicht Vorhersagbar
– für dünnbesetze Matrizen geeignet
– GS-Verfahren konvergiert schneller als das Jacobi-Verfahren, aber
Datenabhängigkeiten
– bei symmetrischer, positiv definiter Koeffizientenmatrix Methode
der konjugierten Gradienten
• exakte Lösung bei rundungsfehlerfreier Rechnung nach
höchstens n Schritten
52
Vielen Dank für die
Aufmerksamkeit!
53