747 lines
20 KiB
Markdown
747 lines
20 KiB
Markdown
<style>
|
|
.formula, .letters {
|
|
margin-top: 2px;
|
|
margin-bottom: 2px;
|
|
color: black;
|
|
padding: 0.5rem;
|
|
padding-bottom: 1px;
|
|
}
|
|
|
|
.formula p:last-child, .letters p:last-child {
|
|
padding-bottom: 0;
|
|
}
|
|
|
|
.formula {
|
|
background: lightblue;
|
|
}
|
|
|
|
.letters {
|
|
background: lightyellow;
|
|
}
|
|
</style>
|
|
|
|
# Höhere Mathematik
|
|
## Inhalt
|
|
- [Höhere Mathematik](#höhere-mathematik)
|
|
- [Inhalt](#inhalt)
|
|
- [Einführung](#einführung)
|
|
- [Einsatzgebiet](#einsatzgebiet)
|
|
- [Arten von Lösungen](#arten-von-lösungen)
|
|
- [Verbindung zur Informatik](#verbindung-zur-informatik)
|
|
- [Typische Fragestellungen](#typische-fragestellungen)
|
|
- [Rechnerarithmetik](#rechnerarithmetik)
|
|
- [Maschinenzahl](#maschinenzahl)
|
|
- [Grenzen von Maschinenzahlen](#grenzen-von-maschinenzahlen)
|
|
- [Datentypen gem. IEEE](#datentypen-gem-ieee)
|
|
- [Rundungsfehler und Maschinengenauigkeit](#rundungsfehler-und-maschinengenauigkeit)
|
|
- [Konditionszahl](#konditionszahl)
|
|
- [Nullstellenprobleme](#nullstellenprobleme)
|
|
- [Problemstellung und Ansatz](#problemstellung-und-ansatz)
|
|
- [Fixpunktiteration](#fixpunktiteration)
|
|
- [Banachscher Fixpunktsatz](#banachscher-fixpunktsatz)
|
|
- [Newton-Verfahren](#newton-verfahren)
|
|
- [Sekantenverfahren](#sekantenverfahren)
|
|
- [Konvergenz-Ordnung](#konvergenz-ordnung)
|
|
- [Fehlerabschätzung](#fehlerabschätzung)
|
|
- [Formelbuchstaben zu Nullstellenproblem](#formelbuchstaben-zu-nullstellenproblem)
|
|
- [Lineare Gleichungssysteme](#lineare-gleichungssysteme)
|
|
- [Lernziele](#lernziele)
|
|
- [Eigenschaften](#eigenschaften)
|
|
- [Dreiecks-Matrizen](#dreiecks-matrizen)
|
|
- [Der Gauss-Algorithmus](#der-gauss-algorithmus)
|
|
- [Fehlerfortpflanzung und Pivotisierung](#fehlerfortpflanzung-und-pivotisierung)
|
|
- [Determinanten-Bestimmung](#determinanten-bestimmung)
|
|
- [Die $LR$-Zerlegung](#die-lr-zerlegung)
|
|
- [Formelbuchstaben](#formelbuchstaben)
|
|
- [Glossar](#glossar)
|
|
|
|
## Einführung
|
|
### Einsatzgebiet
|
|
- Annähern komplexer Formeln in endlicher Zeit
|
|
- Berechnung von Algorithmen durch Computer
|
|
- Algorithmen ohne expliziter Lösungsdarstellung
|
|
- Alternative Lösungsvorgänge für höhere Performance
|
|
|
|
### Arten von Lösungen
|
|
- Direkte Verfahren - Exakte Lösung nach endlicher Zeit
|
|
- Näherungsverfahren/Iteratives Verfahren - Approximation nach begrenzter Anzahl Rechenschritte
|
|
|
|
### Verbindung zur Informatik
|
|
- Effiziente Berechnung numerischer Algorithmen
|
|
- Speicherung und Darstellung von Zahlen
|
|
- Computergrafik & Bildverarbeitung
|
|
- Neuronale Netze
|
|
|
|
### Typische Fragestellungen
|
|
- Wie wirkt sich die Beschränkung der Anzahl Bits für Zahlenformate auf Rechenergebnisse und Rechengenauigkeit aus?
|
|
- Numerische Lösung von Nullstellenproblemen
|
|
- Numerische Integration
|
|
|
|
## Rechnerarithmetik
|
|
### Maschinenzahl
|
|
Maschinenzahlen werden als Zahlen $x$ in folgender Form dargestellt:
|
|
|
|
$x = m \cdot B^e$
|
|
|
|
- $x$: Die zu repräsentierende Zahl
|
|
- $m$: Die Mantisse (der darstellbare Zahlenwert)
|
|
- $B$: Die Basis der zu repräsentierenden Zahl
|
|
- $e$: Der Exponent (der Stellenwert der Mantisse $m$)
|
|
|
|
Beispiel:
|
|
$1337 = 0.1337 * 10^4$
|
|
|
|
Maschinenzahlen sind normalisiert, wenn
|
|
- für die Mantisse $m$ $0.1 <= |m| < 1.0$ zutrifft
|
|
|
|
Maschinenzahlen werden normalisiert, damit es zu jedem Wert eine eindeutige Darstellung als Maschinenzahl gibt.
|
|
|
|
### Grenzen von Maschinenzahlen
|
|
<div class="formula">
|
|
|
|
$x_{max} = B^{e_{max}} - B^{e_{max}-n} = (1 - B^{-n}) \cdot B^{e_{max}}$
|
|
|
|
$x_min = B^{e_{min} - 1}$
|
|
|
|
</div>
|
|
|
|
### Datentypen gem. IEEE
|
|
`float` oder `single`: 32 Bit - 1 Bit für Vorzeichen, 23 Bit für Mantisse $m$, 8 Bit für Exponent $e$
|
|
|
|
`double`: 64 Bit - 1 Bit für Vorzeichen, 52 für Mantisse $m$, 11 Bit für Exponent $e$
|
|
|
|
### Rundungsfehler und Maschinengenauigkeit
|
|
<div class="formula">
|
|
|
|
Absoluter Fehler:
|
|
|
|
$$|\tilde{x} - x|$$
|
|
|
|
</div>
|
|
<div class="formula">
|
|
|
|
Relativer Fehler:
|
|
|
|
$$\frac{|\tilde{x} - x|}{|x|}$$
|
|
|
|
</div>
|
|
<div class="formula">
|
|
|
|
|
|
Maximaler **absoluter** Rundungsfehler:
|
|
|
|
$$\frac{B}{2} \cdot B^{e - n - 1}$$
|
|
|
|
</div>
|
|
<div class="formula">
|
|
|
|
**Maschinengenauigkeit** oder maximaler **relativer** Rundungsfehler:
|
|
|
|
$$\frac{1}{2} \cdot B^{1 - n}$$
|
|
|
|
</div>
|
|
<div class="formula">
|
|
|
|
Fehlerfortpflanzung bei Funktionsauswertung:
|
|
|
|
Relativ:
|
|
|
|
$$\frac{f'(x) \cdot x}{f(x)} \cdot \frac{\tilde{x} - x}{x}$$
|
|
|
|
Absolut:
|
|
|
|
$$|f'(x)| \cdot |\tilde{x} - x|$$
|
|
|
|
</div>
|
|
<div class="letters">
|
|
|
|
- $B$: Die Basis der Maschinenzahl
|
|
- $e$: Der Exponent der Maschinenzahl (Standard-Wert: $0$)
|
|
- $n$: Die Anzahl Stellen der Mantisse $m$
|
|
- $x$: Der darzustellende Wert
|
|
- $\tilde{x}$: Die Annäherung/Approximation an $x$
|
|
- $f$: Auszuwertende Funktion
|
|
|
|
</div>
|
|
|
|
### Konditionszahl
|
|
Die Konditionszahl gibt an, wie gross der potenzielle relative Fehler einer numerischen Lösung ist.
|
|
|
|
Eine niedrige Konditionszahl ($K \le 1$) bedeutet einen niedrigen Fehler, eine hohe Konditionszahl ein grosses Fehlerrisiko.
|
|
|
|
Formel:
|
|
|
|
<div class="formula">
|
|
|
|
Konditionszahl:
|
|
|
|
$$K = \frac{|f'(x)| \cdot |x|}{|f(x)|}$$
|
|
|
|
</div>
|
|
|
|
## Nullstellenprobleme
|
|
### Problemstellung und Ansatz
|
|
Es wird der korrekte Wert $x$ für eine Aufgabe gesucht.
|
|
|
|
1. Aufgabe ausformulieren:
|
|
$x = \sqrt{A}$
|
|
2. Aufgabe zu Nullstellenproblem umformulieren (Funktion, die bei gesuchtem $x$ immer $0$ ergibt):
|
|
$f(x) = x^2 - A$
|
|
3. (Algorithmisch) richtiges $x$ finden, bei dem die Funktion $0$ ergibt
|
|
4. Das gefundene $x$ ist die Lösung
|
|
|
|
> ***Note:***
|
|
> Als Ausgangsbedingung für eine numerische Lösung eines Nullstellenproblems können diverse Bedingungen verwendet werden wie etwa:
|
|
> - Eine bestimmte Anzahl Iterationen
|
|
> - Abstand zwischen $x_n$ und $x_{n + 1}$ unterschreitet Threshold (approximiertes Resultat)
|
|
> - Ein niedriger Threshold ergibt ein genaueres Resultat
|
|
> - Ein Threshold von $0$ ergibt das genaue Resultat
|
|
|
|
### Fixpunktiteration
|
|
|
|
|
|
|
|
Ein möglicher Ansatz für ein solches Problem ist eine Fixpunktiteration.
|
|
|
|
Der Vorgang für eine solche ist folgende:
|
|
|
|
1. Die Funktion in die Form $F(x) = x$.
|
|
Beispiel für $f(x) = x^2 - A$:
|
|
$F(x) = \sqrt{A}$
|
|
2. Beliebigen Wert für $x_0$ wählen (vorzugsweise Wert in Nähe von erwarteter Lösung)
|
|
3. Fixpunktiteration $x_{n + 1}$ berechnen:
|
|
$x_{n+1} = F(x_n)$
|
|
|
|
Dies wird durchgeführt bis die Ausgangsbedingung erfüllt ist.
|
|
|
|
***Code-Beispiel:***
|
|
```py
|
|
import math
|
|
|
|
threshold = 10 ** -6
|
|
|
|
def f(x): # Funktion f in Nullstellenform
|
|
return math.cos(x) - x
|
|
|
|
def F(x): # Funktion f in Fixpunktform
|
|
return math.cos(x)
|
|
|
|
def F_(x): # Die Ableitung F'(x)
|
|
return return -math.sin(x)
|
|
|
|
x = 0.75 # Startwert - angenommene, etwaige Lösung
|
|
|
|
if F_(x) >= 1:
|
|
print("Fehler: Fixpunktiteration divergiert!")
|
|
else:
|
|
while math.abs(x - F(x)) >= threshold:
|
|
x = F(x)
|
|
|
|
print(f"Approximierte Lösung: {x}")
|
|
```
|
|
|
|
<div class="formula">
|
|
|
|
**Konvergenz**
|
|
|
|
Eine Fixpunktiteration is konvergent (also berechenbar), wenn folgendes zutrifft:
|
|
|
|
$$|F'(\tilde{x})| < 1$$
|
|
|
|
</div>
|
|
<div class="formula">
|
|
|
|
**Divergenz**
|
|
|
|
Eine Fixpunktiteration is divergent (also unberechenbar), wenn folgendes zutrifft:
|
|
|
|
$$|F'(\tilde{x})| \ge 1$$
|
|
|
|
</div>
|
|
<div class="letters">
|
|
|
|
- $F(x)$: Die Fixpunktgleichung
|
|
- $F'(x)$: Die Ableitung der Fixpunktgleichung
|
|
- $x$: Das genaue Resultat für $x$
|
|
- $\tilde{x}$: Das approximierte Resultat für $x$ (Fixpunkt)
|
|
- $x_n$: Die $n$-te Approximation für $x$
|
|
|
|
</div>
|
|
|
|
#### Banachscher Fixpunktsatz
|
|
Der Fixpunktsatz dient dazu, abzuschätzen, wie gross der Fehler des Ergebnisses einer Fixpunktiteration in etwa ist.
|
|
|
|
<div class="formula">
|
|
|
|
Fixpunktsatz:
|
|
|
|
$$|F(x) - F(y)| \le \alpha \cdot |x - y| \text{für alle }x,y \in [a, b]$$
|
|
|
|
Alternative Umformung:
|
|
|
|
$$\frac{|F(x) - F(y)|}{|x - y|} \le \alpha$$
|
|
|
|
</div>
|
|
|
|
<div class="formula">
|
|
|
|
**Fehlerabschätzung:**
|
|
|
|
a-priori Abschätzung:
|
|
|
|
$$|x_n - \tilde{x}| \le \frac{\alpha^n}{1 - \alpha} \cdot |x_1 - x_0|$$
|
|
|
|
a-posteriori Abschätzung:
|
|
|
|
$$|x_n - \tilde{x}| \le \frac{\alpha}{1 - \alpha} \cdot |x_n - x_{n - 1}|$$
|
|
|
|
</div>
|
|
|
|
<div class="formula">
|
|
|
|
Konstante $\alpha$:
|
|
|
|
$$\alpha = \max_{x_0 \in [a, b]}| F'(x_0)|$$
|
|
|
|
$$\alpha \approx |F'(\tilde{x})|$$
|
|
|
|
</div>
|
|
|
|
Folgendermassen kann dieser aufgestellt werden:
|
|
|
|
> ***Note:***
|
|
> In dieser Passage wird sowohl $a$ (der Buchstabe "a") als auch $\alpha$ (Alpha) verwendet. Diese haben hier eine unterschiedliche Bedeutung.
|
|
|
|
1. Start- und Endpunkt $a$ und $b$ auswählen, welche genau einen Fixpunkt $\tilde{x}$ beinhalten
|
|
2. Prüfen, ob folgendes Zutrifft: Alle Ergebnisse von $F([a, b])$ befinden sich im Intervall $[a, b]$
|
|
3. Konstante $\alpha$ berechnen (gem. Formel)
|
|
4. Die a-priori und die a-posteriori Abschätzung kann nun beliebig angewendet werden. Hierbei wird für $x_0$ der Wert $a$ verwendet.
|
|
|
|
### Newton-Verfahren
|
|
|
|
|
|
|
|
Das Newton-Verfahren erreicht die Konvergenz (d.h. das (approximierte) Resultat) um einiges schneller.
|
|
|
|
Hierfür wird die Funktion $f$ in der Nullstellenform benötigt ($f(x) = \text{[...]} = 0$).
|
|
|
|
<div class="formula">
|
|
|
|
Newton-Verfahren:
|
|
|
|
$$x_{n + 1} = x_n - \frac{f(x_n)}{f'(x_n)}$$
|
|
|
|
</div>
|
|
<div class="formula">
|
|
|
|
Vereinfachtes Newton-Verfahren:
|
|
|
|
$$x_{n + 1} = x_n - \frac{f(x_n)}{f'(x_0)}$$
|
|
|
|
</div>
|
|
<div class="formula">
|
|
|
|
Konvergenz-Kontrolle:
|
|
|
|
$$\left|\frac{f(x) \cdot f''(x)}{(f'(x))^2}\right| < 1$$
|
|
|
|
Das Ergebnis ist wahr, wenn mit dem gewählten $x$ eine Konvergenz erreicht werden kann.
|
|
|
|
</div>
|
|
|
|
1. Startpunkt $x_0$ in der Nähe einer Nullstelle wählen
|
|
2. (Wahlweise vereinfachtes) Newton-Verfahren anwenden bis $x_n$ und $x_{n + 1}$ bis Ausgangsbedingung erreicht wird
|
|
|
|
### Sekantenverfahren
|
|
|
|
|
|
|
|
<div class="formula">
|
|
|
|
$$x_{n + 1} = x_n - \frac{x_n - x_{n - 1}}{f(x_n) - f(x_{n - 1})} \cdot f(x_n)$$
|
|
|
|
</div>
|
|
|
|
Vorgang:
|
|
|
|
1. Startpunkte $x_0$ und $x_1$ wählen (Punkte, die eine Nullstelle umschliessen)
|
|
2. Iteration durchführen, bis Ausgangsbedingung erfüllt wird
|
|
|
|
### Konvergenz-Ordnung
|
|
|
|
<div class="formula">
|
|
|
|
Ein Verfahren hat eine Konvergenz-Ordnung $q \ge 1$, wenn es eine Konstante $c > 0$ für die für alle $n$ Iterations-Schritte gilt:
|
|
|
|
$$|x_{n + 1} - \tilde{x}| \le c \cdot |x_n - \tilde{x}|^q$$
|
|
|
|
</div>
|
|
<div class="letters">
|
|
|
|
- $c$: Beliebige Konstante
|
|
- $q$: Konvergenz-Ordnung
|
|
- Für Newton-Verfahren: $q = 2$
|
|
- Für vereinfachtes Newton-Verfahren: $q = 1$
|
|
- Für Sekanten-Verfahren: $1 = (1 + \sqrt{5}) : 2 \approx 1.618$
|
|
|
|
</div>
|
|
|
|
### Fehlerabschätzung
|
|
|
|
<div class="formula">
|
|
|
|
Wenn folgendes zutrifft:
|
|
|
|
$$f(x_n - \varepsilon) \cdot f(x_n + \varepsilon) < 0$$
|
|
|
|
Schneidet $f$ zwischen $x_n - \varepsilon$ und $x_n + \varepsilon$ die Nullstelle.
|
|
|
|
Deswegen gilt folgendes:
|
|
|
|
$$|x_n - \xi| < \varepsilon$$
|
|
|
|
Sprich: Der Fehler ist kleiner als $\varepsilon$.
|
|
|
|
</div>
|
|
|
|
Vorgang:
|
|
|
|
- $\varepsilon$ suchen, für die oben genannte Bedingung zutrifft
|
|
- Der maximale Fehler ist $\varepsilon$
|
|
|
|
<div class="letters">
|
|
|
|
- $x_n$: Der approximierte $x$-Wert nach der $n$-ten Iteration
|
|
- $\varepsilon$: Der maximale Fehler
|
|
- $\xi$: Der Schnittpunkt der Nullstelle
|
|
|
|
</div>
|
|
|
|
### Formelbuchstaben zu Nullstellenproblem
|
|
|
|
<div class="letters">
|
|
|
|
- $\alpha$: Lipschitz-Konstante
|
|
- $[a, b]$: Der
|
|
- $F(x)$: Die Fixpunktgleichung
|
|
- $F'(x)$: Die Ableitung der Fixpunktgleichung
|
|
- $x$ und $y$: Beliebig gewählte Punkte im Interval $[a,b]$
|
|
- $\tilde{x}$: Das approximierte Resultat für $x$ (Fixpunkt)
|
|
- $x_n$ Die $n$-te Approximation von $x$
|
|
|
|
</div>
|
|
|
|
## Lineare Gleichungssysteme
|
|
### Lernziele
|
|
- Sie können...
|
|
- [ ] Lineare Gleichungssysteme aufstellen
|
|
- [ ] den Gauss-Algorithmus mit und ohne Pivotisierung
|
|
- [ ] die LR-Zerlegung
|
|
- [ ] die QR-Zerlegung
|
|
- [ ] Jacobi-Verfahren (in Python)
|
|
- [ ] Gauss-Seidel-Verfahren (in Python)
|
|
- [ ] Fehlerabschätzungen
|
|
- [ ] Eigenwerte und Eigenvektoren von Matrizen berechnen
|
|
|
|
<div class="letters">
|
|
|
|
**Lineares Gleichungssystem:**
|
|
|
|
Lineare Gleichungssysteme haben jeweils die Form $A \cdot x = b$ wobei $A$ und $b$ gegeben und $x$ gesucht ist:
|
|
|
|
$$A = \left(
|
|
\begin{matrix}
|
|
a_{11} & a_{12} & \cdots & a_{1n} \\
|
|
a_{21} & a_{22} & \cdots & a_{2n} \\
|
|
\vdots & \vdots & & \vdots \\
|
|
a_{n1} & a_{n2} & \cdots & a_{nn}
|
|
\end{matrix}
|
|
\right),
|
|
x = \left(
|
|
\begin{matrix}
|
|
x_1 \\
|
|
x_2 \\
|
|
\vdots \\
|
|
x_n
|
|
\end{matrix}
|
|
\right),
|
|
b = \left(
|
|
\begin{matrix}
|
|
b_1 \\
|
|
b_2 \\
|
|
\vdots \\
|
|
b_n
|
|
\end{matrix}
|
|
\right)$$
|
|
|
|
</div>
|
|
|
|
### Eigenschaften
|
|
- Gleich viele gesuchte Variablen $x_n$ wie Gleichungen $n$. Folglich:
|
|
- Die Matrix $A$ ist eine quadratische Matrix mit Dimensionen $n \times n$
|
|
- $A$ ist invertierbar
|
|
- $A$ hat eine Determinante $\det(A)$
|
|
|
|
### Dreiecks-Matrizen
|
|
|
|
<div class="letters">
|
|
|
|
***$L$: Untere Dreiecksmatrix***
|
|
|
|
Eine Matrix, die in der oberen rechten Ecke nur den Wert $0$ und auf der Diagonale nur den Wert $1$ hat. Eine Untere Dreiecksmatrix hat also folgende Form:
|
|
|
|
$$L = \left(
|
|
\begin{matrix}
|
|
1 & 0 & 0 & \cdots & 0 \\
|
|
l_{21} & 1 & 0 & \cdots & 0 \\
|
|
l_{31} & l_{32} & 1 & \ddots & 0 \\
|
|
\vdots & \vdots & \ddots & \ddots & 0 \\
|
|
l_{n1} & l_{n2} & \cdots & l_{nn - 1} & 1
|
|
\end{matrix}
|
|
\right)$$
|
|
|
|
***$R$: Obere Dreiecksmatrix***
|
|
|
|
Eine Matrix, die unten links von der Diagonale nur den Wert $0$ beinhaltet. Eine Obere Dreiecksmatrix hat dementsprechend folgende Form:
|
|
|
|
$$R = \left(
|
|
\begin{matrix}
|
|
r_{11} & r_{12} & r_{13} & \cdots & r_{1n} \\
|
|
0 & r_{22} & r_{23} & \cdots & r_{2n} \\
|
|
0 & 0 & r_{33} & \cdots & r_{3n} \\
|
|
\vdots & \vdots & \ddots & \ddots & \vdots \\
|
|
0 & 0 & \cdots & 0 & r_{nn}
|
|
\end{matrix}
|
|
\right)$$
|
|
|
|
</div>
|
|
|
|
***Code-Beispiele:***
|
|
|
|
_Umwandlung in $R$-Matrix:_
|
|
|
|
```py
|
|
for i in range(n):
|
|
if A[i, i] == 0:
|
|
index = -1
|
|
for j in range(i + 1, n):
|
|
if A[j, i] > 0:
|
|
index = j
|
|
if index == -1:
|
|
raise Exception("Invalid Matrix")
|
|
else:
|
|
# Swap lines
|
|
A[[i, index]] = A[[index, i]]
|
|
for j in range(i + 1, n):
|
|
factor = A[j, i] / A[i, i]
|
|
A[j] = A[j] - (factor * A[i])
|
|
```
|
|
|
|
### Der Gauss-Algorithmus
|
|
Der Gauss-Algorithmus basiert darauf, dass ein lineares Gleichungssystem leicht lösbar ist, falls $A$ eine obere Dreiecksmatrix ist. $A$ muss also hierfür die Form einer oberen Dreiecksmatrix $R$ haben.
|
|
|
|
<div class="formula">
|
|
|
|
***Gauss-Algorithmus:***
|
|
|
|
$$x_i = \frac{b_i - \sum_{j = i + 1}^n{a_{ij} \cdot x_j}}{a_{ii}}, i = n, n - 1, \dots, 1$$
|
|
|
|
</div>
|
|
|
|
Um den Gauss-Algorithmus anzuwenden, muss die Matrix $A$ erst in eine $R$-Matrix umgewandelt werden. Dies funktioniert wie folgt:
|
|
|
|
1. Mit $i$ von $1$ bis $n$
|
|
2. Falls $a_{ii}$ den Wert $0$ hat:
|
|
1. Mit $j$ von $i + 1$ bis $n$
|
|
2. Prüfen, ob $a_{ji}$ einen höheren Wert als $0$ hat
|
|
- Falls Zeile gefunden wurde:
|
|
- $a_{i}$ mit $a_{j}$ tauschen
|
|
- $b_{i}$ mit $b_{j}$ tauschen
|
|
- Sonst beenden: ungültige Matrix
|
|
3. Mit $j$ von $i + 1$ bis $n$
|
|
1. $a_k = a_k - \frac{a_{ki}}{a_{ii}} \cdot a_i$
|
|
2. $b_k = b_k - \frac{a_{ki}}{a_{ii}} \cdot b_i$
|
|
|
|
***Code-Beispiel:***
|
|
|
|
```py
|
|
from numpy import array, zeros
|
|
|
|
def gaussMethod(A, b):
|
|
A = array(A)
|
|
n = A.shape[0]
|
|
A = A.reshape((n, n))
|
|
b = array(b).reshape((n))
|
|
result = zeros(n)
|
|
|
|
# Convert to R-Matrix
|
|
for i in range(n):
|
|
maxIndex = i
|
|
for j in range(i + 1, n):
|
|
if A[j, i] > A[maxIndex, i]:
|
|
maxIndex = j
|
|
# Swap lines
|
|
A[[i, maxIndex]] = A[[maxIndex, i]]
|
|
b[[i, maxIndex]] = b[[maxIndex, i]]
|
|
for j in range(i + 1, n):
|
|
factor = A[j, i] / A[i, i]
|
|
A[j] = A[j] - (factor * A[i])
|
|
b[j] = b[j] - (factor * b[i])
|
|
# Calculate result
|
|
for index in range(n, 0, -1):
|
|
i = index - 1
|
|
value = b[i]
|
|
for j in range(i, n):
|
|
value = value - A[i, j] * result[j]
|
|
result[i] = value / A[i, i]
|
|
return result.reshape((n, 1))
|
|
```
|
|
|
|
### Fehlerfortpflanzung und Pivotisierung
|
|
- Da beim Umwandeln einer Matrix $A$ in die $R$-Form Zeilen in jedem Schritt mit dem Faktor $\lambda = \frac{a_{ji}}{a_{ii}}$ multipliziert werden, vergrössert sich der Schritt immer um $|\lambda|$
|
|
- $\lambda$ kann klein gehalten werden, indem Zeilen der Grösse nach sortiert werden
|
|
- In den Code-Beispielen ist dies bereits berücksichtigt
|
|
|
|
### Determinanten-Bestimmung
|
|
Die Determinante einer Matrix $A$ lässt sich einfach berechnen, sobald sie in die $R$-Form gebracht wurde mit folgender Formel:
|
|
|
|
<div class="formula">
|
|
|
|
Determinanten-Bestimmung mit Matrix $\tilde{A}$ (die Matrix $A$ in der $R$-Form):
|
|
|
|
$$\det(A) =
|
|
(-1)^l \cdot \det(\tilde{A}) =
|
|
(-1)^l \cdot \prod_{i = 1}^n{\tilde{a_{ii}}}$$
|
|
|
|
</div>
|
|
|
|
***Code-Beispiel:***
|
|
|
|
```py
|
|
from numpy import array
|
|
|
|
def det(A):
|
|
l = 0
|
|
n = A.shape[0]
|
|
A = A.reshape((n, n))
|
|
|
|
# Convert to R-Matrix
|
|
for i in range(n):
|
|
maxIndex = i
|
|
for j in range(i + 1, n):
|
|
if A[j, i] > A[maxIndex, i]:
|
|
maxIndex = j
|
|
# Swap lines
|
|
A[[i, maxIndex]] = A[[maxIndex, i]]
|
|
l = l + 1
|
|
for j in range(i + 1, n):
|
|
factor = A[j, i] / A[i, i]
|
|
A[j] = A[j] - (factor * A[i])
|
|
|
|
result = 1
|
|
for i in range(n):
|
|
result = result * A[i, i]
|
|
return (-1 ** l) * result
|
|
```
|
|
|
|
### Die $LR$-Zerlegung
|
|
In der $LR$-Zerlegung wird die Matrix $A$ in die Matrizen $L$ und $R$ aufgeteilt, sodass $A = L \cdot R$ gilt.
|
|
|
|
Alternative Namen dieses Vorgangs sind ***$LR$-Faktorisierung*** und $LU$-decomposition.
|
|
|
|
<div class="formula">
|
|
|
|
Für in $L$ und $R$ zerlegte Matrizen gilt:
|
|
|
|
$$A \cdot x = b$$
|
|
|
|
und
|
|
|
|
$$A \cdot x = L \cdot R \cdot x = L \cdot y = b$$
|
|
|
|
Aufwand: Berechnung der $LR$-Zerlegung mit Gauss-Algorithmus benötigt ca. $\frac{2}{3}n^3$ Punktoperationen.
|
|
|
|
</div>
|
|
|
|
Falls Zeilenvertauschungen stattfinden, entsteht bei der $LR$-Zerlegung eine zusätzliche Permutations-Matrix $P$.
|
|
|
|
<div class="formula">
|
|
|
|
Für $L$ und $R$ zerlegte Matrizen mit Permutation $P$ gilt:
|
|
|
|
$$P \cdot A = L \cdot R$$
|
|
|
|
$$L \cdot y = P \cdot b$$
|
|
|
|
$$R \cdot x = y$$
|
|
|
|
</div>
|
|
|
|
Das Verfahren für die $LR$-Zerlegung ist identisch zu den Schritten bei der Umwandlung in eine $R$-Matrix. Jedoch wird jeweils der Wert $l_{ji}$ in der (zu Beginn) leeren Matrix $L$ mit dem im aktuellen Eliminationsschritt gesetzt. Zudem muss bei Vertauschungen die Permutations-Matrix $P$ entsprechend angepasst werden:
|
|
|
|
***Code-Beispiel:***
|
|
|
|
```py
|
|
from numpy import array, identity, zeros
|
|
|
|
def decomposite(A):
|
|
l = 0
|
|
n = A.shape[0]
|
|
R = A.reshape((n, n))
|
|
L = zeros((n, n))
|
|
P = identity((n, n))
|
|
|
|
# Convert to LR-Matrix
|
|
for i in range(n):
|
|
maxIndex = i
|
|
for j in range(i + 1, n):
|
|
if A[j, i] > A[maxIndex, i]:
|
|
maxIndex = j
|
|
# Swap lines
|
|
Pn = identity((n, n))
|
|
A[[i, maxIndex]] = A[[maxIndex, i]]
|
|
Pn[[i, maxIndex]] = Pn[[maxIndex, i]]
|
|
P = P * Pn
|
|
for j in range(i + 1, n):
|
|
factor = R[j, i] / R[i, i]
|
|
L[j, i] = factor
|
|
R[j] = R[j] - (factor * R[i])
|
|
|
|
result = 1
|
|
for i in range(n):
|
|
result = result * R[i, i]
|
|
return [L, R, P]
|
|
```
|
|
|
|
Wenn die $LR$-Zerlegung, wie in diesem Code, Zeilenaustausch und das Berechnen von $P$ involviert, spricht man von einer $LR$-Zerlegung mit **Spaltenmaximum-Strategie**.
|
|
|
|
***Vorgang:***
|
|
|
|
1. Gemäss vorhergehender Beschreibung und Code-Beispiel die Matrizen $L$ und $R$ berechnen
|
|
2. Mit Hilfe des Gauss-Algorithmus $L \cdot y = P \cdot b$ nach $y$ auflösen
|
|
3. Mit Hilfe des Gauss-Algorithmus $R \cdot x = y$ nach $x$ auflösen
|
|
|
|
## Formelbuchstaben
|
|
<div class="letters">
|
|
|
|
- $\alpha$: Lipschitz-Konstante (siehe Fixpunktsatz)
|
|
- $[a,b]$: Das Untersuchungs-Interval für den Banachschen Fixpunktsatz
|
|
- $A$: Matrix eines linearen Gleichungssystems
|
|
- $\tilde{A}$: Umgewandelte Version der Matrix $A$
|
|
- $b$: Das gewünschte Resultat eines linearen Gleichungssystems
|
|
- $B$: Basis der Maschinenzahl
|
|
- $e$: Exponent der Maschinenzahl
|
|
- $K$: Konditionszahl
|
|
- $L$: Untere Dreiecksmatrix/Normierte Matrix
|
|
- $m$: Mantisse (Darstellbarer Bereich der Maschinenzahl)
|
|
- $n$: Anzahl möglicher Stellen der Mantisse $m$
|
|
- $q$: Konvergenz-Ordnung
|
|
- $R$: Obere Dreiecksmatrix
|
|
- $x$: Darzustellender Wert
|
|
- $x_n$: Die $n$-te Approximation von $x$
|
|
- $\tilde{x}$: Approximation/Annäherung an $x$
|
|
|
|
</div>
|
|
|
|
## Glossar
|