Merge branch 'master' of raven.am28.uni-tuebingen.de:scientificComputing

plotting/lecture/Makefile

@@ -0,0 +1,70 @@
+BASENAME=plotting
+
+PYFILES=$(wildcard *.py)
+PYPDFFILES=$(PYFILES:.py=.pdf)
+
+GPTFILES=$(wildcard *.gpt)
+GPTTEXFILES=$(GPTFILES:.gpt=.tex)
+
+
+all: pdf slides thumbs
+
+# script:
+pdf : $(BASENAME)-chapter.pdf
+$(BASENAME)-chapter.pdf : $(BASENAME)-chapter.tex $(BASENAME).tex $(GPTTEXFILES) $(PYPDFFILES)
+	pdflatex -interaction=scrollmode $< | tee /dev/stderr | fgrep -q "Rerun to get cross-references right" && pdflatex -interaction=scrollmode $< || true
+
+
+# slides:
+slides: $(BASENAME)-slides.pdf
+$(BASENAME)-slides.pdf : $(BASENAME)-slides.tex $(GPTTEXFILES) $(PYPDFFILES)
+	pdflatex -interaction=scrollmode $< | tee /dev/stderr | fgrep -q "Rerun to get cross-references right" && pdflatex -interaction=scrollmode $< || true
+
+# thumbnails:
+thumbs: $(BASENAME)-handout.pdf
+$(BASENAME)-handout.pdf: $(BASENAME)-slides.tex $(GPTTEXFILES)
+	sed -e 's/setboolean{presentation}{true}/setboolean{presentation}{false}/; s/usepackage{crop}/usepackage[frame]{crop}/' $< > thumbsfoils.tex
+	pdflatex thumbsfoils | tee /dev/stderr | fgrep -q "Rerun to get cross-references right" && pdflatex thumbsfoils || true
+	pdfnup --nup 2x4 --no-landscape --paper a4paper --trim "-1cm -1cm -1cm -1cm" --outfile $@ thumbsfoils.pdf # 1-19
+	rm thumbsfoils.*
+
+watchpdf :
+	while true; do ! make -q pdf && make pdf; sleep 0.5; done
+
+watchslides :
+	while true; do ! make -q slides && make slides; sleep 0.5; done
+
+# python plots:
+$(PYPDFFILES) : %.pdf: %.py
+	python $<
+
+# gnuplot plots:
+$(GPTTEXFILES) : %.tex: %.gpt whitestyles.gp
+	gnuplot whitestyles.gp $<
+	epstopdf $*.eps
+
+
+clean :
+	rm -f *~ 
+	rm -f $(BASENAME).aux $(BASENAME).log
+	rm -f $(BASENAME)-chapter.aux $(BASENAME)-chapter.log $(BASENAME)-chapter.out
+	rm -f $(BASENAME)-slides.aux $(BASENAME)-slides.log $(BASENAME)-slides.out $(BASENAME)-slides.toc $(BASENAME)-slides.nav $(BASENAME)-slides.snm $(BASENAME)-slides.vrb
+	rm -f $(PYPDFFILES) $(GPTTEXFILES)
+
+cleanall : clean
+	rm -f $(BASENAME)-chapter.pdf $(BASENAME)-slides.pdf $(BASENAME)-handout.pdf
+
+
+help : 
+	@echo -e \
+	"make pdf:        make the pdf file of the script.\n"\
+	"make slides:     make the pdf file of the slides.\n"\
+	"make thumbs:     make color thumbnails of the talk.\n"\
+	"make watchpdf:   make the pdf file of the script\n"\
+        "                 whenever the tex file is modified.\n"\
+	"make watchpdf:   make the pdf file of the slides\n"\
+        "                 whenever the tex file is modified.\n"\
+	"make clean:      remove all intermediate files,\n"\
+        "                 just leave the source files and the final .pdf files.\n"\
+	"make cleanup:    remove all intermediate files as well as\n"\
+        "                 the final .pdf files.\n"\

plotting/lecture/beamercolorthemetuebingen.sty

@@ -0,0 +1,61 @@
+% Copyright 2007 by Till Tantau
+%
+% This file may be distributed and/or modified
+%
+% 1. under the LaTeX Project Public License and/or
+% 2. under the GNU Public License.
+%
+% See the file doc/licenses/LICENSE for more details.
+
+\usepackage{color} 
+\definecolor{karminrot}{RGB}{165,30,55}
+\definecolor{gold}{RGB}{180,160,105}
+\definecolor{anthrazit}{RGB}{50 ,65 ,75 }
+
+\mode<presentation>
+
+\setbeamercolor*{normal text}{fg=anthrazit,bg=white}
+\setbeamercolor*{alerted text}{fg=anthrazit}
+\setbeamercolor*{example text}{fg=anthrazit}
+\setbeamercolor*{structure}{fg=gold,bg=karminrot}
+
+\providecommand*{\beamer@bftext@only}{%
+  \relax
+  \ifmmode
+    \expandafter\beamer@bftext@warning
+  \else
+    \expandafter\bfseries
+  \fi
+}
+\providecommand*{\beamer@bftext@warning}{%
+  \ClassWarning{beamer}
+    {Cannot use bold for alerted text in math mode}%
+}
+
+\setbeamerfont{alerted text}{series=\beamer@bftext@only}
+
+\setbeamercolor{palette primary}{fg=karminrot,bg=white}
+\setbeamercolor{palette secondary}{fg=gold,bg=white}
+\setbeamercolor{palette tertiary}{fg=anthrazit,bg=white}
+\setbeamercolor{palette quaternary}{fg=black,bg=white}
+
+\setbeamercolor{sidebar}{bg=karminrot!100}
+
+\setbeamercolor{palette sidebar primary}{fg=karminrot}
+\setbeamercolor{palette sidebar secondary}{fg=karminrot}
+\setbeamercolor{palette sidebar tertiary}{fg=karminrot}
+\setbeamercolor{palette sidebar quaternary}{fg=karminrot}
+
+\setbeamercolor{item projected}{fg=black,bg=black!20}
+
+\setbeamercolor*{block body}{}
+\setbeamercolor*{block body alerted}{}
+\setbeamercolor*{block body example}{}
+\setbeamercolor*{block title}{parent=structure}
+\setbeamercolor*{block title alerted}{parent=alerted text}
+\setbeamercolor*{block title example}{parent=example text}
+
+\setbeamercolor*{titlelike}{parent=structure}
+
+\mode
+<all>

plotting/lecture/plotting-chapter.tex

@@ -0,0 +1,17 @@
+\documentclass[12pt]{report}
+
+\input{../../header}
+
+\lstset{inputpath=../code}
+
+\graphicspath{{images/}}
+
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\begin{document} 
+
+\include{psth_sta}
+
+\end{document}
+

plotting/lecture/plotting.tex

@@ -0,0 +1,11 @@
+\chapter{\tr{Data plotting}{Graphische Darstellung von Daten}}
+
+\section{Graphische Darstellung von Daten}
+
+
+
+\begin{figure}
+  \includegraphics[width=0.9\columnwidth]{convincing}
+  \caption{Die Folgen schlecht annotierter
+    Plots. \url{www.xkcd.com}} \label{xkcdplotting}
+\end{figure}

programming/code/facultyLoop.m

@@ -0,0 +1,6 @@
+n = 5;
+x = 1;
+for i = 1:n
+	  x = x * i;
+end 
+fprintf('Faculty of %i is: %i\n', n, x)

programming/code/facultyLoop.out

@@ -0,0 +1,2 @@
+>> facultyLoop
+Faculty of 5 is: 120

programming/code/facultyWhileLoop.m

@@ -0,0 +1,7 @@
+n = 5;
+counter = 1;
+x = 1;
+while counter <= n
+    x = x * counter;
+end
+fprintf('Faculty of %i is: %i\n', n, x)

programming/code/ifelse.m

@@ -0,0 +1,20 @@
+x = rand(1); % eine einzelne Zufallszahl
+if x < 0.5
+    disp('x is less than 0.5');
+end
+
+
+if x < 0.5
+    disp('x is less than 0.5!');
+else
+    disp('x is greater than or equal to 0.5!')
+end
+
+
+if x < 0.5
+    disp('x is less than 0.5!');
+elseif x < 0.75
+    disp('x is greater than 0.5 but less than 0.75!');
+else
+    disp('x is greater than or equal to 0.75!')
+end

programming/code/logicalIndexingBenchmark.m

@@ -1,7 +1,7 @@
-% create a vector with a random numbers
+% create a vector with random numbers
 x = rand(1000000, 1);
 
-fprintf('time needed to manually filter elements smaller than 0.5 in a vector of length %i\n', length(x))
+fprintf('Time needed to manually filter out elements smaller than 0.5 in a vector of length %i\n', length(x))
 
 tic
 results = [];
@@ -14,7 +14,7 @@ for i = 1:length(x)
 end
 toc
 
-fprintf('\ntime needed to do the same with logical indexing\n')
+fprintf('\nTime needed to do the same with logical indexing\n')
 
 tic
 results = x(x < 0.5);

programming/code/logicalIndexingBenchmark.out

@@ -1,6 +1,6 @@
 >> logicalIndexingBenchmark
-time needed to manually filter elements smaller than 0.5 in a vector of length 100000
+Time needed to manually filter elements smaller than 0.5 in a vector of length 100000
 Elapsed time is 0.008562 seconds.
 
-time needed to do the same with logical indexing
+Time needed to do the same with logical indexing
 Elapsed time is 0.001543 seconds.

programming/code/neverendingWhile.m

@@ -0,0 +1,6 @@
+i = 1;
+while true % this is always true
+    disp(x);
+    x = x * i;
+    i = i + 1;
+end

programming/code/simplerandomwalk.m

@@ -0,0 +1,26 @@
+num_runs = 10;
+max_steps = 1000;
+
+positions = zeros(max_steps, num_runs);
+
+for run = 1:num_runs
+    for step = 2:max_steps
+        x = randn(1);
+        if x < 0
+            positions(step, run) = positions(step-1, run) + 1;
+        elseif x > 0
+            positions(step, run) = positions(step-1, run) - 1;
+        end
+    end
+end
+
+figure()
+hold on
+for run = 1:num_runs
+    plot(1:max_steps, positions(:, run))
+end
+xlabel('Number of steps')
+ylabel('Position')
+box off
+
+

programming/lectures/logicalIndexingTime.py

@@ -0,0 +1,29 @@
+import matplotlib.pyplot as plt
+import numpy as np
+from IPython import embed
+time = np.arange(0.,10., 0.001)
+x = np.random.randn(len(time))
+selection = x[(time > 5.) & (time < 6.)]
+
+fig = plt.figure()
+fig.set_facecolor("white")
+fig.set_size_inches(5.5, 2.5)
+
+ax = fig.add_subplot(111)
+ax.plot(time, x, label="data", lw=.5)
+ax.plot(time[(time > 5.) & (time < 6.)], selection, color='r', lw=0.5, label="selection")
+ax.spines["right"].set_visible(False)
+ax.spines["top"].set_visible(False)
+ax.yaxis.set_ticks_position('left')
+ax.xaxis.set_ticks_position('bottom')
+ax.xaxis.linewidth=1.5
+ax.yaxis.linewidth=1.5
+ax.tick_params(direction="out", width=1.25)
+ax.tick_params(direction="out", width=1.25)
+ax.set_xlabel("time [s]")
+ax.set_ylabel("intensity")
+ax.legend(fontsize=8)
+fig.tight_layout()
+fig.savefig("images/logicalIndexingTime.pdf")
+
+

programming/lectures/programming.tex

@@ -6,7 +6,7 @@
 
 \subsection{Variablen}
 
-aEine Variable ist ein Zeiger auf eine Stelle im Speicher. Dieser
+Eine Variable ist ein Zeiger auf eine Stelle im Speicher. Dieser
 Zeiger hat einen Namen, den Variablennamen, und einen Datentyp
 (Abbildung \ref{variablefig}). Im Speicher wird der Wert der Variablen
 bin\"ar gespeichert. Wird auf den Wert der Variable zugegriffen, wird
@@ -758,6 +758,23 @@ nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
   von (\code{x}) an den Stellen, an denen \code{x < 5} wahr ist.
 \end{exercise}
 
+Logisches Indizieren wurde oben so benutzt, dass die Auswahl auf dem
+Inhalt desselben Vektors beruhte. Ein sehr h\"auiger Fall ist
+jedoch, dass man die Auswahl aus einem Vektor auf den Inhalt eines
+zweiten Vektors basiert. Ein Beispiel ist, dass man \"uber einen
+gewissen Zeitraum Daten aufnimmt und aus diesen die Daten eines
+bestimmten Zeitraums ausw\"ahlen m\"ochte (Abbildung
+\ref{logicalindexingfig}).
+
+
+\begin{figure}[h]
+  \includegraphics[width= 0.9\columnwidth]{logicalIndexingTime}
+  \caption{\texbf{Beispiel f\"ur ``indirektes'' logisches Indizieren.}
+    Der rot markierte Abschnitt aus den Daten wurde ``indirekt''
+    anhand logischen Indizierens auf dem Zeitvektor
+    ausgew\"ahlt.}\label{logicalindexingfig}
+\end{figure}
+
 \begin{exercise}{logicalIndexingTime.m}{}
   Angenommen es werden \"uber einen bestimmten Zeitraum Messwerte
   genommen. Bei solchen Messungen er\"alt man einen Vektor, der die
@@ -773,9 +790,6 @@ nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
   \item Benutze das logische Indizieren um die Messwerte
     auszuw\"ahlen, die dem zeitlichen Abschnitt 5-6\,s entsprechen.
   \end{itemize}
-  \begin{figure}
-    \includegraphics[width=0.6\textwidth]{logicalIndexing_time.png}
-  \end{figure}
 \end{exercise}
 
 
@@ -784,7 +798,7 @@ nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
 In der Regel wird ein Programm Zeile f\"ur Zeile von oben nach unten
 ausgef\"uhrt. Manchmal muss der Kontrollfluss aber so gesteuert
 werden, dass bestimmte Teile des Programmcodes wiederholt oder nur
-unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro[\ss]er
+unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro{\ss}er
 Bedeutung sind hier zwei Strukturen:
 
 \begin{enumerate}
@@ -796,10 +810,10 @@ Bedeutung sind hier zwei Strukturen:
 
 Schleifen werden gebraucht um wiederholte Ausf\"uhrung desselben Codes
 zu vereinfachen.  In einer \"Ubung wurde die Fakult\"at von 5 wie in
-Listing \ref{facultylisting1} berechnet:
+Listing \ref{facultylisting} berechnet:
 
 \begin{lstlisting}[caption={Berechnung der Fakult\"at von 5 in f\"unf
-    Schritten}, label=facultylisting1]
+    Schritten}, label=facultylisting]
 >> x = 1;
 >> x = x * 2;
 >> x = x * 3;  
@@ -811,83 +825,472 @@ x =
 \end{lstlisting}
 
 Im Prinzip ist das obige Programm v\"ollig in Ordnung. Es f\"allt
-jedoch auf, dass die Zeilen 2 bis 5 sehr \"ahnlich sind und 
+jedoch auf, dass die Zeilen 2 bis 5 sehr \"ahnlich sind; bis auf die
+Multiplikation mit einer ansteigenden Zahl \"andert sich nichts. Die
+Verwendung von mehr oder weniger exakten Klonen einzelner Zeilen oder
+Abschnitte ist schlechter Prgrammierstil. Dabei geht es nicht nur um
+einen \"asthetischen Aspekt sondern vielmehr darum, dass es schwerwiegende Nachteile gibt.
+\begin{enumerate}
+\item Fehleranf\"alligkeit: Beim ``Copy-and-paste'' kann leicht
+  vergessen werden in einzelnen Klonen die entscheidende \"Anderung
+  auch wirklich vorzunehmen.
+\item Flexibilit\"at: Das obige Programm ist f\"ur genau einen Zweck,
+  Berechnung der Fakult\"at von f\"unf, gemacht und kann nichts
+  anderes.
+\item Wartung: Wenn ich einen Fehler gemacht habe, dann muss ich den
+  Fehler in allen Klonen korrigieren (sehr wird dabei der ein oder
+  andere Klon \"ubersehen).
+\item Verst\"andlichkeit: Solche Abschnitte sind schwerer zu lesen/zu
+  verstehen. Das liegt zum Teil daran, dass man dazu neigt \"uber sich
+  wiederholende Zeilen zu springen (ist ja eh das gleiche...) und dann
+  den entscheidenden Teil verpasst.
+\end{enumerate}
+
+Alle Programmiersprachen bieten zur L\"osung dieses Problems die
+Schleifen. Eine Schleife wird immer dann eingesetzt, wenn man
+Abschnitte wiederholt ausf\"uhren will. 
+
+\subsubsection{Die \textbf{for} --- Schleife}
+
+Der am h\"aufigsten benutzte Vertreter der Schleifen ist die
+\textit{for-Schleife}. Sie besteht aus dem \textit{Schleifenkopf} und
+dem \textit{Schleifenk\"orper}. Der Kopf regelt, wie h\"aufig der Code
+im K\"orper ausgef\"uhrt wird.
+
+\begin{definition}
+  Der Schleifenkopf beginnt mit dem Schl\"usselwort \textbf{for} auf
+  welches folgend die \textit{Laufvariable} definiert wird. In \matlab
+  ``l\"auft''/iteriert eine for-Schleife immer(!) \"uber einen
+  Vektor. Die \textit{Laufvariable} nimmt mit jeder Iteration einen
+  Wert dieses Vektors an.  Im Schleifenk\"orper k\"onnen beliebige
+  Anweisungen ausgef\"uhrt werden. Die Schleife wird durch das
+  Schl\"usselwort \textbf{end} beendet. Listing \ref{looplisting}
+\end{definition}
+
+\begin{lstlisting}[caption={Beispiel einer \textbf{for} Schleife. Die Laufvariable \code{x} nimmt mit jeder Iteration der Schleife einen Wert des Vektors \code{1:5} an.}, label=looplisting]
+for x = 1:5
+  % ... etwas sinnvolles mit x ...
+end
+\end{lstlisting}
+
+
+\begin{exercise}{facultyLoop.m}{facultyLoop.out}
+  Wie k\"onnte Fakult\"at mit einer Schleife implementiert werden?
+  Implementiere eine for Schleife, die die Fakul\"at von einer Zahl
+  \code{n} berechnet.
+\end{exercise}
+
+
+\subsubsection{Die \textbf{while} --- Schleife}
+
+Eine weiterer Schleifentyp, der weniger h\"aufig eingesetzt wird, ist
+die \textot{while}-Schleife. Auch sie hat ihre Entsprechungen in fast
+allen Programmiersprachen.  \"Ahnlich zur \code{for} Schleife wird
+auch hier der in der Schleife definierte Programmcode iterativ
+ausgef\"uhrt.
 
+\begin{definition}
+  Der Schleifenkopf beginnt mit dem Schl\"usselwort \textbf{while}
+  gefolgt von einem \underline{Booleschen Ausdruck}. Solange dieser zu
+  \textit{true} ausgewertet werden kann, wird der Code im
+  Schleifenk\"orper ausgef\"uhrt.  Die Schleife wird mit dem
+  Schl\"usselwort \textbf{end} beendet.
+\end{definition}
+
+
+\begin{lstlisting}[caption={Grundstruktur einer \textbf{while} Schleife.}, label=whileloop]
+while x == true 
+   % fuehre diesen sinnvollen code aus ...
+end
+\end{lstlisting}
+  
+
+\begin{exercise}{facultyWhileLoop.m}{}
+  Implementiere die Fakult\"at mit einer \textbf{while}-Schleife.
+\end{exercise}
+
+
+\begin{exercise}{neverendingWhile.m}{}
+  Implementiere eine \textbf{while}-Schleife, die unendlich
+  l\"auft. Tipp: wenn der Boolesche Ausdruck hinter dem \textbf{while}
+  zu wahr ausgewertet wird, wird die Schleife weiter ausgef\"uhrt.
+\end{exercise}
+
+
+\subsubsection{Vergleich \textbf{for} und \textbf{while} Schleife}
+\begin{itemize}
+\item Beide f\"uhren den Code im Schleifenk\"orper iterativ aus.
+\item Der K\"orper einer \code{for} Schleife wird mindestens 1 mal
+  betreten.
+\item Der K\"orper einer \code{while} Schleife wird nur dann betreten,
+  wenn die Bedinung im Kopf \textbf{true} ist. \\$\rightarrow$ auch
+  ``Oben-abweisende'' Schleife genannt.
+\item Die \code{for} Schleife eignet sich f\"ur F\"alle in denen f\"ur
+  jedes Element eines Vektors der Code ausgef\"uhrt werden soll.
+\item Die \code{while} Schleife ist immer dann gut, wenn nicht klar
+  ist wie h\"aufig etwas ausgef\"uhrt werden soll. Sie ist
+  speichereffizienter.
+\item Jedes Problem kann mit beiden Typen gel\"ost werden. 
+\end{itemize}
+
+
+\subsection{Bedingte Anweisungen und Verzweigungen}
+
+Bedingte Anweisungen und Verzweigungen sind Kontrollstrukturen, die
+regeln, dass der in ihnen eingeschlossene Programmcode nur unter
+bestimmten Bedingungen ausgef\"uhrt wird.
+
+\subsubsection{Die if --- Anweisung}
+
+Am h\"aufigsten genutzter Vertreter ist die \textbf{if} -
+Anweisung. Sie Wird genutzt um Programmcode nur unter bestimmten
+Bedingungen auszuf\"uhren. 
+\begin{definition}
+  Der Kopf der if - Anweisung beginnt mit dem Schl\"usselwort
+  \textbf{if} welches von einem \underline{Booleschen Ausdruck}
+  gefolgt wird. Wenn dieser zu \textbf{true} ausgewertet werden kann,
+  wird der Code im K\"orper der Anweisung ausgef\"uhrt.  Optional
+  k\"onnen weitere Bedingungen mit dem Schl\"usselwort \textbf{elseif}
+  folgen.  Ebenfalls optional ist die Verwendung eines finalen
+  \textbf{else} Falls. Dieser wird immer dann ausgef\"uhrt wenn alle
+  vorherigen Bedingungen nicht erf\"ullt werden.  Die \code{if}
+  Anweisung wird mit \textbf{end} beendet. Listing \ref{ifelselisting}
+  zeigt den Aufbau einer if-Anweisung.
+\end{definition}
+
+\begin{lstlisting}[label=ifelselisting, caption={Grundger\"ust einer \textbf{if} Anweisung.}]
+  if x < y
+   % fuehre diesen code aus
+elseif x > y
+   % etwas anderes soll getan werden
+else
+   % wenn x == y wieder etwas anderes
+end  
+  \end{lstlisting}
+
+\begin{exercise}{ifelse.m}{}
+  Ziehe eine Zufallszahl und \"uberpr\"ufe mit einer geegnet \textbf{if} Anweisung, ob sie:
+  \begin{enumerate}
+  \item ... kleiner als 0.5 ist.
+  \item ... kleiner oder gr\"o{\ss}er-gleich 0.5 ist.
+  \item ... kleiner als 0.5, gr\"o{\ss}er oder gleich 0.5 aber kleiner
+    als 0.75 ist oder gr\"o{\ss}er oder gleich 0.75 ist.
+  \end{enumerate}
+\end{execise}
+
+\subsubsection{Die  \code{switch} - Verzweigung} 
+
+Die \textbf{switch} Verzweigung Wird eingesetzt wenn mehrere F\"alle
+auftreten k\"onnen, die einer unterschiedlichen Behandlung bed\"urfen.
+
+\begin{definition}
+  Wird mit dem Schl\"usselwort \textbf{switch} begonnen, gefolgt von
+  der \textit{switch Anweisung} (Zahl oder String). Jeder Fall auf den
+  die Anweisung \"uberpr\"ft werden soll wird mit dem Schl\"usselwort
+  \textbf{case} eingeleitet. Diese wird gefolgt von der \textit{case
+    Anweisung} welche definiert gegen welchen Fall auf
+  \underline{Gleichheit} getestet wird. F\"ur jeden Fall wird der
+  Programmcode angegeben, der ausgef\"uhrt werden soll Optional
+  k\"onnen mit dem Schl\"usselwort \textbf{otherwise} alle nicht
+  explizit genannten F\"alle behandelt werden.  Die \code{switch}
+  Anweisung wird mit \textbf{end} beendet (z.B. in Listing
+  \ref{switchlisting}).
+\end{definition}
+
+
+\begin{lstlisting}[label=switchlisting, caption={Grundger\"ust einer \textbf{switch} Anweisung.}]
+mynumber = input('Enter a number:');
+switch mynumber
+  case -1
+      disp('negative one');
+  case 1
+      disp('positive one');
+  otherwise
+      disp('something else');
+ end
+\end{lstlisting}
+
+Wichtig ist hier, dass in jedem \textbf{case} auf \underline{Gleichheit} der
+switch-Anweisung und der case-Anweisung getestet wird.
+
+
+\subsubsection{Vergleich if - Anweisung  und switch Verzweigung}
+\begin{itemize}
+\item Mit der \code{if} Anweisung k\"onnen beliebige F\"alle
+  unterschieden und entsprechender code ausgef\"uhrt werden.
+\item Die \code{switch} Anweisung leistet \"ahnliches allerdings wird in
+  jedem Fall auf Gleichheit getestet.
+\item Die \code{switch} Anweisung ist etwas kompakter, wenn viele F\"alle
+  behandelt werden m\"ussen.
+\item Die \code{switch} Anweisung wird deutlich seltener benutzt und
+  kann immer durch eine \code{if} Anweisung erstezt werden.
+\end{itemize}
+
+
+\subsection{Die Schl\"usselworte \code{break} und \code{continue}}
+
+Soll die Ausf\"uhrung einer Schleife abgebrochen oder \"ubersprungen
+werden, werden die Schl\"usselworte \textbf{break} und
+\textbf{continue} eingesetzt (Listing \ref{breakcontinuelisting}
+zeigt, wie sie eingesetzt werden k\"onnen).
+
+\begin{lstlisting}[caption={Ensatz der \code{continue} und \code{break} Schl\"usselworte um die Ausf\"uhrung von Abschnitte in Schleife zu \"uberspringen oder abzubrechen.}, label=breakcontinuelisting]
+for x = 1:10 
+  if(x > 2 & x < 5)
+    continue;
+  end
+  disp(x);
+end
+    
+x = 1;
+while true
+  if(x > 5)
+    break;
+  end
+  disp(x);
+  x = x + 1
+end
+\end{lstlisting}
+
+\begin{exercise}{logicalIndexingBenchmark.m}{logicalIndexingBenchmark.out}
+  Vergleich von logischem Indizieren und ``manueller'' Auswahl von
+  Elementen aus einem Vektor. Es wurde oben behauptet, dass die
+  Auswahl von Elementen mittels logischem Indizieren effizienter
+  ist. Teste dies indem ein Vektor mit vielen (100000) Zufallszahlen
+  erzeugt wird aus dem die Elemente gefiltert und gespeichert werden,
+  die kleiner $0.5$ sind.  Umgebe den Programmabschnitt mit den
+  Br\"udern \code{tic} und \code{toc}. Auf diese Weise misst \matlab{}
+  die zwischen \code{tic} und \code{toc} vergangene Zeit.
+
+  \begin{enumerate}
+  \item Benutze eine \code{for} Schleife um die Element auszuw\"ahlen.
+  \item Benutze logisches Indizieren.
+  \end{enumerate}
+\end{exercise}
+
+\begin{exercise}{simplerandomwalk.m}{}
+  Programmiere einen 1-D random walk. Ausgehend von der Startposition
+  $0$ ``l\"auft'' ein Agent zuf\"allig in die eine oder andere
+  Richtung.
   \begin{itemize}
-  \item Zeilen 2 bis 5 sind sehr \"ahnlich.
-  \item Die Verwendung von solchen Codeklonen ist schlechter Programmierstil!
-  \item Welche Nachteile hat es sonst noch?
+  \item In dem Programm sollen 10 Realisationen eines random walk mit
+    jeweils 1000 Schritten durchgef\"uhrt werden.
+  \item Die Position des Objektes ver\"andert sich in jedem Schritt zuf\"allig um
+    +1 oder -1.
+  \item Merke Dir alle Positionen.
+  \item Plotte die Positionen als Funktion der Schrittnummer.
   \end{itemize}
+\end{exercise}
 
+\section{Skripte und Funktionen}
+
+\subsection{Was ist ein Programm?}
+
+Ein Programm ist eine Sammlung von Anweisungen, die in einer Datei auf
+dem Rechner abgelegt sind. Wenn es durch den Aufruf zum Leben erweckt
+wird, dann wird es Zeile f\"r Zeile von oben nach unten ausgef\"uhrt.
+
+\matlab{} kennt drei Arten von Programmen:
+\begin{enumerate}
+\item Skripte
+\item Funktionen
+\item Objekte (werden wir ignorieren)
+\end{enumerate}
 
+Alle Programme werden in den sogenannten \textit{m-files} gespeichert
+(z.B. \textit{meinProgramm.m}). Um sie zu benutzen werden sie von der
+Kommandozeile aufgerufen oder in anderen Programmen
+verwendet. Programme erh\"ohen die Wiederverwertbarkeit von
+Programmcode. Bislang haben wir ausschlie{\ss}lich Skripte
+verwendet. Dabei wurde jede Variable, die erzuegt wurde im
+\textit{Workspace} abgelegt und konnte wiederverwendet werden. Hierin
+liegt allerdings auch eine Gefahr. In der Regel sind Datenanalysen auf
+mehrere Skripte verteilt und alle teilen sich den gemeinsamen
+Workspace. Verwendet nun ein aufgerufenes Skript eine bereits
+definierte Variable und weist ihr einen neuen Wert zu, dann kann das
+erw\"unscht und praktisch sein. Wenn es aber unbeabsichtigt passiert
+kann es zu Fehlern kommen, die nur sehr schwer erkennbar sind, da ja
+jedes Skript f\"ur sich enwandtfrei arbeitet. Eine L\"osung f\"ur
+dieses Problem bieten die \textbf{Funktionen}.
+
+\subsection{Funktionen}
+
+Eine Funktion in \matlab{} wird \"ahnlich zu einer mathematischen
+Funktion definiert:
+
+\[ y = f(x) \]
+
+Die Funktion hat einen Namen $f$, sie h\"angt von einem Argument $x$
+ab und liefert ein Ergebnis $y$ zur\"uck. Listing
+\ref{functiondefinitionlisting} zeigt wie das in \matlab{} umgesetzt
+wird.
+
+\begin{lstlisting}[caption={Funktionsdefinition in \matlab{}}, label=functiondefinitionlisting]
+function [y] = function_name(arg_1, arg_2)
+%         ^                   ^        ^
+%  Rueckgabewert          Argument_1, Argument_2
+\end{lstlisting}
+
+Ein Funktion beginnt mit dem Schl\"usselwort \textbf{function} gefolgt
+von den R\"uckgabewerte(n), dem Funktionsnamen und (in Klammern) den
+Argumenten.  Auf den Funktionskopf folgt der auszuf\"uhrende
+Programmcode im Funktionsk\"orper. Die Funktionsdefinition wird
+optional mit einem \textbf{end} abgeschlossen. Jede Funktion, die vom
+Nutzer direkt verwendet werden soll ist in einer eigenen Datei
+definiert. \"uber die Definition/Benutzung von Funktionen wird folgendes erreicht:
 
+\begin{itemize}
+\item Kapseln von Programmcode, der f\"ur sich eine Aufgabe l\"ost.
+\item Definierte Schnittstelle.
+\item Eigener G\"ultigkeitsbereich:
   \begin{itemize}
-  \item  Wird genutzt um iterativ/wiederholt einen Codeabschnitt auszuf\"uhren.\pause
-  \item  Eine \code{for} Schleife besteht aus dem \textit{(Schleifen-) Kopf} und dem \textit{(Schleifen-) K\"orper}.
-    \begin{itemize}
-    \item Der Schleifenkopf beginnt mit dem Schl\"usselwort
-      \textbf{for} auf welches folgend die \textit{Laufvariable}
-      definiert wird.
-    \item Die Schleife ``l\"auft''/iteriert immer(!) \"uber einen
-      Vektor.
-    \item Die \textit{Laufvariable} nimmt in jeder Iteration einen
-      Wert dieses Vektors an.
-    \item Im Schleifenk\"orper k\"onnen beliebige Anweisungen
-      ausgef\"uhrt werden.
-    \item Die Schleife wird durch das Schl\"usselwort \textbf{end}
-      beendet.
-    \end{itemize}
+  \item Variablen im Workspace sind in der Funktion \textbf{nicht} sichtbar.
+  \item Variablen, die in der Funktion definiert werden erscheinen
+    \textbf{nicht} im Workspace.
   \end{itemize}
+\item Erhöht die Wiederverwendbarkeit von Programmcode.
+\item Erh\"oht die Lesbarkeit von Programmen, da sie
+  \"ubersichtlicher werden.
+\end{itemize}
+
+Das Folgende Beispiel (Listing \ref{badsinewavelisting}) zeigt eine
+Funktion, die eine Reihe von Sinusschwingungen unterschiedlicher
+Frequenzen berechnet und graphisch darstellt.
+
+\begin{lstlisting}[caption={Eine Beispielfunktion, die eine Reihe Sinus plottet.},label=badsinewavelisting]
+function meine_erste_funktion() % Funktionskopf
+   t = (0:0.01:2); % hier faengt der Funktionskoerper an
+   frequenz = 1.0;
+   amplituden = [0.25 0.5 0.75 1.0 1.25];
+
+   for i = 1:length(amplituden)
+       y = sin(frequenz * t * 2 * pi) * amplituden(i);
+       plot(t, y)
+       hold on;
+   end 
+\end{lstlisting}
 
-  \begin{lstlisting}[label=loopListing2]
-   for x = 1:5
-     % ... etwas sinnvolles mit x ...
-   end
-   \end{lstlisting}
+Dieses schlechte Beispiel ist ein Paradebeispiel f\"ur eine schlechte
+Funktion. Sie hat folgende Probleme:
+\begin{itemize}
+\item Der Name ist nicht aussagekr\"aftig.
+\item Die Funktion ist f\"ur genau einen Zweck gut.
+\item Was sie tut, ist festgelegt und kann von au{\ss}en nicht
+  beeinflusst werden.
+\item Sie tut drei Dinge aus einmal: Sinus berechnen \textbf{und}
+  Amplituden \"andern \textbf{und} graphisch darstellen.
+\item Es ist nicht (einfach) m\"oglich an die berechneten Daten zu
+  kommen.
+\item Keinerlei Dokumentation. Man muss den code lesen um zu
+  rekonstruieren, was sie tut.
+\end{itemize}
 
+Bevor wir anfangen die Funktion zu verbessern sollten wir uns Gedanken
+\"uber das zu l\"osende Problem zu machen:
 
+\begin{enumerate}
+\item Welches Problem soll gel\"ost werden?
+\item Aufteilen in Teilprobleme. 
+\item Gute Namen finden.
+\item Definieren der Schnittstellen --- Was muss die Funktion
+  wissen? Was möchte ich von ihr haben?
+\item Daten zur\"uck geben (R\"uckgabewerte definieren). 
+\end{enumerate}
 
-  Zur\"uck zu unserer Implementation der Fakult\"at:
-  \begin{lstlisting}
->> x = 1;
->> x = x * 2;
->> x = x * 3;  
->> x = x * 4;
->> x = x * 5;
->> x
-x =
-    120
+Das Beispiel aus Listing \ref{badsinewavelisting} kann in drei
+Teilprobleme aufgetrennt werden:
+\begin{enumerate}
+\item Berechnen der \textbf{einzelnen} Sinus.
+\item Plotten der Daten.
+\item Koordinieren von Berechung und Darstellung mit
+  unterschiedlichen Amplituden.
+\end{enumerate}
+
+\begin{lstlisting}
+function [t, y] = calculate_sinewave(frequency, amplitude, t_max, t_step)
+   x = (0:t_step:t_max);
+   y = sin(frequency * t * 2 * pi) * amplitude;
+end
 \end{lstlisting}
-\normalsize
-Wie k\"onnte das in einer Schleife gel\"ost werden?
-
-
-  Implementatierung der Fakult\"at mithilfe einer \code{for} Schleife:
-  \begin{lstlisting}
-    x = 1;
-    for i = 1:5
-      x = x * i;
-    end 
-    % oder auch
-    iterations = 1:5;
-    for i = iterations
-      x = x * i;
-    end
+  
+
+\textbf{2. Plotten einer einzelnen Schwingung:}
+
+\begin{enumerate}
+\item Namen finden
+\item Schnittstelle definieren: Was will ich von der Funktion?
+  Welche Information muss ich ihr geben?\pause
+  \begin{itemize}
+  \item Funktion muss wissen: Welche Daten soll sie plotten? Zeitachse,
+    y-Werte, einen Namen f\"ur die Legende?
+  \item Muss nichts zur\"uckgeben.
+  \end{itemize}
+\end{enumerate}
+
+\begin{lstlisting}
+function plot_sinewave(x_data, y_data, name)
+  plot(x_data, y_data, 'displayname', name) 
+end
 \end{lstlisting}
 
 
-\subsection{Bedingte Anweisungen und Verzweigungen}
+\textbf{3. Erstellen eines \textbf{Skriptes} zur Koordinierung:}
 
+\begin{enumerate}
+\item Namen finden
+\item Definieren eins Vektors, f\"ur die Amplituden.
+\item Definieren einer Variable f\"ur die Frequenz.
+\item Definieren der Variablen f\"ur das Maximum und die
+  Schrittweite der x-Achse.
+\item \"Offnen einer neuen Abbildung (\code{figure()}).
+\item Setzen des \code{hold on}.
+\item \code{for}-Schleife, die über die Amplituden iteriert, die
+  Sinus berechnen l\"asst und die Resultate an die Plot-Funktion
+  weiterreicht.
+\end{enumerate}
 
-\section{Skripte und Funktionen}
+Skript: \verb+plot_sinewaves.m+
+\begin{lstlisting}
+amplitudes = 0.25:0.25:1.25;
+frequency = 2;
+t_max = 10;
+t_step = 0.01;
+    
+figure()
+hold on
+ 
+for a = amplitudes
+  name = num2str(a);
+  [x_data, y_data] = calculate_sinewave(frequency, a, t_max, t_step);
+  plot_sinewave(x_data, y_data, name)
+end
+legend('show')
+\end{lstlisting}
 
+\begin{exercise}{}{}
+  Erweitert das Programm so, dass auch ein Satz von Frequenzen benutzt
+  wird.
+\end{exercise}
 
-\section{Graphische Darstellung von Daten}
-%%% Wuerde ich als eigenes Kapitel machen! JB
-%%% In einem separaten Verzeichnis...
+\subsection{Fazit}
+
+Funktionen sind kleine Code Fragmente, die
+\begin{enumerate}
+\item ... genau eine Aufgabe erledigen.
+\item ... Argumente entgegennehmen k\"onnen.
+\item ... R\"uckgabewerte haben k\"onnen.
+\item ... ihren eigenen G\"ultigkeitsbereich haben.
+\item ... Skripten fast immer vorzuziehen sind.
+\end{enumerate}
+
+Die vorangegangene Diskussion klingt, alsob Skripte zu verteufeln und
+zu vermeiden w\"aren. Dem ist nicht so. In Wahrheit sind sie daf''ur
+gemacht, Hand in Hand ein Probelm zu l\"osen. W\"ahrend die Funktionen
+relativ kleine ``verdauliche'' Teilprobleme l\"osen. Sind die Skripte
+daf\"ur gemacht den Rahmen zu bilden und den Ablauf zu koordinieren.
+Ein m\"ogliches Programmlayout k\"onnte so aussehen:
 
 \begin{figure}
-  \includegraphics[width=0.9\columnwidth]{convincing}
-  \caption{Die Folgen schlecht annotierter
-    Plots. \url{www.xkcd.com}} \label{xkcdplotting}
-\end{figure}
+  \includegraphics[width=0.5\columnwidth]{./images/simple_program.pdf}
+\end{figure}
+  

projects/project_adaptation_fit/adaptation_fit.tex

@@ -40,10 +40,12 @@ electroreceptors of the weakly electric fish \textit{Apteronotus
 
 \begin{questions}
   \question In the accompanying datasets you find the
-  \textit{spike\_times} of an P-unit electrorecptor to a stimulus of a
-  certain intensity, i.e. the \textit{contrast} which is also stored
-  in the file. The data is sampled with 20\,kHz sampling frequency and
-  spike times are given in milliseconds relative to the stimulus onset.
+  \textit{spike\_times} of an P-unit electroreceptor to a stimulus of
+  a certain intensity, i.e. the \textit{contrast} which is also stored
+  in the file. The contrast of the stimulus is a measure relative to
+  the amplitude of fish's field, it has no unit. The data is sampled
+  with 20\,kHz sampling frequency and spike times are given in
+  milliseconds relative to the stimulus onset.
   \begin{parts}
     \part Estimate for each stimulus intensity the PSTH and plot
     it. You will see that there are three parts.  (i) The first

projects/project_stimulus_reconstruction/stimulus_reconstruction.tex

@@ -57,7 +57,7 @@ reconstruct the stimulus a neuron has been stimulated with.
     error using the mean-square-error and express it relative to the
     variance of the original stimulus.
     \begin{equation}
-      err = \frac{1}{N} \cdot \displaystyle\sum^{N}_{i=1}(x_i - \bar{x}),
+      err = \frac{1}{N} \cdot \displaystyle\sum^{N}_{i=1}(x_i - \bar{x})^2,
     \end{equation}
     with $N$ the number of data points, $x_i$ the current value and
     $\bar{x}$, the average of all $x$.

spike_trains/lecture/psth_sta.tex

@@ -17,7 +17,7 @@ modellieren.
 Die Analyse von Spiketrains beinhaltet demnach einige der Methoden,
 die auch f\"r die Beschreibung von Punktprozessen angewandt
 werden. Dar\"uber hinaus wird versucht die Beziehung zwischen der
-zeitabh\"aengigen neuronalen Antwort und dem zugrundeliegenden
+zeitabh\"angigen neuronalen Antwort und dem zugrundeliegenden
 Stimulus zu analysieren.
 
 \section{Darstellung der zeitabh\"angigen Feuerrate}
@@ -34,12 +34,13 @@ Nachteile. Im folgenden werden die drei Methoden aus Abbildung
 
 \begin{figure}
   \includegraphics[width=\columnwidth]{psth_comparison}
-  \caption{\textbf{Verschiedene Methoden das PSTH zu bestimmen. A)}
-    Rasterplot einer einzelnen neuronalen Antwort. Jeder vertikale
-    Strich notiert den Zeitpunkt eines Aktionspotentials. \textbf{B)}
-    PSTH aus der instantanen Feuerrate bestimmt. \textbf{C)} PSTH mit
-    der Binning Methode. \textbf{D)} Feuerrate durch Faltung mit einem
-    Gauss Kern bestimmt.}\label{psthfig}
+  \caption{\textbf{Verschiedene Methoden die zeitabh\"angige Feuerrate
+      zu bestimmen. A)} Rasterplot einer einzelnen neuronalen
+    Antwort. Jeder vertikale Strich notiert den Zeitpunkt eines
+    Aktionspotentials. \textbf{B)} Feurerrate aus der instantanen
+    Feuerrate bestimmt. \textbf{C)} klassisches PSTH mit der Binning
+    Methode. \textbf{D)} Feuerrate durch Faltung mit einem Gauss Kern
+    bestimmt.}\label{psthfig}
 \end{figure}
 
 
@@ -47,10 +48,10 @@ Nachteile. Im folgenden werden die drei Methoden aus Abbildung
 Ein sehr einfacher Weg, die zeitabh\"angige Feuerrate zu bestimmen ist
 die sogenannte \textit{instantane Feuerrate}. Dabei wird die Feuerrate
 aus dem Kehrwert des \textit{Interspike Intervalls}, der Zeit zwischen
-zwei aufeinander folgenden Aktionspotentialen (Abbildung \ref{isipsth}
-A), bestimmt. Die abgesch\"atzte Feuerrate (Abbildung \ref{isipsth} B)
+zwei aufeinander folgenden Aktionspotentialen (Abbildung \ref{instrate}
+A), bestimmt. Die abgesch\"atzte Feuerrate (Abbildung \ref{instrate} B)
 ist g\"ultig f\"ur das gesammte Interspike Intervall
-\ref{isipsth}. Diese Methode hat den Vorteil, dass sie sehr einfach zu
+\ref{instrate}. Diese Methode hat den Vorteil, dass sie sehr einfach zu
 berechnen ist und keine Annahme \"uber eine relevante Zeitskala (der
 Kodierung oder des Auslesemechanismus der postsynaptischen Zelle)
 macht. $r(t)$ ist allerdings keine kontinuierliche Funktion, die
@@ -60,13 +61,13 @@ Aktionspotentiale generiert wurden.
 
 \begin{figure}[!htb]
   \includegraphics[width=\columnwidth]{isi_method}
-  \caption{\textbf{Bestimmung des PSTH aus dem Interspike
-      Interval. A)} Skizze eines Rasterplots einer einzelnen
-    neuronalen Antwort. Jeder vertikale Strich notiert den Zeitpunkt
-    eines Aktionspotentials. Die Pfeile zwischen aufeinanderfolgenden
-    Aktionspotentialen illustrieren das Interspike
-    Interval. \textbf{B)} Der Kehrwert des Interspike Intervalls ist
-    die Feuerrate.}\label{isipsth}
+  \caption{\textbf{Bestimmung des zeitabh\"angigen Feuerrate aus dem
+      Interspike Interval. A)} Skizze eines Rasterplots einer
+    einzelnen neuronalen Antwort. Jeder vertikale Strich notiert den
+    Zeitpunkt eines Aktionspotentials. Die Pfeile zwischen
+    aufeinanderfolgenden Aktionspotentialen illustrieren das
+    Interspike Interval. \textbf{B)} Der Kehrwert des Interspike
+    Intervalls ist die Feuerrate.}\label{instrate}
 \end{figure}
 
 
@@ -99,9 +100,10 @@ koninuierliche Funktion.
 
 
 \paragraph{Faltungsmethode}
-Bei der Faltungsmethode geht man etwas anders vor. Die
-Aktionspotentialfolge wird ``bin\"ar'' dargestellt. Das heisst, dass
-eine Antwort als Vektor dargestellt wird, in welchem die Zeitpunkte der
+Bei der Faltungsmethode geht wird etwas anders vorgegangen um die
+Feuerrate zeitaufgel\"ost zu berechnen. Die Aktionspotentialfolge wird
+zun\"achst ``bin\"ar'' dargestellt. Das heisst, dass eine Antwort als
+(Zeit-)Vektor dargestellt wird, in welchem die Zeitpunkte der
 Aktionspotentiale als 1 notiert werden. Alle anderen Elemente des
 Vektors sind 0. Anschlie{\ss}end wir dieser bin\"are Spiketrain mit
 einem Gauss Kern bestimmter Breite gefaltet.
@@ -109,9 +111,9 @@ einem Gauss Kern bestimmter Breite gefaltet.
 \[r(t) = \int_{-\infty}^{\infty}d\tau \omega(\tau)\rho(t-\tau) \],
 wobei $\omega(\tau)$ der Filterkern und $\rho(t)$ die bin\"are Antwort
 ist. Bildlich geprochen wird jede 1 in $rho(t)$ durch den Filterkern
-ersetzt (Abbildung \ref{convpsth} A). Wenn der Kern richtig normiert
+ersetzt (Abbildung \ref{convrate} A). Wenn der Kern richtig normiert
 wurde (Integral 1), ergibt sich die Feuerrate direkt aus der
-\"Uberlagerung der Kerne (Abb. \ref{convpsth} B). Die Faltungsmethode
+\"Uberlagerung der Kerne (Abb. \ref{convrate} B). Die Faltungsmethode
 f\"uhrt, anders als die anderen Methoden, zu einer kontinuierlichen
 Funktion was f\"ur spektrale Analysen von Vorteil sein kann. Die Wahl
 der Kernbreite bestimmt, \"ahnlich zur Binweite, die zeitliche
@@ -126,17 +128,18 @@ relevante Zeitskala.
     Faltung werden die mit einer 1 notierten Aktionspotential durch
     den Faltungskern ersetzt. \textbf{B)} Bei korrekter Normierung des
     Kerns ergibt sich die Feuerrate direkt aus der \"Uberlagerung der
-    Kerne.}\label{convpsth}
+    Kerne.}\label{convrate}
 \end{figure}
 
 
 
 \section{Spike triggered Average}
-Die graphischer Darstellung der Feuerrate reicht nicht aus um den
-Zusammenhang zwischen neuronaler Antwort und einem Stimulus zu
-analysieren.  Eine Methode mehr \"uber diesen zu erfahren ist der
-Spike triggered average (STA). Der STA ist der mittlere Stimulus, der
-zu einem Aktionspotential in der neuronalen Antwort f\"uhrt.
+Die graphischer Darstellung der Feuerrate allein reicht nicht aus um
+den Zusammenhang zwischen neuronaler Antwort und einem Stimulus zu
+analysieren.  Eine Methode mehr \"uber diesen Zusammenhang zu erfahren
+ist der Spike triggered average (STA). Der STA ist der mittlere
+Stimulus, der zu einem Aktionspotential in der neuronalen Antwort
+f\"uhrt.
 
 \begin{equation}
   STA(\tau) = \frac{1}{\langle n \rangle} \left\langle  \displaystyle\sum_{i=1}^{n}{s(t_i - \tau)} \right\rangle