[NumCS] Fix typos and layout

semester3/numcs/parts/01_interpolation/00_polynomial/00_intro.tex

@@ -12,12 +12,13 @@ Die $x_i$ heissen Stützstellen/Knoten, für welche $\tilde{f}(x_i) = y_i$ gelte
 	\quad x_i, y_i \in \mathbb{R}
 \end{align*}
 
-Normalerweise stellt $f$ eine echte Messung dar, d.h. macht es Sinn anzunehmen dass $f$ glatt ist.
+Normalerweise stellt $f$ eine echte Messung dar, d.h. es macht Sinn anzunehmen dass $f$ glatt ist.
 
 Die informelle Problemstellung oben lässt sich durch Vektorräume formalisieren:
 
-$f \in \mathcal{V}$, wobei $\mathcal{V}$ ein Vektorraum mit $\dim(\mathcal{V}) = \infty$ ist. \\
+$f \in \mathcal{V}$, wobei $\mathcal{V}$ ein Vektorraum mit $\dim(\mathcal{V}) = \infty$ ist.
-Wir suchen d.h. $\tilde{f}$ in einem Unterraum $\mathcal{V}_n$ mit endlicher $\dim(\mathcal{V}_n) = n$.
+
+Wir suchen also $\tilde{f}$ in einem Unterraum $\mathcal{V}_n$ mit endlicher $\dim(\mathcal{V}_n) = n$.
 Sei $B_n = \{b_1,\ldots,b_n\}$ eine Basis für $\mathcal{V}_n$.
 Dann lässt sich der Bezug zwischen $f$ und $\tilde{f} = f_n(x)$ so ausdrücken:
 \begin{align*}
@@ -26,7 +27,7 @@ Dann lässt sich der Bezug zwischen $f$ und $\tilde{f} = f_n(x)$ so ausdrücken:
 
 \setLabelNumber{all}{1}
 \inlineremark Unterräume $\mathcal{V}_n$ existieren nicht nur für Polynome, wir beschränken uns aber auf $b_j(x) = x^{i-1}$.
-Andere Möglichkeiten: $b_j = \cos((j-1)\cos^-1(x))$ \textit{(Chebyshev)} oder $b_j = e^{i2\pi j x}$ \textit{(Trigonometrisch)}
+Andere Möglichkeiten: $b_j = \cos((j-1)\cos^{-1}(x))$ \textit{(Chebyshev)} oder $b_j = e^{i2\pi j x}$ \textit{(Trigonometrisch)}
 
 \fancytheorem{Peano} $f$ stetig $\implies \exists p(x)$ welches $f$ in $||\cdot||_\infty$ beliebig gut approximiert.
 

semester3/numcs/parts/01_interpolation/00_polynomial/03_lagrange-and-barzycentric-formula.tex

@@ -52,35 +52,35 @@ Man berechnet die baryzentrischen Gewichte $\lambda_k$ folgendermassen:
 oder das ganze mithilfe von Numpy:
 \begin{code}{python}
     def barycentric_weights(x: np.ndarray) -> np.ndarray:
-    n = len(x)
+        n = len(x)
-    # Initialize to zeros
+        # Initialize to zeros
-    barweight = np.ones(n)
+        barweight = np.ones(n)
-    for k in range(n):
+        for k in range(n):
-    # Vectorized differences between $x_k$ and all $x$s
+            # Vectorized differences between $x_k$ and all $x$s
-    differences = x[k] - x
+            differences = x[k] - x
-    # Remove the $k$-th element (and handle edge cases for $k = 0$ and $k = n - 1$)
+            # Remove the $k$-th element (and handle edge cases for $k = 0$ and $k = n - 1$)
-    if k < n - 1 and k > 0:
+            if k < n - 1 and k > 0:
-    diff_processed = np.concatenate((differences[:k], differences[(k + 1) :]))
+                diff_processed = np.concatenate((differences[:k], differences[(k + 1) :]))
-    barweight[k] = 1 / np.prod(diff_processed)
+                barweight[k] = 1 / np.prod(diff_processed)
-    elif k == 0:
+            elif k == 0:
-    barweight[k] = 1 / np.prod(differences[1:])
+                barweight[k] = 1 / np.prod(differences[1:])
-    else:
+            else:
-    barweight[k] = 1 / np.prod(differences[:k])
+                barweight[k] = 1 / np.prod(differences[:k])
-    return barweight
+        return barweight
 \end{code}
 
 Gleiche funktion, etwas kürzer:
 
 \begin{code}{python}
     def barycentric_weights(x: np.ndarray) -> np.ndarray:
-    n = len(x)
+        n = len(x)
-    w = np.ones(n) # = barweight
+        w = np.ones(n) # = barweight
-    # Compute the (non-inverted) product, avoiding case (x[i] - x[i]) = 0
+        # Compute the (non-inverted) product, avoiding case (x[i] - x[i]) = 0
-    for i in range(0, n, 1):
+        for i in range(0, n, 1):
-    if (i-1 > 0): w[0:(i-1)] *= (x[0:(i-1)] - x[i])
+            if (i-1 > 0): w[0:(i-1)] *= (x[0:(i-1)] - x[i])
-    if (i+1 < n): w[i+1:n]   *= (x[i+1:n]   - x[i])
+            if (i+1 < n): w[i+1:n]   *= (x[i+1:n]   - x[i])
-    # Invert all at once
+        # Invert all at once
-    return 1/w
+        return 1/w
 \end{code}
 
 Mit dem können wir dann ein Polynom mit der baryzentrischen Interpolationsformel interpolieren:
@@ -102,32 +102,33 @@ Eine weitere Anwendung der Formel ist als Ausganspunkt für die Spektralmethode
 
 \begin{code}{python}
     def interp_barycentric(
-    data_point_x: np.ndarray,
+        data_point_x: np.ndarray,
-    data_point_y: np.ndarray,
+        data_point_y: np.ndarray,
-    barweight: np.ndarray,
+        barweight: np.ndarray,
-    x: np.ndarray
+        x: np.ndarray
     ):
-    p_x = np.zeros_like(x)
+        p_x = np.zeros_like(x)
-    n = data_point_x.shape[0]
+        n = data_point_x.shape[0]
 
-    for i in range(x.shape[0]):
+        for i in range(x.shape[0]):
-    # Separate sums to divide in the end
+            # Separate sums to divide in the end
-    upper_sum = 0
+            upper_sum = 0
-    lower_sum = 0
+            lower_sum = 0
-    for k in range(n):
+            for k in range(n):
-    frac = barweight[k] / (x[i] - data_point_x[k])
+                frac = barweight[k] / (x[i] - data_point_x[k])
-    upper_sum += frac * data_point_y[k]
+                upper_sum += frac * data_point_y[k]
-    lower_sum += frac
+                lower_sum += frac
-    p_x[i] = upper_sum / lower_sum
+            p_x[i] = upper_sum / lower_sum
 
-    return p_x
+        return p_x
 \end{code}
 
 
 % ────────────────────────────────────────────────────────────────────
 \newpage
 \subsubsection{Fehler}
-Falls an den Stützstellen $x_i$ durch beispielsweise ungenaue Messungen unpräzise Werte $\tilde{y_i}$ haben, so entsteht logischerweise auch ein unpräzises Polynom $\tilde{p}(x)$.
+Falls wir an den Stützstellen $x_i$ durch beispielsweise ungenaue Messungen unpräzise Werte $\tilde{y_i}$ haben,
+so entsteht logischerweise auch ein unpräzises Polynom $\tilde{p}(x)$.
 Verglichen in der Lagrange-Basis zum korrekten Interpolationspolynom $p(x)$ ergibt sich folgender Fehler:
 \begin{align*}
     |p(x) - \tilde{p}(x)| = \left| \sum_{i = 0}^{n} (y_i - \tilde{y_i}) l_i(x) \right| \leq \max_{i = 0, \ldots, n} |y_i - \tilde{y_i}| \cdot \sum_{i = 0}^{n} |l_i(x)|

semester3/numcs/parts/01_interpolation/01_trigonometric/01_dft/02_fftshift.tex

@@ -1,8 +1,8 @@
 \subsubsection{DFT in Numpy}
 
-Sei $y$ in der Standardbasis, und $c = \mathcal{F}_N(y)$, also $y$ in der trig. Basis.
+Sei $y$ in der Standardbasis, und $c = \mathcal{F}_N(y)$, also $y$ in der trigonometrischen Basis.
 \begin{align*}
-    c = F_N \times y = \texttt{fft}(y)\quad \text{\textit{(DFT in numpy)}} & y = \frac{1}{N}F_N^Hc = \texttt{ifft}(c)\quad \textit{(Inverse DFT in numpy)}
+    c = F_N \times y = \texttt{fft}(y)\quad \text{\textit{(DFT in numpy)}} & & y = \frac{1}{N}F_N^Hc = \texttt{ifft}(c)\quad \textit{(Inverse DFT in numpy)}
 \end{align*}
 
 Um zur ursprünglichen Darstellung des trig. Polynoms zurück zu kommen, müssen wir die Koeffizienten umsortieren: \\

semester3/numcs/parts/01_interpolation/01_trigonometric/04_error-estimation.tex

@@ -93,6 +93,7 @@ wie in der untenstehenden Abbildung \ref{fig:aliasing} zu sehen:
     \caption{Aliasing für $f(t) = \cos(2\pi \cdot 19t)$. (Abbildung 3.5.10 aus dem Vorlesungsdokument von Prof. V. Gradinaru, Seite 100)}
     \label{fig:aliasing}
 \end{figure}
+
 Für unser Signal bedeutet das also, dass wir eine Art Verzerrung auf der Aufnahme haben, oder für Autoräder, dass es so scheint, als würden sich die Räder rückwärts drehen.
 
 \begin{theorem}[]{Fehlerabschätzung}

semester3/numcs/parts/01_interpolation/01_trigonometric/05_dft-chebyshev.tex

@@ -47,7 +47,7 @@ Auf Seite 102 im Skript findet sich auch eine effiziente Implementation dessen.
 \inlineremark Die Formel in Satz 2.4.16 (und in der eben erwähnten Implementierung) sind nichts anderes als eine Version der DCT (Discrete Cosine Transform).
 Dies ist eine günstigere, aber beschränktere Variante der DFT, mit der nur reellwertige, gerade Funktionen interpoliert werden können.
 
-\innumpy benutzen wir \texttt{scipy.fft.dct}. Dazu müssen die Mesungen in den Punkten $x_j = \cos\left( (j + 0.5) \cdot \frac{\pi}{N} \right)$
+\innumpy benutzen wir \texttt{scipy.fft.dct}. Dazu müssen die Mesungen in den Punkten $x_j = \cos\left( (j + 0.5) \cdot \frac{\pi}{N} \right)$ sein.
 
 \inlineremark Die Chebyshev-Koeffizienten $c_j$ können folgendermassen berechnet werden:
 \rmvspace