Folien (Zusammenfassung)

1 Arithmetische Grundlagen
Am 4. Juni 1996 explodierte kurz nach dem Start die

erste Ariane 5 Rakete durch einen Softwarefehler.
Die Horizontalgeschwindigkeit wurde durch eine
Gleitkommazahl
v ∈ [−10308 , −10−308 ] ∪ {0} ∪ [10−308 , 10308 ]
dargestellt.
Innerhalb der Rechnung wurde die Zahl versehentlich
in eine ganzzahlige Darstellung
n ∈ {0, 1, 2, ..., 32 767}
konvertiert.
Als die Geschwindigkeit v > 32 767 m/h erreichte,
verlor die Software die Geschwindigkeitsinformation
und damit schließlich die Orientierung.
http://ta.twi.tudelft.nl/users/vuik/wi211/disasters.html
http://www5.in.tum.de/ huckle/bugse.html
C. Wieners: Einführung in die Numerische Mathematik für Studierende der Fachrichtung Informatik und Ingenieurwissenschaften 1
Am 25. Februar 1991 während des ersten Golfkriegs in
Dharan, Saudi Arabien, verfehlte eine amerikanische
Patriot–Rakete eine anfliegende irakische Scud Rakete
durch eine falsche Zeitberechnung.
Eine 1/10 Sekunde wurde ungenau dargestellt (durch
Rundungsfehler wurde die periodische Dualentwicklung
0.0001100110011001100110011001100....
in der Computerdarstellung zu
0.00011001100110011001100
abgeschnitten), so dass nach 100 Stunden Betriebszeit
eine Zeitdifferenz von ca. 0.3 Sekunden entstand.
Dieser Fehler wurde nicht in allen Teilen des
Betriebsprogramms korrigiert.
http://ta.twi.tudelft.nl/users/vuik/wi211/disasters.html
http://www5.in.tum.de/ huckle/bugse.html
(1.1)
a) Die Gleitkommazahlen zur Basis B ∈ {2, 3, ...} der Mantissenlänge M und
Exponentenlänge E ist die Menge
n M E−1 o
FL = ± B e ∑ am B −m : e = e− + ∑ ck B k , am , ck ∈ {0, 1, ..., B − 1} .
m=1 k =0
b) Eine Gleitkommaarithmetik wird durch eine Abbildung fl : R −→ FL mit fl(x) = x für
x ∈ FL definiert. Sie bestimmt die Rundung: x ⊕ y = fl(x + y ), x y = fl(x · y ), etc.
Die zugehörige Maschinengenauigkeit ist

|x − fl(x)|
eps := sup ; 1<x <2 .
|x|
(1.2)
a) Ein Problem heißt sachgemäß gestellt, wenn es eindeutig lösbar ist und die Lösung
stetig von den Daten abhängt.
b) Die Kondition eines Problems ist ein Maß dafür, wie stark die Abhängigkeit der Lösung
von den Daten ist.
c) Die Stabilität eines numerischen Algorithmus ist ein Maß dafür, wie stark die Daten-
Abhängigkeit der numerischen Lösung im Vergeich zu der tatsächlichen Lösung ist.
(1.3) Sei f : RN −→ RK eine differenzierbare Funktion und x ∈ RN . Dann heißt

a) κabskn = ∂ f (x) absolute Konditionszahl.
∂ xn k

b) κrelkn = ∂ f (x) |xn | relative Konditionszahl.
∂ xn k |f (x)|
k
Auslöschung bei Nullstellenberechnung
Wir betrachten die Gleichung
x 2 − 2px + q = 0,
deren Nullstellen durch
q
x = p ± p2 − q
gegeben sind. Diese Berechnungsvorschrift ist aber für p q nicht zu empfehlen, da dann
Auslöschung bei der betragsmäßig kleineren Nullstelle auftritt. Wählt man beispielsweise
p = 108 und q = 1, so berechnet IEEE-Arithmetik
x1 = 2 ∗ 108 , x2 = 0.
Die Auslöschung bei x2 kann man umgehen, indem man zuerst die größere Nullstelle durch
q
x1 = p + sign(p) p2 − q
berechnet und dann (mit dem Satz von Vieta) die zweite Nullstelle durch
q
x2 =
x1
erhält. Mit dieser Vorschrift berechnet IEEE-Arithmetik die bessere Lösung
x1 = 2 ∗ 108 , x2 = 0.5 ∗ 10−9 .
Sei | · | eine Vektornorm, und sei k · k eine zugeordnete Matrixnorm, d. h.,
|Ax| ≤ kAk |x| , x ∈ RN , A ∈ RM×N .

Wir verwenden für x ∈ RN und A ∈ RM×N
N p
|x|1 = ∑ |xn | |x|2 = xT x |x|∞ = max |xn |
n=1 n=1,...,N
|Ax|p
und die zugeordnete Operatornorm kAkp = supx6=0N |x|p , d.h.
M q N
kAk1 = max ∑ |amn | , kAk2 = ρ(AT A) , kAk∞ = max ∑ |amn |
n=1,...,N m=1 m=1,...,M n=1
mit Spekralradius ρ(A) = max{|λ | : λ Eigenwert von A}.
(1.4) Sei A ∈ RN×N invertierbar. Dann heißt κp (A) = kAkp kA−1 kp die Kondition von A.
Sei b ∈ RN , b 6= 0N , 4b ∈ RN eine kleine Störung und b̃ = b + 4b.

Sei x ∈ RN Lösung von Ax = b, x̃ ∈ RN Lösung von Ax̃ = b̃, und 4x = x̃ − x der Fehler.
|4x|p |4b|p
Dann gilt für den relativen Fehler ≤ κp (A) .
|x|p |b|p
2 Direkte Lösungsverfahren für lineare Gleichungen
(2.1) Sei L ∈ RN×N eine normierte untere Dreiecksmatrix und b ∈ RN . Dann ist L invertierbar und
das Lineare Gleichungssystem (LGS) Ly = b ist mit O(N 2 ) Operationen lösbar.
Entsprechend ist für eine invertierbare obere Dreiecksmatrix R ∈ RN×N das LGS Rx = y in
O(N 2 ) Operationen lösbar.
(2.2) Wenn eine Matrix A ∈ RN×N eine LR-Zerlegung A = LR mit einer normierten untere
Dreiecksmatrix L und einer invertierbaren obere Dreiecksmatrix R besitzt, dann ist A
invertierbar und das LGS Ax = b ist mit O(N 2 ) Operationen lösbar.
(2.3) Eine Matrix A ∈ RN×N besitzt genau dann eine LR-Zerlegung von A, wenn alle
Hauptuntermatrizen A[1 : n, 1 : n] invertierbar sind. Die LR-Zerlegung ist eindeutig und lässt
sich mit O(N 3 ) Operationen berechnen.
N
(2.5) Eine Matrix A ∈ RN×N heißt strikt diagonal-dominant, falls |A[n, n]| > ∑ |A[n, k ]|.
k =1
k 6=n
Sie heißt positiv definit, wenn x > Ax > 0 für x ∈ RN , x 6= 0.
In beiden Fällen existiert eine LR-Zerlegung.
(2.6) Sei A ∈ RN×N symmetrisch und positiv definit.

Dann existiert genau eine Cholesky-Zerlegung A = LL> mit einer unteren Dreiecksmatrix L.
Software: www.netlib.org/lapack www.mathworks.com www.python.org

from scipy import linalg
import numpy as np
def lu_decomposition(matrix):
n = matrix.shape[0]
lower = np.zeros(shape=matrix.shape)
upper = np.zeros(shape=matrix.shape)
for j in range(n):
lower[j][j] = 1.0
for i in range(j + 1):
first_sum = sum(upper[k][j] * lower[i][k] for k in range(i))
upper[i][j] = matrix[i][j] - first_sum
for i in range(j, n):
second_sum = sum(upper[k][j] * lower[i][k] for k in range(j))
lower[i][j] = (matrix[i][j] - second_sum) / upper[j][j]
return lower, upper
def forward_sub(lower, rhs):

n = lower.shape[0]
solution = np.zeros(n)
for i in range(n):
solution[i] = rhs[i]
for j in range(i):
solution[i] = solution[i] - (lower[i, j] * solution[j])
solution[i] = solution[i] / lower[i, i]
return solution
def backward_sub(upper, rhs):

n = upper.shape[0]
for i in range(n - 1, -1, -1):
tmp = rhs[i]
for j in range(i + 1, n):
tmp -= upper[i, j] * solution[j]
solution[i] = tmp / upper[i, i]
return solution
def solve_with_lu(matrix, rhs):

lower, upper = lu_decomposition(matrix)
y = forward_sub(lower, rhs)
return backward_sub(upper, y)
from scipy import linalg
import numpy as np
def cholesky_decomposition(matrix):
n = matrix.shape[0]
lower = np.zeros(matrix.shape)
lower[0, 0] = np.sqrt(matrix[0, 0])
for n in range(1, n):
y = linalg.solve_triangular(lower[:n, :n], matrix[n, :n], lower=True)
lower[n, :n] = y
lower[n, n] = np.sqrt(matrix[n, n] - np.dot(y, y))
return lower
def forward_sub(lower, rhs):

n = lower.shape[0]
for i in range(n):
solution[i] = rhs[i]
for j in range(i):
solution[i] = solution[i] - (lower[i, j] * solution[j])
solution[i] = solution[i] / lower[i, i]
return solution
def backward_sub(upper, rhs):

n = upper.shape[0]
for i in range(n - 1, -1, -1):
tmp = rhs[i]
for j in range(i + 1, n):
tmp -= upper[i, j] * solution[j]
solution[i] = tmp / upper[i, i]
return solution
def solve_with_cholesky(matrix, rhs):

lower = cholesky_decomposition(matrix)
y = forward_sub(lower, rhs)
return backward_sub(lower.transpose(), y)
matrix = np.array([[2.0, 1.0],
[1.0, 4.0]])
rhs = np.array([1.0, 2.0])
solution = solve_with_lu(matrix, rhs)
print("solution",solution)
test = rhs - np.dot(matrix,solution)
print("test ",test)
rhs = np.array([1.0, 2.0])
solution = solve_with_cholesky(matrix, rhs)

print("solution",solution)
test = rhs - np.dot(matrix,solution)
print("test ",test)
2 Direkte Lösungsverfahren für lineare Gleichungen
(2.7) a) Eine bijektive Abbildung π : {1, . . . , N} → {1, . . . , N} heißt Permutation.
Sie wird eindeutig durch einen Permutationsvektor p = π(1), . . . , π(N) repräsentiert.
b) Die zugehörige Permutationsmatrix Pπ = eπ −1 (1) · · · eπ −1 (N) ∈ RN×N von π vertauscht

die Einträge einer Matrix. Dabei ist ek ∈ RN der k -te Einheitsvektor.

(2.8) Sei A ∈ RN×N invertierbar. Dann existiert eine Permutationsmatrix P, so dass PA eine
LR-Zerlegung PA = LR besitzt, so dass |L[m, n]| ≤ 1 gilt.
(2.9) a) Zu v ∈ RN und k 6= n mit v [k ]2 + v [n]2 > 0 existiert eine Givens-Rotation G ∈ RN×N mit

G[k , k ] G[k , n] c s
= , c 2 + s2 = 1 ,
G[n, k ] G[n, n] −s c
und G[j, j] = 1 für j 6= k , n und G[i, j] = G[j, i] = 0 sonst, so dass für w = Gv gilt: w[n] = 0.
Für |v [n]| > |v [k ]| setze τ = vv [k ]
[n] , s =
√ 1 , c = sτ, sonst setze τ = vv [k
2
[n]
], c =
√ 1 , s = cτ.
2
1+τ 1+τ
2
b) Zu v ∈ RN , v 6= 0, existiert eine Householder-Spiegelung H = IN − ww > ∈ RN×N
w >w
mit w ∈ RN , w[1] = 1, sodass Hv = σ e1 mit σ ∈ R.
1
Falls v [1] > 0, setze σ = −|v |2 , sonst setze σ = |v |2 . Dann definierte w = v [1]−σ (v − σ e1 ).
Rotationen und Spiegelungen Q sind orthogonale Matrizen, d.h.

Q > Q = IN , Q −1 = Q > , kQk2 = 1 und κ2 (Q) = 1.
(2.10) Zu A ∈ RK ×N existiert eine QR-Zerlegung A = QR mit einer orthogonalen Matrix Q ∈ RK ×K
und eine oberen Dreiecksmatrixmatrix R ∈ RK ×N .
LR-Zerlegung (ohne Vektorisierung)
N = size(A,1);
for n=1:N-1
% Berechnung der n-ten Spalte von L
for m=n+1:N
A(m,n) = A(m,n)/A(n,n);
end;
% keine Berechnung der n-ten Zeile von R erforderlich
% Berechnung der Restmatrix

for m=n+1:N
for k=n+1:N
A(m,k) = A(m,k) - A(m,n) * A(n,k);
end;
end;
end;
LR-Zerlegung
N = size(A,1);
for n=1:N-1
A(n+1:N,n) = A(n+1:N,n)/A(n,n);
A(n+1:N,n+1:N) = A(n+1:N,n+1:N) - A(n+1:N,n) * A(n,n+1:N);
end;
x = b;
for n=2:N
x(n) = x(n) - A(n,1:n-1) * x(1:n-1);
end;
for n=N:-1:1
x(n) = (x(n) - A(n,n+1:N)*x(n+1:N))/A(n,n);
end;
Cholesky-Zerlegung
N = size(A,1);
for n=1:N
A(n:N,n) = A(n:N,n) - A(n:N,1:n-1) * A(n,1:n-1)’;
A(n:N,n) = A(n:N,n) / sqrt(A(n,n));
end;
x = b;
for n=1:N
x(n) = (x(n) - A(n,1:n-1) * x(1:n-1))/ A(n,n);
end;
for n=N:-1:1
x(n) = (x(n) - A(n+1:N,n)’ * x(n+1:N))/ A(n,n);
end;
LR-Zerlegung mit Pivotsuche
N = size(A,1); p = (1:N)’;
for n = 1:N-1
[r,m] = max(abs(A(n:N,n)));
m = m+n-1;
if abs(A(m,n))<eps
error(’*** ERROR *** LR-Zerlegung existiert nicht’);
end;
if (m ~= n)
A([n m],:) = A([m n],:); p([n m]) = p([m n]);
end;
A(n+1:N,n) = A(n+1:N,n)/A(n,n);
A(n+1:N,n+1:N) = A(n+1:N,n+1:N) - A(n+1:N,n)*A(n,n+1:N);
end;
x = b(p);
for n=2:N
x(n) = x(n) - A(n,1:n-1)*x(1:n-1);
end;
for n=N:-1:1
x(n) = (x(n) - A(n,n+1:N)*x(n+1:N))/A(n,n);
end;
Berechnung der Householder-Vektoren
function [v,beta] = householder(y)

N = length(y);
s = y(2:N)’ * y(2:N);
if N == 1
s = 0;
end;
v = [1;y(2:N)];
if s == 0
beta = 0;
else
mu = sqrt(y(1)^2 + s);
if y(1) <= 0
v(1) = y(1) - mu;
else
v(1) = -s/(y(1) + mu);
end;
beta = 2*v(1)^2/(s + v(1)^2);
v = v / v(1);
end;
return;
QR-Zerlegung
[M,N] = size(A);
for m = 1:min(N,M-1)
[v,beta] = householder(A(m:M,m));
if beta ~= 0
w = beta * v’ * A(m:M,m:N);
A(m:M,m:N) = A(m:M,m:N) - v * w;
A(m+1:M,m) = v(2:M-m+1);
end;
end;
for m = 1:min(N,M-1)
v = [1;A(m+1:M,m)];
beta = 2 / (v’ * v);
if beta ~= 2
b(m:M) = b(m:M) - beta*(v’*b(m:M)) * v;
end;
end;
for n=min(N,M):-1:1
x(n) = (b(n) - A(n,n+1:N) * x(n+1:N)) / A(n,n);
end;
3 Lineare Ausgleichsrechnung
(3.1) Sei A ∈ RK ×N und b ∈ RK . Dann gilt:
x ∈ RN minimiert |Ax − b|2 ⇐⇒ A> Ax = A> b.
(3.2) Zu A ∈ RK ×N existieren Singulärwerte σ1 , ..., σR > 0 und eine Singulärwertzerlegung

R
A = V ΣU > = ∑ σr vr ur> , R = rang(A)
r =1
mit V = (v1 | · · · |vR ) ∈ RK ×R , U = (u1 | · · · |uR ) ∈ RN×R und Σ = diag(σ1 , . . . , σR ) ∈ RR×R mit
V > V = IR , U > U = IR , und σr > 0 für r = 1, ..., R.
R
1
(3.3) A+ = UΣ−1 V > = ∑ σr ur vr> ist die Pseudo-Inverse.
r =1
(3.4) x = A+ b löst die Normalengleichung A> Ax = A> b.
(3.5) Sei A ∈ RK ×N und b ∈ RK .

Dann gilt für die Tikhonov-Regularisierung mit α > 0:
x ∈ RN minimiert |Ax − b|22 + α |x|22 ⇐⇒ (A> A + αIN )x = A> b.
(3.6) Es gilt lim (A> A + αIN )−1 A> b = A+ b.

α−→0
Ein schlecht konditioniertes Gleichungssystem
Wir betrachten das lineare Gleichungssystem Ax = b mit der Hilbertmatrix
1
A= ∈ RN+1×N+1
m + n + 1 m,n=0,...,N
n
und der rechten Seite b = (−1)n log(2) + ∑ (−1)m ∈ RN+1 .
n=0,...,N
m=1
Die exakte Lösung lautet:

N x0 x1 x2 x3 x4 x5 x6
1 0.93 −0.48
2 0.99 −0.80 0.33
3 1.00 −0.94 0.66 −0.22
4 1.00 −0.98 0.86 −0.53 0.15
5 1.00 −1.00 0.95 −0.77 0.42 −0.11
6 1.00 −1.00 0.98 −0.90 0.67 −0.32 0.07
(Beispiel aus Kress: Numerical Analysis)
Stören wir nun aber die rechte Seite geringfügig, indem wir log(2) nur bis auf
5 Nachkommastellen auswerten, so erhalten wir folgende Lösung:
N x0 x1 x2 x3 x4 x5 x6
1 0.93 −0.48
2 0.99 −0.81 0.33
3 1.00 −0.96 0.70 −0.25
4 1.01 −1.16 1.63 −1.70 0.72
5 1.06 −2.74 12.68 −31.16 33.87 −13.26
6 1.39 −16.58 151.10 −584.81 1071.96 −926.77 304.50
Also: Eine geringfügige Störung der Daten führt zu einer großen Sprung des Ergebnisses.
Der Grund dafür liegt in der schlechten Kondition der Hilbertmatrix.
Diese ist in der Spektralnorm:
N 2 3 4 5 6
κ2 (A) 19.28 524.06 1.55e + 04 4.77e + 05 1.495e + 07
(Beispiel aus Kress: Numerical Analysis)
Wir können die Kondition verbessern, indem wir die Tikhonov-Regularisierung auf die
Hilbertmatrix anwenden, d.h.
x α = (A> A + αIN )−1 A> b .
Regularisieren wir mit einem Parameter α = 10−10 , so erhalten wir
N x0 x1 x2 x3 x4 x5 x6
1 0.93 −0.48
2 0.99 −0.81 0.33
3 1.00 −0.95 0.69 −0.24
4 0.99 −0.89 0.47 0.06 −0.14
5 1.00 −0.91 0.52 0.02 −0.18 0.04
6 1.00 −0.94 0.58 0.08 −0.25 −0.17 0.20
4 Eigenwertberechung
(4.1) Eine Matrix H ∈ RN×N heißt Hessenberg-Matrix, wenn H[n + 2 : N, n] = 0N−n−1 für
n = 1, ..., N − 2.
(4.2) Sei A ∈ RN×N . Dann existiert eine orthogonale Matrix Q ∈ RN×N , so dass H = QAQ > eine
Hessenberg-Matrix ist. Die Berechnung benötigt O(N 3 ) Operationen.
Wenn A symmetrisch ist, dann ist H eine Tridiagonalmatrix.
(4.3) Sei A ∈ RN×N symmetrisch, tridiagonal, und irreduzibel, d.h.

A[n + 2 : N, n] = A[n, n + 2 : N]> = 0N−n−1 und A[n − 1, n] = A[n, n − 1] 6= 0.
Dann hat A paarweise verschiedene reele Eigenwerte λ1 < λ2 < · · · < λN .
v > Av
Zu A ∈ RN×N und v ∈ RN , v 6= 0, sei r (A, v ) = v>v
der Rayleigh-Quotient.
(4.4) Inverse Iteration mit variablem Shift

S0) Wähle z 0 ∈ RN , z 0 6= 0N , ε ≥ 0. Setze k = 0.
S1) Setze w k = |z1| z k , µk = r (A, w k ).
k 2
S2) Falls |Aw k − µk w k |2 ≤ ε STOP.
S3) Berechne z k +1 = (A − µk IN )−1 w k .
S4) Setze k := k + 1, gehe zu S1).
Wenn der Startvektor z 0 hinreichend nahe bei einem Eigenvektor v m mit isoliertem
Eigenwert λ = λm liegt, konvergiert die Iteration kubisch, d.h. |µk − λ | ≤ C |µk − λ |3 .
4 Eigenwertberechnung: QR-Iteration mit Shift
Sei A ∈ RN×N symmetrisch.
S0) Berechne A0 = QAQ > tridiagonal (Hessenberg-Transformation).
Wähle ε ≥ 0. Setze k = 0.
S1) Falls |Ak [n + 1, n]| ≤ ε für ein n:
getrennte Eigenwertberechnung für Ak [1 : n, 1 : n] und Ak [n + 1 : N, n + 1 : N].
S2) Berechne dk = 12 (Ak [N − 1, N − 1] − Ak [N, N]) und
q
sk = Ak [N, N] + dk − sgn(dk ) dk2 + Ak [N − 1, N]2 .
S3) Berechne QR-Zerlegung

Qk Rk = Ak − sk IN
und setze
Ak +1 = Rk Qk + sk IN .
S4) Setze k := k + 1, gehe zu S1).
Es gilt Ak +1 = Qk> Ak Qk . Also haben Ak +1 und Ak disselben Eigenwerte.
Falls der shift sk = Ak [N, N] gewählt wird, entspricht die QR-Iteration der Inversen Iteration
mit variablem Shift und Startvektor z 0 = eN .
Impliziter QR-Algorithmus mit Wilkinson-Shift
Für symmetrische Matrizen (o.B.d.A. Hessenbergform) lässt sich der QR-Algorithmus so
modifizieren, dass die QR-Zerlegung in jedem Iterationsschritt nur implizit durch N − 1
Transformationen mit Givensrotationen durchgeführt werden muss. Durch den
Wilkinson-Shift (siehe Golub, van Loan) erhalten wir außerdem kubische Konvergenz, im
Gegensatz zur linearen Konvergenz des QR-Algorithmus’ ohne Shift. Dabei können wir eine
Toleranz für die verschwindenden Nebendiagonalelemente vorgeben.
Wir betrachten
A = tridiag(−1, 2, −1) ∈ RN×N .
Für die Toleranz tol = ε braucht der Algorithmus die folgende Anzahl von Iterationen:
N Iterationen
100 281
200 532
500 1120
1000 2310
Das sind im Schnitt weniger als 3 Iterationen pro Eigenwert.
Der maximale Fehler bei diesen Berechnungen beträgt zwischen 10−13 und 10−14 .
5 Iterationsverfahren für lineare Gleichungen
(5.1) S0) Wähle x 0 ∈ RN und ε > 0.
Berechne r 0 = b − Ax 0 . Setze k = 0.
S1) Falls |r 0 | ≤ ε STOP.
S2) Berechne
wk = Br k −1
k +1
x = xk + wk
k +1
r = r k − Aw k
Setze k := k + 1 und gehe zu S1).
Sei A = L + D + R. Dann gilt B = D −1 für das Jacobi-Verfahren

−1
und B = L + D für das Gauß-Seidel-Verfahren.
(5.2) Sei A, B ∈ RN×N mit ρ(IN − BA) < 1. Dann ist A invertierbar, und es gilt für alle b ∈ RN und
alle Startvektoren x 0 ∈ RN konvergiert die Iteration
x k +1 = x k + B(b − Ax k ) , k = 0, 1, 2, ...
gegen lim xk = A−1 b. Dann exisitiert eine Vektor-Norm | · | und dazu eine Matrix-Norm k · k
k −→∞
mit kIN − BAk < 1. Damit ergibt sich |x − x k | ≤ kIN − BAkk |x − x 0 | (lineare Konvergenz).
Liste von Software ascend4.org/Survey_of_sparse_matrix_software

Benchmark-Matritzen sparse.tamu.edu
5 Iterative Lösungsverfahren: Krylov-Verfahren
Sei h·, ·iV ein Skalarprodukt in V = RN .
S0) Wähle x 0 ∈ RN .
1 1
Berechne r 0 = b − Ax 0 , z 1 = Br 0 , h10 = |z 1 |V und v 1 = h10 z . Setze k = 1.
S2) Berechne
wk = BAv k
k
z k +1 = w k − ∑ hjk v j mit hjk = hv j , w k iV
j=1
k +1 1
v = z k +1 mit hk +1,k = |z k +1 |V
hk +1,k
S2) Setzte k := k + 1 und gehe zu S1).
Dann ist v 1 , ..., v k eine Orthonormalbasis von dem Krylov-Raum

Vk = span{Br 0 , BABr 0 , . . . , (BA)k −1 Br 0 } = {Qk y : y ∈ Rk } , Qk = v 1 | · · · |v k .

k +1
Es gilt BAv k = ∑ hjk v j , also BAQk = Qk +1 Hk mit Hk = (hjm ) ∈ Rk +1,k .
j=1
GMRES-Verfahren: Wähle hv , wiV = v T w.
cg-Verfahren (A, B symmetrisch positiv definit): Wähle hv , wiV = v T Aw.
5 Iterative Lösungsverfahren: GMRES-Verfahren
S0) Wähle x 0 ∈ RN , ε > 0.
1 1
Berechne r 0 = b − Ax 0 , z 1 = Br 0 , h10 = |z 1 |2 und v 1 = h10 z . Setze k = 1.
S1) Berechne
w k = BAv k
k
z k +1 = w k − ∑ hjk v j mit hjk = (v j )T w k
j=1
k +1 1
v = z k +1 mit hk +1,k = |z k +1 |2
hk +1,k
S2) Berechne y k ∈ Rk mit ρk = |Hk y k − h10 e1 |2 = min!

Dabei ist Hk = (hjm )j=1,...,k +1, m=1,...,k ∈ Rk +1,k und e1 = (1, 0, . . . , 0)> ∈ Rk +1 .
k
S3) Wenn ρk < ε, setze x k = x 0 + ∑ yjk v j STOP.
j=1
S4) Setze k := k + 1 und gehe zu S1).
(4.4) Es gilt ρk = min |B(b − Az)|2 .

z∈x 0 +Vk
(4.5) Für C ≥ α > 0 gelte z T BAz ≥ αz T z und kBAk2 ≤ C.
k /2
α2

Dann gilt für das GMRES-Verfahren |x k − x|2 ≤ κ2 (BA) 1 − 2 |x 0 − x|2 .
C
5 Iterative Lösungsverfahren: cg-Verfahren
Seien A, B ∈ RN×N symmetrisch und positiv definit.
S0) Wähle x 0 ∈ RN , ε > 0.
Berechne r 0 = b − Ax 0 , w 0 = Br 0 , ρ0 = (w 0 )T r 0 und d 1 = w 0 . Setze k = 0.
S1) Falls ρk ≤ ε STOP
S2) Setze k := k + 1 und berechne
uk = Ad k
ρk −1
αk =
(u k )T d k
xk = x k −1 + αk d k
r k
= r k −1 − αk u k
k
w = Br k
ρk = (w k )T r k
ρ
d k +1 = wk + k dk
ρk −1
Gehe zu S1).
pκ(BA) − 1 k
k
(4.6) Es gilt |x − x|A ≤ 2 p |x 0 − x|A .
κ(BA) + 1
6 Iterationsverfahren für nichtlineare Gleichungen
Sei F : RN −→ RN differenzierbar. Sei x ∗ ∈ RN eine Nullstelle von F (·), d.h. F (x ∗ ) = 0.
Dann gilt 0 = F (x) + DF (x)(x ∗ − x) + o(x ∗ − x).
Falls DF (x) invertierbar ist, gilt x ∗ = x − DF (x)−1 F (x) + o(x ∗ − x).
Falls DF (x ∗ ) invertierbar ist, ist x ∗ Fixpunkt von ΦF (x) = x − DF (x)−1 F (x), d.h. ΦF (x ∗ ) = x ∗ .
Newton-Verfahren: Wähle x 0 ∈ RN und definiere x k +1 = ΦF (x k ) für k = 0, 1, 2, ...
(6.1) Sei DF (x ∗ ) invertierbar. Dann ist das Newton-Verfahren für alle x 0 hinreichend nahe bei x ∗
wohldefiniert, und x k konvergiert gegen x ∗ . Wenn zusätzlich F (·) glatt genug ist, ist die
Konvergenz quadratisch, d.h. es existiert C > 0 mit |x k +1 − x ∗ | ≤ C |x k − x ∗ |2 .
Wenn DF (x)−1 durch B ∈ RN×N approximiert wird, erhalten wir eine einfache
Fixpunktiteration mit ΦF ,B (x) = x − BF (x).
(6.2) Sei ρ(IN − B DF (x ∗ )) < 1. Dann gilt: Für alle x 0 hinreichend nahe bei x ∗ konvergiert die
einfache Fixpunkt-Iteration x k +1 = ΦF ,B (x k ) linear gegen x ∗ .
(6.3) Iterationsverfahren für nichtlineare Gleichungen mit Dämpfungsstrategie
S0) Wähle x 0 ∈ RN , θ ∈ (0, 1), smax ∈ N und ε > 0. Setze k = 0.
S1) Falls |F (x k )| ≤ ε STOP (Konvergenz)
S2) Wähle Bk ≈ DF (x k )−1 und berechne c k = −Bk F (x k ).
S3) Wähle tk ∈ {1, θ , θ 2 , ..., θ smax } mit |F (x k + tk ck )| < |F (x k )|.
Falls |F (x k + tk ck )| ≥ |F (x k )| für tk = θ smax STOP (keine Konvergenz)
S4) Setze x k +1 = x k + tk ck , k := k + 1 und gehe zu S1).
7 Polynom-Interpolation
(7.1) Lagrange-Interpolation Zu Stützstellen ξ0 < ξ1 < · · · < ξN und Werten f0 , f1 , . . . , fN ∈ R
existiert genau ein Polynom P ∈ PN mit P(ξn ) = fn .
N N
t−ξk
Konstruktion: Definiere die Lagrange-Basis Ln (t) = ∏ ξn −ξk
, setze P(t) = ∑ fn Ln (t).
k =0, k 6=n n=0
(7.2) Hermite-Interpolation Zu ξ0 ≤ · · · ≤ ξN definiere en = max{n − k : ξk = · · · = ξn }, m = max en .

d en d en
Zu f ∈ C m [a, b] existiert genau ein Polynom P ∈ PN mit P(ξn ) = f (ξn ).
dt dt
Konstruktion: Zu ξ0 ≤ ξ1 ≤ · · · ≤ ξN definiere die Newton-Basis durch
ω0 ≡ 1, ω1 (t) = t − ξ0 , ωk (t) = (t − ξk −1 )ωk −1 (t) ∈ Pk , k = 1, . . . , N .
en
1 d
Nun definiere f [ξn ] = f (ξn ) und f [ξk , . . . , ξn ] = (n−k =! dt f (ξn ) falls ξk = ξk +1 = · · · = ξn .
f [ξk +1 , . . . , ξn ] − f [ξk , . . . , ξn−1 ]
Berechne rekursiv f [ξk , . . . , ξn ] = .
ξn − ξk
N
Dann ist P(t) = ∑ f [ξ0 , . . . , ξk ]ωk (t) das Interpolationspolynom.
k =0
Neville-Schema Sei Pnk ∈ Pn−k Interpolation zu ξk , ..., ξn für 0 ≤ k ≤ n ≤ N. Dann gilt
t − ξk ξn − t
Pnk (t) = P (t) + P (t) ,
ξn − ξk k +1,n ξn − ξk k ,n−1
(7.3) Sei f ∈ C N+1 [a, b], a ≤ ξ0 , . . . , ξN ≤ b. Dann gilt für den Interpolationsfehler
1 d N+1
f (t) − PN (t) = f (τ) ωN+1 (t) mit τ ∈ (a, b).
(N + 1)! dt
Runge-Phänomen bei Interpolation
Wir betrachten das Interpola-
tionsproblem für äquidistant
verteilte Stützstellen. Wir
würden erwarten, dass für
eine genügend glatte Funktion
die Folge der Interpolations-
polynome, gehörig zu immer
kleinerem Stützstellenabstand,
in der Maximumsnorm gegen
die Funktion konvergiert. Dass
dem nicht so ist zeigt zum
Beispiel das sogenannte Runge-
Phänomen für die Funktion
f : [−5, 5] → R,
1
f (x) := .
1 + x2
Der maximale Fehler wird hier sogar immer größer, je höher der Grad des
Interpolationspolynoms ist. Für den Grad 10 ist das zugehörige Interpolationspolynom
eingezeichnet. Der Fehler wird offenbar durch die starke Oszillation verursacht, dies
verschlimmert sich noch mit steigendem Polynomgrad.
8 Spline-Interpolation
(8.1) a) Zu einer Zerlegung Ξ = {a = ξ0 < ξ1 < · · · < ξN = b} von [a, b] definiere den kubischen
Spline-Raum
S3 (Ξ) = S ∈ C 2 [a, b] : Sn := S|[ξn−1 ,ξn ] ∈ P3 ,

n = 1, . . . , N .
b) S ∈ S3 (Ξ) heißt interpolierender Spline zu f ∈ C 0 [a, b] wenn S(ξn ) = f (ξn ).
(8.2) Es gilt dim S3 (Ξ) = 3 + N. Mit einer der Randbedingungen

(I) Natürliche Randbedingung S 00 (a) = 0 und S 00 (b) = 0
(II) Hermite-Randbedingung zu f ∈ C 1 [a, b] S 0 (a) = f 0 (a) und S 0 (b) = f 0 (b)
(III) Periodische Randbedingungen S 0 (a) = S 0 (b) und S 00 (a) = S 00 (b)
ist die Spline-Interpolation S ∈ S3 (Ξ) zu f eindeutig lösbar.
(8.3) Die Momente µn = S 00 (ξn ) von S ∈ S3 (Ξ) zu f sind eindeutig durch

αn µn−1 + µn + βn µn+1 = 3f [ξn−1 , ξn , ξn+1 ]
hn hn+1
und αn = , βn = bestimmt und es gilt
2(hn + hn+1 ) 2(hn + hn+1 )
µn (t − ξn−1 )3 + µn−1 (ξn − t)3 f (ξn ) + f (ξn−1 ) hn2
Sn (t) = + − (µn + µn−1 )
6hn 2 12
f (ξ ) − f (ξ ) h ξn + ξn−1
n n−1 n
+ − (µn − µn−1 ) t − .
hn 6 2
(8.4) Sei f ∈ C 4 [a, b]. Dann gilt für die Spline-Interpolation kS − f k∞ ≤ h4 kf 0000 k∞ mit h = max hn .
9 Trigonometrische Interpolation und FFT
2π
(9.1) Sei f : R −→ C eine 2π-periodische stetige Funktion, N = 2K , ξn = n und fn = f (ξn ).
N
Dann existiert genau ein trigonometrisches Interpolationspolynom
N−1
TN (t) = ∑ cn exp(int) , cn ∈ C
n=0
mit TN (ξn ) = fn für n = 0, ..., N − 1. Es gilt

N−1
1
ck =
N ∑ fn ωN−kn , ωN = exp(i2π/N) .
n=0
Die Koeffizienten lassen sich rekursiv mit O(N log N) Operationen berechnen:
N−1 M−1 M−1
∑ fn ωN−kn = ∑ −km
f2m ωM + ω −k ∑ −km
f2m+1 ωM , N = 2M .
n=0 m=0 m=0
Für s-mal stetig differenzierbare Funktionen konvergieren die Koeffizienten ck gegen

Z 2π
1
f̂k = f (t) exp(−ikt) dt ,
2π 0
und es existiert eine Konstante Cs > 0 mit
d s Z 2π
1/2
kf − TN kL2 (0,2π) ≤ Cs N −s k f kL2 (0,2π) , kgkL2 (0,2π) = |g(t)|2 dt .
dt 0
10 Numerische Integration
(10.1) Sei [a, b] ⊂ R ein Intervall, und sei Ξ ⊂ [a, b] eine endliche Menge mit |Ξ| = N.
Dann existiert genau eine Quadratur
QΞ : C[a, b] −→ R , QΞ (f ) = ∑ ωξ f (ξ )
ξ ∈Ξ
mit Gewichten ωξ ∈ R zu den Stützstellen ξ ∈ Ξ, die für Polynome vom Grad N − 1 exakt ist:
Z b
QΞ (P) = P(t) dt , P ∈ PN−1 .
a
t−η Rb
Konstruktion: Sei Lξ (t) = ∏η∈Ξ\{ξ } ξ −η
. Dann gilt ωξ = a Lξ (t) dt.
(10.2) a) Es gibt genau eine Quadratur GN mit N Stützstellen, die für Polynome in P2N−1 exakt ist.
Wähle dazu die Nullstellen des Orthogonalpolynoms PN ∈ PN bzgl. (f , g) = ab f (t)g(t) dt.
R
b) Es gibt keine Quadratur QΞ mit #Ξ = N, die für Polynome P ∈ P2N exakt ist.
(10.3) Sei QΞ eine Quadratur, die für Polynome P ∈ PK −1 exakt ist. Dann existiert C > 0 mit
Z b d K
QΞ (f ) − f (t) dt ≤ C(b − a)K +1 f

a dt ∞
(10.4) Für die summierte Trapezregel

M−1
1 1 b−a
TM (f ) = h f (a) + ∑ f (a + mh) + f (b) mit h=
2 m=1
2 M
Rb 2 00
gilt TM (f ) − a f (t) dt ≤ C h kf k∞ .

10 Extropolierte Trapezsummen (Romberg)
Die Trapezsummen lassen sich extrapolieren: Setze Tk 0 = T2k (f ) und definiere rekursiv
1
Tki = Tk ,i−1 + (Tk ,i−1 − Tk −1,i−1 ), i = 1, . . . , m und k = i, . . . , m .
4i − 1
Dann ist Tmk für Polynome P ∈ P2k +1 exakt.
Z √2−1
1 π
Beispiel: Approximiere dt =
0 1 + t2 8
Neville-Schema zur Extrapolation von Tk 0 = T2k +3
T00 = 0.392564202887866
T10 = 0.392665370185121 T11 = 0.392699092617539
T20 = 0.392690654331774 T21 = 0.392699082380658 T22 = 0.392699081698199
T30 = 0.392696974888946 T31 = 0.392699081741337 T32 = 0.392699081698716 T33 = 0.392699081698724
Konvergenzabschätzung durch Vergleich von Trapezsummen

T10 − T00 = 0.00010116730
T20 − T10 = 0.00002528415 T21 − T11 = −0.0000000102368817
T30 − T20 = 0.00000632056 T31 − T21 = −0.0000000006393204
Fehler
T00 − π = −0.000134878810858
8
T10 − π = −0.000033711513603 T − π = 1.0918815e − 8
8 11 8
T20 − π = −0.000008427366950 T − π = 0.0681934e − 8 T − π = −5.2519100e − 13
8 21 8 22 8
T30 − π = −0.000002106809778 T − π = 0.0042613e − 8 T − π = −0.0816014e − 13 T − π = 5.5511151e − 17
8 31 8 32 8 33 8
11 Numerische Integration von Differentialgleichungen
(11.1) Sei t0 ∈ R und T > 0. Zu einem Anfangswert u0 ∈ RM und f ∈ C([t0 , t0 + T ] × RM , RM ) suchen
wir eine Lösung u ∈ C1 ([t0 , t0 + T ], RM ) der Anfangswertaufgabe

u̇(t) = f t, u(t) für t ∈ [t0 , t0 + T ] und dem Anfangswert u(t0 ) = u0 .
(11.2) Wenn L > 0 existiert

mit |f (t, w) − f (t,
z)| ≤ L |w − z|, dann gilt für zwei Lösungen
u̇(t) = f t, u(t) und v̇ (t) = f t, v (t)

|u(t) − v (t)| ≤ exp(L(t − t0 )) u(t0 ) − v (t0 ) für t ≥ t0 .
Daher ist die Lösung der Anfangswertaufgabe eindeutig.
(11.3) Klassisches Runge-Kutta-Verfahren: Sei tn = t0 + nτ, u 0 = u0 und setze
k1 = f (tn−1 , u n−1 )
τ τ
k2 = f (tn−1 + , u n−1 + k1 )
2 2
τ τ
k3 = f (tn−1 + , u n−1 + k2 )
2 2
k4 = f (tn−1 + τ, u n−1 + τk3 )
τ
u n = u0n−1 + (k1 + 2k2 + 2k3 + k4 ) .
6
Dann gilt |u(tn ) − u n | ≤ C exp(L(tn − t0 )) τ 4 .
(11.3) Implizites Euler-Verfahren: In jedem Schritt bestimme u n als Lösung der nichtlinearen
Gleichung u n = u n−1 + τf (tn , u n ). Dann gilt |u(tn ) − u n | ≤ C exp(L(tn − t0 )) τ.
11 Simulation: Radioaktiver Zerfall u̇ = −λ u
N explizites Eulerverfahren implizites Eulerverfahren Mittelpunktsregel
u n = u n−1 + τf (u n−1 ) u n = u n−1 + τf (u n ) u n = u n−2 + 2τf (u n−1 )
4 0.46711 0.52770 0.51266

8 0.48431 0.51440 0.50323
16 0.49233 0.50735 0.50081
32 0.49621 0.50371 0.50020
64 0.49811 0.50187 0.50005
∞ 0.50000 0.50000 0.50000
O(1/N) O(1/N) O(1/N 2 )
Table: Vergleich der Konvergenzordnung |u(tn ) − un | = O(N −β ) = O(hN ) im Zeitintervall [0, 5730].
β
N =5 N = 100
Figure: Stabilität der numerischen Approximation. Vergleich im Zeitintervall [0, 57300] für N = 5, 100.

Folien (Zusammenfassung)

Hochgeladen von

Dokumentinformationen

Copyright

Verfügbare Formate

Dieses Dokument teilen

Dokument teilen oder einbetten

Freigabeoptionen

Stufen Sie dieses Dokument als nützlich ein?

Sind diese Inhalte unangemessen?

Copyright:

Verfügbare Formate

Folien (Zusammenfassung)

Hochgeladen von

Copyright:

Verfügbare Formate

1 Arithmetische Grundlagen

Am 4. Juni 1996 explodierte kurz nach dem Start die

(1.3) Sei f : RN −→ RK eine differenzierbare Funktion und x ∈ RN . Dann heißt

|Ax| ≤ kAk |x| , x ∈ RN , A ∈ RM×N .

mit Spekralradius ρ(A) = max{|λ | : λ Eigenwert von A}.

Sei b ∈ RN , b 6= 0N , 4b ∈ RN eine kleine Störung und b̃ = b + 4b.

(2.6) Sei A ∈ RN×N symmetrisch und positiv definit.

Software: www.netlib.org/lapack www.mathworks.com www.python.org

def forward_sub(lower, rhs):

def backward_sub(upper, rhs):

def solve_with_lu(matrix, rhs):

def forward_sub(lower, rhs):

def backward_sub(upper, rhs):

def solve_with_cholesky(matrix, rhs):

solution = solve_with_lu(matrix, rhs)

rhs = np.array([1.0, 2.0])

solution = solve_with_cholesky(matrix, rhs)

die Einträge einer Matrix. Dabei ist ek ∈ RN der k -te Einheitsvektor.

Rotationen und Spiegelungen Q sind orthogonale Matrizen, d.h.

% Berechnung der Restmatrix

function [v,beta] = householder(y)

(3.2) Zu A ∈ RK ×N existieren Singulärwerte σ1 , ..., σR > 0 und eine Singulärwertzerlegung

(3.4) x = A+ b löst die Normalengleichung A> Ax = A> b.

(3.5) Sei A ∈ RK ×N und b ∈ RK .

(3.6) Es gilt lim (A> A + αIN )−1 A> b = A+ b.

Die exakte Lösung lautet:

(Beispiel aus Kress: Numerical Analysis)

(Beispiel aus Kress: Numerical Analysis)

(4.3) Sei A ∈ RN×N symmetrisch, tridiagonal, und irreduzibel, d.h.

(4.4) Inverse Iteration mit variablem Shift

S3) Berechne QR-Zerlegung

Es gilt Ak +1 = Qk> Ak Qk . Also haben Ak +1 und Ak disselben Eigenwerte.

Sei A = L + D + R. Dann gilt B = D −1 für das Jacobi-Verfahren

Liste von Software ascend4.org/Survey_of_sparse_matrix_software

S2) Setzte k := k + 1 und gehe zu S1).

Dann ist v 1 , ..., v k eine Orthonormalbasis von dem Krylov-Raum

S2) Berechne y k ∈ Rk mit ρk = |Hk y k − h10 e1 |2 = min!

S4) Setze k := k + 1 und gehe zu S1).

(4.4) Es gilt ρk = min |B(b − Az)|2 .

(7.2) Hermite-Interpolation Zu ξ0 ≤ · · · ≤ ξN definiere en = max{n − k : ξk = · · · = ξn }, m = max en .

(8.2) Es gilt dim S3 (Ξ) = 3 + N. Mit einer der Randbedingungen

(8.3) Die Momente µn = S 00 (ξn ) von S ∈ S3 (Ξ) zu f sind eindeutig durch

mit TN (ξn ) = fn für n = 0, ..., N − 1. Es gilt

Für s-mal stetig differenzierbare Funktionen konvergieren die Koeffizienten ck gegen

(10.4) Für die summierte Trapezregel

Konvergenzabschätzung durch Vergleich von Trapezsummen

(11.2) Wenn L > 0 existiert

4 0.46711 0.52770 0.51266

Das könnte Ihnen auch gefallen