[NumCS] Compile

semester3/numcs/numcs-summary.tex

@@ -154,7 +154,13 @@ Moral of the story: Use descriptive variable names and do NOT use $t$, $tt$, $tt
 \input{parts/03_zeros/02_fix-point-iteration.tex}
 \input{parts/03_zeros/03_bisection-method.tex}
 \input{parts/03_zeros/04_newton-one-d.tex}
+\input{parts/03_zeros/05_sectant-method.tex}
+\input{parts/03_zeros/06_newton-nd.tex}
+\input{parts/03_zeros/07_damped-newton.tex}
+\input{parts/03_zeros/08_quasi-newton.tex}
 
-
+\newsection
+\section{Intermezzo: Lineare Algebra}
+\input{parts/04_linalg/00_intro.tex}
 
 \end{document}

semester3/numcs/parts/03_zeros/03_bisection-method.tex

@@ -9,4 +9,5 @@ Der Code ist jedoch (at the time of writing) nicht ausführbar aufgrund von \tex
 
 Das Bisektionsverfahren konvergiert linear und kann nur für Funktionen verwenden, bei welchen die Nullstellen auf beiden Seiten jeweils ungleiche Vorzeichen haben.
 
-% TODO: Need to add the formula from SPAM script
+Für jeden Iterationsschritt ermitteln wir die Mitte des Intervalls und berechnen die Funktionswerte an den Rändern, wie auch dem Mittelpunkt.
+Dann ersetzen wir den Rand des Intervalls, dessen Funktionswert dasselbe Vorzeichen hat, wie der Funktionswert des Mittelpunkts.

semester3/numcs/parts/03_zeros/04_newton-one-d.tex

@@ -1,2 +1,17 @@
 \newsectionNoPB
 \subsection{Newtonverfahren in 1D}
+Beim Newtonverfahren verwendet man für jeden Iterationsschritt die lineare Funktion $\tilde{F} = F(x^(k)) + F'(x^{(k)})(x - x^{(k)})$. Die Nullstelle ist dann:
+\rmvspace
+\begin{align*}
+    x^{(k + 1)} := x^{(k)} - \frac{F(x^{(k)})}{F'(x^{(k)})}, \mediumhspace \text{falls } F'(x^{(k)}) \neq 0
+\end{align*}
+
+\stepLabelNumber{all}
+\inlineremark Die Newton-Iteration ist eine Fixpunktiteration mit quadratischer lokaler Konvergenz, mit
+\rmvspace
+\begin{align*}
+    \phi(x) = x - \frac{F(x)}{F'(x)} \Longrightarrow \phi'(x) = \frac{F(x) F''(x)}{(F'(x))^2} \Longrightarrow \phi'(x^*) = 0
+\end{align*}
+
+\drmvspace
+falls $F(x^*) = 0$ und $F^(x^*) \neq 0$

semester3/numcs/parts/03_zeros/05_sectant-method.tex

@@ -0,0 +1,8 @@
+\newsectionNoPB
+\subsection{Sekantenverfahren}
+Falls die Ableitung zu teuer oder nicht verfügbar ist, kann man sie durch $q^(k) := \frac{F(x^{(k)}) - F(x^{(k - 1)})}{x^{(k)} - x^{(k - 1)}}$.
+Dann ist ein Schritt:
+\rmvspace
+\begin{align*}
+    \tilde{F}(x) = F(x^{(k)}) + q^{(k)} (x - x^{(k)}) \Longrightarrow x^{(k + 1)} := x^{(k)} - \frac{F(x^{(k)})}{q^{(k)}}, \smallhspace \text{ falls } q^{(k)} \neq 0
+\end{align*}

semester3/numcs/parts/03_zeros/06_newton-nd.tex

@@ -0,0 +1,36 @@
+\newsectionNoPB
+\subsection{Newton-Verfahren in $n$ Dimensionen}
+Sei $D \subseteq \R^n$ und $F: D \rightarrow \R^n$ stetig differenzierbar. Die Nullstelle ist
+\rmvspace
+\begin{align*}
+    x^{(k + 1)} := x^{(k)} - DF(x^{(k)})^{-1} F(x^{(k)})
+\end{align*}
+
+\drmvspace
+wobei $DF(x^{(k)}) =
+    \begin{bmatrix}
+        \frac{\partial F_j}{\partial x_k} (x)
+    \end{bmatrix}_{j, k = 1, 2, \ldots, n}$ die Jacobi-Matrix von $F$ ist.
+
+Wichtig ist dabei, dass wir \bi{niemals} das Inverse der Jacobi-Matrix (oder irgend einer anderen Matrix) von der Form $s = A^{-1} b$,
+sondern immer das Gleichungssystem $As = b$ lösen sollten, da dies effizienter ist:
+
+\begin{code}{python}
+def newton(x, F, DF, tol=1e-12, maxit=50):
+    x = np.atleast_2d(x)  # ’solve’ erwartet x als 2-dimensionaler numpy array
+    # Newton Iteration
+    for _ in range(maxit):
+        s = np.linal.solve(DF(x), F(x))
+        x -= s
+        if np.linalgnorm(s) < tol * np.linalg.norm(x):
+            return x
+\end{code}
+
+Wollen wir aber garantiert einen Fehler kleiner als unsere Toleranz $\tau$ können wir das Abbruchkriterium
+\rmvspace
+\begin{align*}
+    ||DF(x^{(k - 1)})^{-1}F(x^{(k)})|| \leq \tau
+\end{align*}
+
+\drmvspace
+verwenden. Code, welcher dies implementiert findet sich auf Seite 213-216 im Skript.

semester3/numcs/parts/03_zeros/07_damped-newton.tex

@@ -0,0 +1,16 @@
+\newsection
+\subsection{Gedämpftes Newton-Verfahren}
+Wir wenden einen einen Dämpfungsfaktor $\lambda^{(k)}$ an, welcher heuristisch gewählt wird:
+\rmvspace
+\begin{align*}
+    x^{(k + 1)} := x^{(k)} - \lambda^{(k)}DF(x^{(k)})^{-1} F(x^{(k)})
+\end{align*}
+
+\drmvspace
+Wir wählen $\lambda^{(k)}$ so, dass für $\Delta x^{(k)} = DF(x^{(k)})^{-1} F(x^{(k)})$ und $\Delta(\lambda^{(k)}) = DF(x^{(k)})^{-1} F(x^{(k)} - \lambda^{(k)} \Delta x^{(k)})$
+\rmvspace
+\begin{align*}
+    ||\Delta x(\lambda^{(k)})||_2 \leq \left( 1 - \frac{\lambda^{(k)}}{2} \right) ||\Delta x^{(k)}||_2
+\end{align*}
+
+\drmvspace

semester3/numcs/parts/03_zeros/08_quasi-newton.tex

@@ -0,0 +1,13 @@
+\newsectionNoPB
+\subsection{Quasi-Newton-Verfahren}
+Falls $DF(x)$ zu teuer ist oder nicht zur Verfügung steht, können wir im Eindimensionalen das Sekantenverfahren verwenden.
+
+Im höherdimensionalen Raum ist dies jedoch nicht direkt möglich und wir erhalten die Broyden-Quasi-Newton Methode:
+\rmvspace
+\begin{align*}
+    J_{k + 1} := J_k + \frac{F(x^{(k + 1)}) (\Delta x^{(k)})^\top}{||\Delta x^{(k)}||_2^2}
+\end{align*}
+
+\drmvspace
+Dabei ist $J_0$ z.B. durch $DF(x^{(0)})$ definiert.
+% Page 222

semester3/numcs/parts/04_linalg/00_intro.tex

@@ -0,0 +1,44 @@
+Das Skript-Kapitel hierzu existiert nicht. Die Vorlesung orientiert sich an dem äquivalenten Teil des NumCSE Dokuments.
+
+\textbf{Perturbierte LGS}
+
+Statt $Ax = b$ ist das LGS ungenau gegeben: $(A + \Delta A)(\tilde{x} - x) = \Delta b - \Delta Ax$.
+
+$\text{cond}(A) := \left\lvert\left\lvert A^{-1} \right\rvert\right\rvert \cdot \lvert\lvert A \rvert\rvert \in \mathbb{R}$ (Konditionszahl von $A$)
+
+$\text{cond}(A) \gg 1$ bedeutet intuitiv: kleine Änderung der Daten $\mapsto$ grosse Änderung in der Lösung
+
+\textbf{Gauss Elimination / LU Zerlegung}
+
+$A \in \mathbb{R}^{n\times m} = PLU$ wie bekannt.
+
+\textbf{Cholesky Zerlegung} ($A$ pos. def. und hermitesch)
+
+$A = LDL^\top = \underbrace{L\sqrt{D}}_{R^\top}\underbrace{\sqrt{D}L^\top}_{R} = R^\top R$
+
+Kann $Ax = b$ potenziell schneller lösen als LU.
+
+\begin{code}{python}
+    L = np.linalg.solve(A)      # A = L @ L.T
+    y = np.linalg.solve(L, b)
+    x = np.linalg.solve(L.T, y)
+\end{code}
+
+\textbf{Grosse Matrizen}
+
+Passen oft nicht (direkt) in den Speicher: effizientere Speicherung nötig, möglich für z.B. Diagonalmatrizen, Dreiecksmatrizen. Auch für Cholesky möglich.
+
+\textbf{Dünnbesetzte Matrizen}
+
+$\text{nnz}(A) := |\{ (i,j) \ |\ a_{ij} \in A, a_{ij} \neq 0 \}| \ll m\cdot n$
+
+$\underset{l \to \infty}{\lim} \frac{\text{nnz}(A^{(l)})}{n_l m_l} = 0$
+
+Einfacher zu speichern: \verb|val, col, row| vektoren s.d. \verb|val[k]| $ = a_{ij}$ wobei $i=$ \verb|row[k]|, $j=$ \verb|col[k]|. (nur $a_{ij} \neq 0$)
+
+Viele Formate, je nach Anwendung gewisse sinnvoller als andere. (Siehe Tabelle, NumCSE)
+
+\verb|scipy.sparse.csr_matrix(A)| $\mapsto$ Dramatische Speichereinsparung.\\
+Deprecated: \verb|bsr_array| und \verb|coo_array| verwenden, kompatibel mit \verb|numpy| arrays.
+
+\verb|CSC, CSR| erlauben weitere Optimierungen, je nach Gewichtung der $a_{ij}$ auf Zeilen, Spalten.