Add chapters about gauss and $LU$-decomposition

This commit is contained in:
Manuel Thalmann 2023-01-11 01:15:03 +01:00
parent 5f4cc5e678
commit 5965f0e783

View file

@ -46,6 +46,12 @@
- [Formelbuchstaben zu Nullstellenproblem](#formelbuchstaben-zu-nullstellenproblem) - [Formelbuchstaben zu Nullstellenproblem](#formelbuchstaben-zu-nullstellenproblem)
- [Lineare Gleichungssysteme](#lineare-gleichungssysteme) - [Lineare Gleichungssysteme](#lineare-gleichungssysteme)
- [Lernziele](#lernziele) - [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) - [Formelbuchstaben](#formelbuchstaben)
- [Glossar](#glossar) - [Glossar](#glossar)
@ -58,7 +64,7 @@
### Arten von Lösungen ### Arten von Lösungen
- Direkte Verfahren - Exakte Lösung nach endlicher Zeit - Direkte Verfahren - Exakte Lösung nach endlicher Zeit
- Näherungsverfahren - Approximation nach begrenzter Anzahl Rechenschritte - Näherungsverfahren/Iteratives Verfahren - Approximation nach begrenzter Anzahl Rechenschritte
### Verbindung zur Informatik ### Verbindung zur Informatik
- Effiziente Berechnung numerischer Algorithmen - Effiziente Berechnung numerischer Algorithmen
@ -437,17 +443,300 @@ Vorgang:
- [ ] Fehlerabschätzungen - [ ] Fehlerabschätzungen
- [ ] Eigenwerte und Eigenvektoren von Matrizen berechnen - [ ] 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 ## Formelbuchstaben
<div class="letters"> <div class="letters">
- $\alpha$: Lipschitz-Konstante (siehe Fixpunktsatz) - $\alpha$: Lipschitz-Konstante (siehe Fixpunktsatz)
- $[a,b]$: Das Untersuchungs-Interval für den Banachschen 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 - $B$: Basis der Maschinenzahl
- $e$: Exponent der Maschinenzahl - $e$: Exponent der Maschinenzahl
- $K$: Konditionszahl - $K$: Konditionszahl
- $L$: Untere Dreiecksmatrix/Normierte Matrix
- $m$: Mantisse (Darstellbarer Bereich der Maschinenzahl) - $m$: Mantisse (Darstellbarer Bereich der Maschinenzahl)
- $n$: Anzahl möglicher Stellen der Mantisse $m$ - $n$: Anzahl möglicher Stellen der Mantisse $m$
- $q$: Konvergenz-Ordnung - $q$: Konvergenz-Ordnung
- $R$: Obere Dreiecksmatrix
- $x$: Darzustellender Wert - $x$: Darzustellender Wert
- $x_n$: Die $n$-te Approximation von $x$ - $x_n$: Die $n$-te Approximation von $x$
- $\tilde{x}$: Approximation/Annäherung an $x$ - $\tilde{x}$: Approximation/Annäherung an $x$