[NumCS] Start FFT

semester3/numcs/numcs-summary.tex

@@ -5,6 +5,7 @@
 \load{full}
 
 \usepackage{lmodern}
+% \usepackage{pgfplots}
 \setFontType{sans}
 
 \renewcommand{\authorTitle}{Robin Bacher, Janis Hutz\\\url{https://github.com/janishutz/eth-summaries}}

semester3/numcs/parts/01_interpolation/01_trigonometric/00_fourier.tex

@@ -126,3 +126,27 @@ wobei $l = 0, 1 \ldots, N - 1$ und $N$ die Anzahl der Intervalle ist:
 \begin{align*}
     \hat{f}_N(k) := \frac{1}{N} \sum_{l = 0}^{N - 1} f(t_l) e^{-2\pi ikt_l} \approx \hat{f}(k)
 \end{align*}
+
+% TODO: Consider if we should use the below
+
+% \begin{tikzpicture}
+%     \begin{axis}[
+%         legend pos=outer north east,
+%         title=Function plot of $f(x)$ (parts coloured),
+%         axis lines = box,
+%         xlabel = $x$,
+%         ylabel = $y$,
+%         variable = t,
+%         trig format plots = rad,
+%     ]
+%         \addplot [
+%             domain=1:4,
+%             samples=70,
+%             color=blue,
+%         ]
+%         {log2(x)};
+%         \addlegendentry{$ y=x^2 - x - 0.5$}
+%     \end{axis}
+%     \node (0) at (0, 0) {};
+% \end{tikzpicture}
+

semester3/numcs/parts/01_interpolation/01_trigonometric/02_fft.tex

@@ -1,2 +1,38 @@
 \newsection
 \subsection{Schnelle Fourier Transformation}
+Da es viele Anwendungen für die Fourier-Transformation gibt, ist ein Algorithmus mit guter Laufzeit sehr wichtig.
+Während eine naive version des DFT-Algorithmus eine Laufzeit von $\tco{N^2}$ hat,
+so hat der Fast Fourier Transform Algorithmus nur eine Laufzeit von $\tco{N \log(N)}$,
+was bei $N = 1024$ bereits eine Laufzeitsverbesserung von $100\times$ mit sich bringt ($\tco{10\,000}$ vs $\tco{1\,000\,000}$ Operationen)!
+Die untenstehende Abbildung \ref{fig:trigo-interp-fft-runtimes} findet sich, zusammen mit dem Code,
+mit der sie produziert wurde im Skript auf Seite 86-88
+
+\begin{figure}[h!]
+    \begin{center}
+        \includegraphics[width=0.7\textwidth]{assets/01_interpolation/01_trigonometric/fft-runtimes.png}
+    \end{center}
+    \caption{Vergleich der Laufzeit von verschiedenen Fourier-Transformations-Algorithmen}
+    \label{fig:trigo-interp-fft-runtimes}
+\end{figure}
+
+Der hier besprochene Cooley-Tukey-Algorithmus wurde ursprünglich von Gauss 1805 entdeckt, dann vergessen und schliesslich 1965 von Cooley und Tukey wiederentdeckt.
+Der Algorithmus verwendet einen ``Divide and Conquer'' Approach, also ist logischerweise die Idee,
+dass man die Berechnung einer DFT der Länge $n$ auf die Berechnung vieler DFTs kleinerer Längen zurückführen kann.
+
+Für den Algorithmus müssen folgende vier Optionen betrachtet werden:
+\begin{enumerate}[label=\Roman*]
+    \item Vektoren der Länge $N = 2m \Longrightarrow$ Laufzeit ideal
+    \item Vektoren der Länge $N = 2^L \Longrightarrow$ Laufzeit ideal
+    \item Vektoren der Länge $N = pq$ mit $p, q \in \Z \Longrightarrow$ Etwas langsamer
+    \item Vektoren der Länge $N$, mit $N$ prim $\Longrightarrow$ ca. $\tco{N^2}$, besonders für $N$ gross
+\end{enumerate}
+Wir formen die Fourier-Transformation um für den ersten Fall ($N = 2m$):
+\begin{align*}
+    c_k & = \sum_{j = 0}^{N - 1} y_j e^{- \frac{2\pi i}{N} jk}                                                                     \\
+        & = \sum_{j = 0}^{m - 1} y_{2j} e^{-\frac{2 \pi i}{N}2jk} + \sum_{j = 0}^{m - 1} y_{2j + 1} e^{-\frac{2\pi i}{N}(2j + 1)k} \\
+        & = \sum_{j = 0}^{m - 1} \left( y_{2j} e^{-\frac{2 \pi i}{N \div 2}jk} \right)
+    + e^{- \frac{2\pi}{N} k} \left( \sum_{j = 0}^{m - 1} y_{2j + 1} e^{-\frac{2\pi i}{N \div 2}jk} \right)
+\end{align*}
+Der zweite Fall ist einfach eine rekursive Weiterführung des ersten Falls,
+bei welchem dann das $m$ kontinuierlich weiter dividiert wird bis zum Trivialfall mit einer $1 \times 1$-Matrix.
+