diff --git a/plotting/lecture/Makefile b/plotting/lecture/Makefile new file mode 100644 index 0000000..9c5c90f --- /dev/null +++ b/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"\ diff --git a/plotting/lecture/beamercolorthemetuebingen.sty b/plotting/lecture/beamercolorthemetuebingen.sty new file mode 100644 index 0000000..c4a5da6 --- /dev/null +++ b/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 + +\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 + diff --git a/programming/lectures/images/badbarleft.png b/plotting/lecture/images/badbarleft.png similarity index 100% rename from programming/lectures/images/badbarleft.png rename to plotting/lecture/images/badbarleft.png diff --git a/programming/lectures/images/badbarplot.jpg b/plotting/lecture/images/badbarplot.jpg similarity index 100% rename from programming/lectures/images/badbarplot.jpg rename to plotting/lecture/images/badbarplot.jpg diff --git a/programming/lectures/images/badbarright.png b/plotting/lecture/images/badbarright.png similarity index 100% rename from programming/lectures/images/badbarright.png rename to plotting/lecture/images/badbarright.png diff --git a/programming/lectures/images/comparison_properly_improperly_graph.png b/plotting/lecture/images/comparison_properly_improperly_graph.png similarity index 100% rename from programming/lectures/images/comparison_properly_improperly_graph.png rename to plotting/lecture/images/comparison_properly_improperly_graph.png diff --git a/programming/lectures/images/convincing.png b/plotting/lecture/images/convincing.png similarity index 100% rename from programming/lectures/images/convincing.png rename to plotting/lecture/images/convincing.png diff --git a/programming/lectures/images/improperly_scaled_graph.png b/plotting/lecture/images/improperly_scaled_graph.png similarity index 100% rename from programming/lectures/images/improperly_scaled_graph.png rename to plotting/lecture/images/improperly_scaled_graph.png diff --git a/programming/lectures/images/line_graph1.png b/plotting/lecture/images/line_graph1.png similarity index 100% rename from programming/lectures/images/line_graph1.png rename to plotting/lecture/images/line_graph1.png diff --git a/programming/lectures/images/line_graph1_3.png b/plotting/lecture/images/line_graph1_3.png similarity index 100% rename from programming/lectures/images/line_graph1_3.png rename to plotting/lecture/images/line_graph1_3.png diff --git a/programming/lectures/images/line_graph1_4.png b/plotting/lecture/images/line_graph1_4.png similarity index 100% rename from programming/lectures/images/line_graph1_4.png rename to plotting/lecture/images/line_graph1_4.png diff --git a/programming/lectures/images/misleading_pie.png b/plotting/lecture/images/misleading_pie.png similarity index 100% rename from programming/lectures/images/misleading_pie.png rename to plotting/lecture/images/misleading_pie.png diff --git a/programming/lectures/images/nobelbad.png b/plotting/lecture/images/nobelbad.png similarity index 100% rename from programming/lectures/images/nobelbad.png rename to plotting/lecture/images/nobelbad.png diff --git a/programming/lectures/images/one_d_problem_c.pdf b/plotting/lecture/images/one_d_problem_c.pdf similarity index 100% rename from programming/lectures/images/one_d_problem_c.pdf rename to plotting/lecture/images/one_d_problem_c.pdf diff --git a/programming/lectures/images/properly_scaled_graph.png b/plotting/lecture/images/properly_scaled_graph.png similarity index 100% rename from programming/lectures/images/properly_scaled_graph.png rename to plotting/lecture/images/properly_scaled_graph.png diff --git a/programming/lectures/images/sample_pie.png b/plotting/lecture/images/sample_pie.png similarity index 100% rename from programming/lectures/images/sample_pie.png rename to plotting/lecture/images/sample_pie.png diff --git a/programming/lectures/images/spike_detection.pdf b/plotting/lecture/images/spike_detection.pdf similarity index 100% rename from programming/lectures/images/spike_detection.pdf rename to plotting/lecture/images/spike_detection.pdf diff --git a/plotting/lecture/plotting-chapter.tex b/plotting/lecture/plotting-chapter.tex new file mode 100644 index 0000000..323d374 --- /dev/null +++ b/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} + diff --git a/programming/lectures/plotting-slides.tex b/plotting/lecture/plotting-slides.tex similarity index 100% rename from programming/lectures/plotting-slides.tex rename to plotting/lecture/plotting-slides.tex diff --git a/plotting/lecture/plotting.tex b/plotting/lecture/plotting.tex new file mode 100644 index 0000000..81c6bf5 --- /dev/null +++ b/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} \ No newline at end of file diff --git a/programming/code/facultyLoop.m b/programming/code/facultyLoop.m new file mode 100644 index 0000000..ba14622 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/programming/code/facultyLoop.out b/programming/code/facultyLoop.out new file mode 100644 index 0000000..192c318 --- /dev/null +++ b/programming/code/facultyLoop.out @@ -0,0 +1,2 @@ +>> facultyLoop +Faculty of 5 is: 120 \ No newline at end of file diff --git a/programming/code/facultyWhileLoop.m b/programming/code/facultyWhileLoop.m new file mode 100644 index 0000000..8f718d1 --- /dev/null +++ b/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) \ No newline at end of file diff --git a/programming/code/ifelse.m b/programming/code/ifelse.m new file mode 100644 index 0000000..94de3d6 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/programming/code/logicalIndexingBenchmark.m b/programming/code/logicalIndexingBenchmark.m index 4a95184..80c4a87 100644 --- a/programming/code/logicalIndexingBenchmark.m +++ b/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); diff --git a/programming/code/logicalIndexingBenchmark.out b/programming/code/logicalIndexingBenchmark.out index 3161e95..f133b26 100644 --- a/programming/code/logicalIndexingBenchmark.out +++ b/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. \ No newline at end of file diff --git a/programming/code/neverendingWhile.m b/programming/code/neverendingWhile.m new file mode 100644 index 0000000..e3999e9 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/programming/code/simplerandomwalk.m b/programming/code/simplerandomwalk.m new file mode 100644 index 0000000..865693f --- /dev/null +++ b/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 + + diff --git a/programming/lectures/images/logicalIndexing_time.png b/programming/lectures/images/logicalIndexing_time.png deleted file mode 100644 index d709140..0000000 Binary files a/programming/lectures/images/logicalIndexing_time.png and /dev/null differ diff --git a/programming/lectures/logicalIndexingTime.py b/programming/lectures/logicalIndexingTime.py new file mode 100644 index 0000000..ef553de --- /dev/null +++ b/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") + + diff --git a/programming/lectures/programming.tex b/programming/lectures/programming.tex index 52724ec..6498e71 100644 --- a/programming/lectures/programming.tex +++ b/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} \ No newline at end of file + \includegraphics[width=0.5\columnwidth]{./images/simple_program.pdf} +\end{figure} + diff --git a/projects/project_adaptation_fit/adaptation_fit.tex b/projects/project_adaptation_fit/adaptation_fit.tex index 80bca6f..b89f946 100644 --- a/projects/project_adaptation_fit/adaptation_fit.tex +++ b/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 diff --git a/projects/project_eod/EOD_data.mat b/projects/project_eod/EOD_data.mat index 406ee21..e53ceb6 100644 Binary files a/projects/project_eod/EOD_data.mat and b/projects/project_eod/EOD_data.mat differ diff --git a/projects/project_stimulus_reconstruction/stimulus_reconstruction.tex b/projects/project_stimulus_reconstruction/stimulus_reconstruction.tex index 7e185b6..1db9aba 100644 --- a/projects/project_stimulus_reconstruction/stimulus_reconstruction.tex +++ b/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$. diff --git a/spike_trains/lecture/psth_sta.tex b/spike_trains/lecture/psth_sta.tex index 404b34a..96e5d71 100644 --- a/spike_trains/lecture/psth_sta.tex +++ b/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