Sie sind auf Seite 1von 7

Numerik Projekt 2 Aufgabe 5

Daniel Judas / Philip Dimitrov


19.11.2012

Aufgabenstellung

In nachfolgendem Projekt werden verschiedene Moglichkeiten die Gauelimination durchzuf


uhren untersucht, angefangen mit der reinen Gauelimination u
ber selbiger mit Spaltenpivotsuche und zuletzts noch mit Totalpivotsuche.
Bei diesen drei Methoden wird der relative Rechenfehler verglichen um zu sehen, welche
als die Effektivste zu bezeichnen ist.
Intuitiv sollte es mit Totalpivotsuche nat
urlich um einiges genauer sein, da diese um einiges aufwandiger, als zb die reine Gauelimination ist.

Gausches Eliminationsverfahren

In der linearen Algebra und der Numerik ist das Gau-Verfahren oder gausche Eliminationverfahren als Algorithmus zu verstehen, mit dem es gelingt lineare Gleichungssysteme
zu losen.
Der Algorithmus beruht im wesentlichen darauf, dass elementare Umformungen getatigt
werden, die zwar das Gleichungssystem andern, die Losung aber erhalten.
Dadurch lasst sich jedes eindeutig Losbare Gleichungssystem Ax = b auf die Stufenform
umbauen und daraufhin u
ber schrittweises Eliminieren die Losung bestimmen.

Reine Gauelimination

Hierbei handelt es sich um die simpelste Form das Gau-Verfahren anzuwenden.


Es werden nur Zeilen vertauscht und anschlieend eliminiert, was wie im spateren Verlauf
zu sehen, zu Problemen f
uhren kann
Mit nachfolgendem Matlab-Code wurde die reine Gauelimination durchgef
uhrt:

function x=rgauss(A,b)
[m,n] = size(A);
if m=n
error(Die Matrix ist nicht quadratisch.);
end
l = eye(n);
x = zeros(n,1);
for k=1:n-1
for i=k+1:n l(i,k) = A(i,k)/A(k,k);
b(i)=b(i)-l(i,k)*b(k);
A(i,k+1:n) = A(i,k+1:n) - l(i,k)*A(k,k+1:n);
end end
for j=n:-1:1
x(j) = (b(j)-sum(A(j,j+1:n)*x(j+1:n)))/A(j,j);
end

Vorskalierung

Durch ung
unstiges Hochskalieren kann es zu groen Rechenfehlern kommen, weshalb
zunachst u
uft werden sollte, ob die Eintrage der Matrix ungefahr in der gleichen
berpr
Groenordnung sind.
Um sie auf diese Form zu bringen wird je Zeile der betragsgrote Eintrag gesucht und
die komplette Zeile inklusive dem Eintrag in b durch selbige dividiert.

Pivotelement

Das Wort pivot kommt aus dem Franzosischem, wo es soviel wie Dreh-/Angelpunkt bedeutet, was auch gleich die Bedeutung in der Mathematik verdeutlicht.
Es wird benotigt um in verschiedenen Algorithmen bestimmte Berechnungen durchf
uhren
zu konnen, in unserem Fall in der Gauelimination.
Pro Spalte bzw Zeile wird nach dem betragsmaig groten Element gesucht, welches dann
Pivot genannt wird.

Gauelimination mit Spaltenpivotsuche

Mit der Spaltenpivotsuche umgehen wir die Situation, dass an der Stelle des Pivots eine
Null steht und somit die reine Gauelimination an ihre Grenzen stoen w
urde.
Es wird die Spalte von oben durchgelaufen und u
uft in welcher Zeile das betragsberpr
grote Element steht, diese Zeile wird dann mit der Zeile vertauscht, in der die niedrigere
Zahl steht.
Umgesetzt wurde es in Matlab wie folgt:
function x=spaltenpivot(A,b)
[m,n] = size(A);
if m =n
error(Die Matrix ist nicht quadratisch.);
end
l = eye(n);
x = zeros(n,1);
pp=1:n;
%Vorskalierung
for k=1:n
[tmp,c]=max(abs(A(k,1:n)));
b(k)=b(k)/A(k,c);
A(k,1:n)=A(k,1:n)/A(k,c);
end
%Gau Elimination mit Pivotsuche
for k=1:n-1
[tmp,p] = max(abs(A(pp(k:n),k)));
p=p+k-1;
hlp=pp(k);
pp(k)=pp(p);
pp(p)=hlp;
for i=k+1:n
3

l(pp(i),k) = A(pp(i),k)/A(pp(k),k);
b(pp(i))=b(pp(i))-l(pp(i),k)*b(pp(k));
A(pp(i),k+1:n) = A(pp(i),k+1:n)-l(pp(i),k)*A(pp(k),k+1:n);
end end
%R
uckwartssubstitution for j=n:-1:1
x(j) = (b(pp(j))-sum(A(pp(j),j+1:n)*x(j+1:n)))/A(pp(j),j);
end end

Gauelimination mit Totalpivotsuche

Das Totalpivot wir nun sowohl in Spalte als auch in der Zeile gesucht sodass in der Diagonale betragsmaig die groten Zahlen stehen, sowohl von Spalte als auch von Zeile
ausgehend.
Hierf
ur haben wir zunachst folgenden Matlab-Code angewendet um die LU-Zerlegung zu
bekommen:

function [L, U, P, Q] = gecp2(A)


% Input : A nxn matrix
% Output
% L = Lower triangular matrix with ones as diagonals
% U = Upper triangular matrix
% P and Q permutations matrices so that P*A*Q = L*U
[n, n] = size(A);
p = 1:n;
q = 1:n;
for k = 1:n-1
[maxc, rowindices] = max( abs(A(k:n, k:n)) );
[maxm, colindex] = max(maxc);
row = rowindices(colindex)+k-1; col = colindex+k-1;
A( [k, row], : ) = A( [row, k], : );
A( :, [k, col] ) = A( :, [col, k] );
p( [k, row] ) = p( [row, k] ); q( [k, col] ) = q( [col, k] );
if A(k,k) == 0
break
end
A(k+1:n,k) = A(k+1:n,k)/A(k,k);
i = k+1:n;

A(i,i) = A(i,i) - A(i,k) * A(k,i);


end
L = tril(A,-1) + eye(n);
U = triu(A);
P = eye(n);
P = P(p,:);
Q = eye(n);
Q = Q(:,q);

Mit unserer LU Zerlegung wenden wir jetzt nachstehende Formeln an:


L U = P 1 A P2
wobei P1 und P2 Permutationsmatrizen sind. Um weiter die Vorteile der LU-Zerlegung
zu nutzen lost man nun die Gleichungen:
L U x = P1 b
x = P2 x

Anwendung der Verfahren und Auswertung der


Fehler

Berechnung des Rechenfehlers:


Der relative Rechenfehler wurde wie folgt in Matlab berechnet:
F ehler =

norm(
x x)
norm(x)

Wobei mit einem exaktem x der Losungsvektor b ausgerechnet und daraufhin mit der
Matrix A und dem Vektor b das Gleichungssystem A x = b gelost wurde.
Hilbertmatrix:
Die Hilbertmatrix baut sich wie nach dieser Formel auf
Ein Beispiel hierf
ur:
1 1
1 2 3
H := 1 1 1
2
1
3

3
1
4

1
i+j1

4
1
5

In der Tabelle sind nun die Rechenfehler aufgef


uhrt, ausgewertet f
ur x = (1, 2, 3, 4, ...., n)T ,
sortiert nach den einzelnen Verfahren, wobei die Spalte ganz links die Dimension angibt.

Householder-Matrix:
Bei der Householder-Matrix wird die Formel H := I
anschlieende Beispiel zu kommen:


0 1
H :=
1 0

2
vT v
vT v

entwickelt um auf das

Erneut wird eine Tabelle mit den entsprechenden relativen Rechenfehlern aufgestellt, ausgewertet mit x = (1, 1, 1, 1, ....1)T .

Fazit

Wie oben zu sehen gibt es zwar den Punkt an dem die reine Gauelimination an ihre
Grenzen stot, dieser kommt aber eher selten vor und man benotigt daf
ur konstruierte
Beispiele wie in diesem Fall.
Des Weiteren sieht man, solange es moglich ist mit der reine Gauelimination zu rechnen,
ergibt sich kein groer Unterschied zu den wesentlich aufwendigeren Verfahren wie der
Spalten- bzw Totalpivotsuche.
Zwischen Spalten- und Totalpivot suche ist die Abweichung der Rechenfehler ebenfalls
sehr gering.
6

Deshalb ist es offensichtlich, dass in den meisten Fallen eine reine Gauelimination
vollends ausreichend ist.

10

Beschreibung der Betriebsmittel

F
ur die Berechnungen wurde Maple 16 verwendet. Das erstellen der Tabelle verlief in
matlab. Daten des Verwendeten Computer:
Intel Core i5
4 GB RAM Arbeitsspeicher
MacOS