Vectors finished
This commit is contained in:
parent
fffd7226e2
commit
59ce7227fc
@ -1,7 +1,7 @@
|
||||
%!PS-Adobe-2.0 EPSF-2.0
|
||||
%%Title: pointprocessscetchA.tex
|
||||
%%Creator: gnuplot 4.6 patchlevel 4
|
||||
%%CreationDate: Wed Oct 28 18:47:55 2015
|
||||
%%CreationDate: Mon Nov 2 19:55:25 2015
|
||||
%%DocumentFonts:
|
||||
%%BoundingBox: 50 50 373 135
|
||||
%%EndComments
|
||||
@ -430,10 +430,10 @@ SDict begin [
|
||||
/Title (pointprocessscetchA.tex)
|
||||
/Subject (gnuplot plot)
|
||||
/Creator (gnuplot 4.6 patchlevel 4)
|
||||
/Author (benda)
|
||||
/Author (jan)
|
||||
% /Producer (gnuplot)
|
||||
% /Keywords ()
|
||||
/CreationDate (Wed Oct 28 18:47:55 2015)
|
||||
/CreationDate (Mon Nov 2 19:55:25 2015)
|
||||
/DOCINFO pdfmark
|
||||
end
|
||||
} ifelse
|
||||
|
||||
@ -1,7 +1,7 @@
|
||||
%!PS-Adobe-2.0 EPSF-2.0
|
||||
%%Title: pointprocessscetchB.tex
|
||||
%%Creator: gnuplot 4.6 patchlevel 4
|
||||
%%CreationDate: Wed Oct 28 18:47:56 2015
|
||||
%%CreationDate: Mon Nov 2 19:57:38 2015
|
||||
%%DocumentFonts:
|
||||
%%BoundingBox: 50 50 373 237
|
||||
%%EndComments
|
||||
@ -430,10 +430,10 @@ SDict begin [
|
||||
/Title (pointprocessscetchB.tex)
|
||||
/Subject (gnuplot plot)
|
||||
/Creator (gnuplot 4.6 patchlevel 4)
|
||||
/Author (benda)
|
||||
/Author (jan)
|
||||
% /Producer (gnuplot)
|
||||
% /Keywords ()
|
||||
/CreationDate (Wed Oct 28 18:47:56 2015)
|
||||
/CreationDate (Mon Nov 2 19:57:38 2015)
|
||||
/DOCINFO pdfmark
|
||||
end
|
||||
} ifelse
|
||||
|
||||
491
programming/lectures/programming.tex
Normal file
491
programming/lectures/programming.tex
Normal file
@ -0,0 +1,491 @@
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
||||
\chapter{\tr{Programming basics}{Grundlagen der Programmierung in Matlab}}
|
||||
|
||||
\section{Variablen und Datentypen}
|
||||
|
||||
\subsection{Variablen}
|
||||
|
||||
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
|
||||
dieses Bitmuster je nach Datentyp interpretiert. Das Beispiel in
|
||||
Abbildung \ref{variablefig} zeigt, dass das gleiche Bitmuster im einen
|
||||
Fall als 8-Bit Integer Datentyp zur Zahl 38 interpretiert wird und im
|
||||
anderen Fall als Character zum kaufm\"annischen ``und'' ausgewertet
|
||||
wird. In Matlab sind Datentypen nicht von sehr zentraler
|
||||
Bedeutung. Wir werden uns dennoch sp\"ater etwas genauer mit ihnen
|
||||
befassen.
|
||||
|
||||
\begin{figure}
|
||||
\centering
|
||||
\begin{subfigure}{.5\textwidth}
|
||||
\includegraphics[width=0.8\textwidth]{variable}
|
||||
\label{variable:a}
|
||||
\end{subfigure}%
|
||||
\begin{subfigure}{.5\textwidth}
|
||||
\includegraphics[width=.8\textwidth]{variableB}
|
||||
\label{variable:b}
|
||||
\end{subfigure}
|
||||
\caption{\textbf{Variablen.} Variablen sind Zeiger auf eine Adresse
|
||||
im Speicher, die einen Namen und einen Datentypen beinhalten. Im
|
||||
Speicher ist der Wert der Variable bin\"ar gespeichert. Abh\"angig
|
||||
vom Datentyp wird dieses Bitmuster unterschiedlich
|
||||
interpretiert.}\label{variablefig}
|
||||
\end{figure}
|
||||
|
||||
|
||||
\subsection{Erzeugen von Variablen}
|
||||
In Matlab kann eine Variable auf der Kommandozeile, in einem Skript
|
||||
oder einer Funktion an beliebiger Stelle erzeugen. Das folgende
|
||||
Listing zeigt zwei M\"oglichkeiten:
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=varListing1, caption=Erzeugen von Variablen]
|
||||
>> y = []
|
||||
y =
|
||||
[]
|
||||
>>
|
||||
>> x = 38
|
||||
x =
|
||||
38
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
Die Zeile 1 kann etwa so gelesen werden:''Erzeuge eine Variable mit
|
||||
dem Namen y und weise ihr einen leeren Wert zu.'' Das
|
||||
Gleichheitszeichen ist der sogenannte
|
||||
\textit{Zuweisungsoperator}. Zeile 5 definiert eine Variable x, der
|
||||
nun der Zahlenwert 38 zugewiesen wird. Da Matlab, wenn nicht anders
|
||||
angegeben immer den ``double'' Datentypen benutzt, haben beide
|
||||
Variablen diesen Datentyp.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=varListing2, caption={Erfragen des Datentyps einer Variable, Listen aller definierten Variablen.}]
|
||||
>>disp(class(x))
|
||||
double
|
||||
>>
|
||||
>> who % oder whos um mehr Information zu bekommen
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
Bei der Namensgebung ist zu beachten, dass Matlab auf Gro{\ss}- und
|
||||
Kleinschreibung achtet und ein Variablennane mit einem alphabethischen
|
||||
Zeichen beginnen muss. Des Weiteren sind Umlaute, Sonder- und
|
||||
Leerzeichen in Variablennamen nicht erlaubt.
|
||||
|
||||
|
||||
\subsection{Arbeiten mit Variablen}
|
||||
|
||||
Nat\"urlich kann man mit den Variablen auch arbeiten, bzw
|
||||
rechnen. Matlab kennt alle normalen arithmetischen Operatoren wie
|
||||
\code{+, -, *. /}. Die Potenz wird \"uber das Dach Symbol \code{\^}
|
||||
dargestellt. Das folgende Listing zeigt, wie sie benutzt werden.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=varListing3, caption={Rechnen mit Variablen.}]
|
||||
>> x = 1;
|
||||
>> x + 10
|
||||
ans =
|
||||
11
|
||||
>>
|
||||
>> x % x wurde nicht veraendert
|
||||
ans =
|
||||
1
|
||||
>>
|
||||
>> y = 2;
|
||||
>>
|
||||
>> x + y
|
||||
ans =
|
||||
3
|
||||
>>
|
||||
>> z = x + y
|
||||
z =
|
||||
3
|
||||
>>
|
||||
>> z = z * 5;
|
||||
>> z
|
||||
z =
|
||||
15
|
||||
>>
|
||||
>> clear z
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
Beachtenswert ist z.B. in Zeilen 3 und 6, dass wir mit dem Inhalt
|
||||
einer Variablen rechnen k\"onnen, ohne dass dadurch ihr Wert
|
||||
ver\"andert w\"urde. Wenn der Wert einer Variablen ver\"andert werden
|
||||
soll, dann muss dieser der Variable expliyit zugewiesen werden (mit
|
||||
dem \code{=} Zuweisungsoperator, z.B. Zeilen 16, 20). Zeile 25 zeigt
|
||||
wie eine einzelne Variable gel\"oscht wird.
|
||||
|
||||
|
||||
\subsection{Datentypen}
|
||||
|
||||
Der Datentyp bestimmt, wie die im Speicher abgelegten Bitmuster
|
||||
interpretiert werden. Die Wichtigsten Datentpyen sind folgende:
|
||||
|
||||
\begin{itemize}
|
||||
\item \textit{integer} - Ganze Zahlen. Hier gibt es mehrere
|
||||
Unterarten, die wir in Matlab (meist) ignorieren k\"onnen.
|
||||
\item \textit{double} - Flie{\ss}kommazahlen.
|
||||
\item \textit{complex} - Komplexe Zahlen.
|
||||
\item \textit{logical} - Boolesche Werte, die als wahr
|
||||
(\textit{true}) oder falsch (\textit{false}) interpretiert werden.
|
||||
\item \textit{char} - ASCII Zeichen
|
||||
\end{itemize}
|
||||
|
||||
Unter den numerischen Datentypen gibt es verschiedene Arten mit
|
||||
unterschiedlichem Speicherbedarf und Wertebreich.
|
||||
|
||||
\begin{table}[]
|
||||
\centering
|
||||
\caption{Gel\"aufige Datentypen und ihr Wertebereich.}
|
||||
\label{dtypestab}
|
||||
\begin{tabular}{l|l|c|cl}
|
||||
Datentyp & Speicherbedarf & Wertebereich & Beispiel \\ \cline{1-4}
|
||||
double & 64 bit & & Flie{\ss}kommazahlen.\\ \cline{1-4}
|
||||
int & 64 bit & $-2^{31} bis 2^{31}-1$ & Ganzzahlige Werte \\ \cline{1-4}
|
||||
int16 & 64 bit & $-2^{15} bis 2^{15}-1$ & Digitalisierte Spannungen. \\ \cline{1-4}
|
||||
uint8 & 64 bit & 0 bis 255 & Digitalisierte Imaging Daten. \\ \cline{1-4}
|
||||
& & &
|
||||
\end{tabular}
|
||||
\end{table}
|
||||
|
||||
|
||||
Matlab arbeitet meist mit dem ``double'' Datentyp wenn numerische
|
||||
Daten gespeichert werden. Dennoch lohnt es sich, sich ein wenig mit
|
||||
den Datentypen auseinanderzusetzen. Ein Szenario, dass in der
|
||||
Neurobiologie nicht selten ist, ist, dass wir die elektrische
|
||||
Aktivit\"at einer Nervenzelle messen. Die gemessenen Spannungen werden
|
||||
mittels Messkarte digitalisiert und auf dem Rechner
|
||||
gespeichert. Typischerweise k\"onnen mit solchen Messkarten Spannungen
|
||||
im Bereich $\pm 10$\,V gemessen werden. Die Aufl\"osung der Wandler
|
||||
betr\"agt typischerweise 16 bit. Das heisst, dass der gesamte
|
||||
Spannungsbereich in $2^{16}$ Schritte aufgeteilt ist. Um Speicherplatz
|
||||
zu sparen ist es sinnvoll, die gemessenen Daten als ``int16'' Werte im
|
||||
Rechner abzulegen. Die Daten als ``echte'' Spannungen, also als
|
||||
Flie{\ss}kommawerte, abzulegen w\"urde den 4-fachen Speicherplatz
|
||||
ben\"otigen.
|
||||
|
||||
|
||||
|
||||
\section{Vektoren und Matrizen}
|
||||
|
||||
\begin{definition}[Vektoren und Matrizen]
|
||||
Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
|
||||
Matlab. In andern Programmiersprachen spricht man von ein-
|
||||
bzw. mehrdimensionalen Feldern. Felder sind Datenstrukturen, die
|
||||
mehrere Werte des geleichen Datentyps in einer Variablen
|
||||
vereinen. Da Matalb seinen Ursprung in der Verarbeitung von
|
||||
mathematischen Vektoren und Matrizen hat werden sie hier auch so
|
||||
genannt.\\
|
||||
|
||||
In Wahrheit existiert auch in Matlab kein Unterschied zwischen
|
||||
beiden Datenstrukturen. Im Hintergrund sind auch Vektoren
|
||||
2-diemsensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e 1
|
||||
hat.
|
||||
\end{definition}
|
||||
|
||||
|
||||
\subsection{Vektoren}
|
||||
|
||||
Im Gegensatz zu den Variablen, die einzelene Werte beinhalten,
|
||||
Skalare, kann ein Vektor mehrere Werte des gleichen Datentyps
|
||||
beinhalten (Abbildung \ref{vectorfig} B). Die Variable ``test''
|
||||
enth\"alt in diesem Beispiel vier ganzzahlige Werte.
|
||||
|
||||
|
||||
\begin{figure}
|
||||
\includegraphics[width=0.8\columnwidth]{scalarArray}
|
||||
\caption{\textbf{Skalare und Vektoren. A)} Eine skalare Variable kann
|
||||
genau einen Wert tragen. \textbf{B)} Ein Vektor kann mehrer
|
||||
Werte des gleichen Datentyps (z.B. ganzzahlige Integer Werte)
|
||||
beinhalten. Matlab kennt den Zeilen- (row-) und Spaltenvektor
|
||||
(columnvector).}\label{vectorfig}
|
||||
\end{figure}
|
||||
|
||||
Das folgende Listing zeigt, wie einfache Vektoren erstellt werden
|
||||
k\"onnen.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=arrayListing1, caption={Erstellen einfacher Zeilenvektoren.}]
|
||||
>> a = [0 1 2 3 4 5 6 7 8 9] % Erstellen eines Zeilenvektors
|
||||
a =
|
||||
0 1 2 3 4 5 6 7 8 9
|
||||
>>
|
||||
>> b = (0:9) % etwas bequemer
|
||||
b =
|
||||
0 1 2 3 4 5 6 7 8 9
|
||||
>>
|
||||
>> c = (0:2:10)
|
||||
c =
|
||||
0 2 4 6 8 10
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
Die L\"ange eines Vektors kann mithilfe der Funktion \code{length()}
|
||||
bestimmt werden. \"Ahnliche Information kann man \"uber die Funktion
|
||||
\code{size()} erhalten. Im Falle des Vektors \code{a} von oben erh\"alt
|
||||
man folgende Ausgabe:
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=arrayListing2, caption={Gr\"o{\ss}e von Vektoren.}]
|
||||
>> length(a)
|
||||
ans =
|
||||
10
|
||||
>> size(a)
|
||||
ans =
|
||||
1 10
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
Diese Ausgabe zeigt, dass Vektoren im Grunde 2-dimensional sind. Bei
|
||||
einem Zeilenvektor hat die erste Dimension die Gr\"o{\ss}e
|
||||
1. \code{length(a)} gibt die l\"angste Ausdehnung an.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=arrayListing3, caption={Spaltenvektoren.}]
|
||||
>> b = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10] % Erstellen eines Spaltenvektors
|
||||
b =
|
||||
1
|
||||
2
|
||||
....
|
||||
9
|
||||
10
|
||||
>> length(b)
|
||||
ans =
|
||||
10
|
||||
>> size(b)
|
||||
ans =
|
||||
10 1
|
||||
>> b = b'; % Transponieren
|
||||
>> size(b)
|
||||
ans =
|
||||
1 10
|
||||
\end{lstlisting}
|
||||
|
||||
Der \code{'}- Operator transponiert den Spaltenvektor zu einem
|
||||
Zeilenvektor.
|
||||
|
||||
\subsubsection{Zugriff auf Inhalte von Vektoren}
|
||||
\begin{figure}
|
||||
\includegraphics[width=0.4\columnwidth]{arrayIndexing}
|
||||
\caption{\textbf{Indices von Vektoren.} Jedes Feld eines Vektors hat
|
||||
einen Index mit dem auf den jeweiligen Inhalt zugegriffen werden
|
||||
kann.}\label{vectorindexingfig}
|
||||
\end{figure}
|
||||
|
||||
Der Zugriff auf die Inhalte eines Vektors erfolgt \"uber den Index
|
||||
(Abbildung \ref{vectorindexingfig}). Jedes Feld in einem Vektor hat
|
||||
einen \textit{Index} \"uber den auf die Werte des Vektors zugegriffen
|
||||
werden kann. Dabei spielt es keine Rolle, ob es sich um einen Zeilen-
|
||||
oder Spaltenvektor handlet. \textbf{Achtung!} Anders als viele andere
|
||||
Sprachen beginnt Matlab mit dem Index 1. Die Listings
|
||||
\ref{arrayListing4} und \ref{arrayListing5} zeigen wie man mit dem
|
||||
Index auf die Inhalte zugreifen kann.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=arrayListing4, caption={Zugriff auf den Inhalt von Vektoren I}]
|
||||
>> a = (11:20);
|
||||
>> a(1) % das 1. Element
|
||||
ans =
|
||||
11
|
||||
>> a(5) % das 5. Element
|
||||
ans =
|
||||
15
|
||||
>> a(end) % das letzte Element
|
||||
ans =
|
||||
20
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
Hierbei kann man auf einzelne Werte zugreifen oder, analog zur
|
||||
Erzeugung von Vektoren, die \code{:} Notation verwenden um auf mehrere
|
||||
Element gleichzeitig zuzugreifen.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[caption={Zugriff auf den Inhalt von Vektoren I}, label=arrayListing5]
|
||||
>> a([1 3 5]) % das 1., 3. und 5. Element
|
||||
ans =
|
||||
11 13 15
|
||||
>> a(2:4) % alle element von Index 2 bis 4
|
||||
ans =
|
||||
12 13 14
|
||||
>> a(1:2:end) %jedes zweite Element
|
||||
ans =
|
||||
11 13 15 17 19
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
\paragraph{Frage:}
|
||||
Der R\"uckgabewert von \code{size(a)} ist wieder ein Vektor der
|
||||
L\"ange 2. Wie k\"onnte man also die Gr\"o{\ss}e von \code{a} in der
|
||||
zweiten Dimension herausfinden?
|
||||
|
||||
\paragraph{Antwort:}
|
||||
Man speichert den R\"uckgabewert in einer Variable (\code{s = size(a);})
|
||||
und gibt den Inhalt an der Stelle 2 aus (\code{disp(s(2))}).
|
||||
|
||||
|
||||
\subsubsection{Operationen auf Vektoren}
|
||||
|
||||
Nat\"urlich kann man mit Vektoren auch rechnen. Listing
|
||||
\ref{arrayListing5} zeigt Rechnungen mit Vektoren.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[caption={Rechnen mit Vektoren.},label=arrayListing5]
|
||||
>> a = (0:2:8);
|
||||
>> a + 5 % addiere einen Skalar
|
||||
ans =
|
||||
5 7 9 11 13
|
||||
|
||||
>> a - 5 % subtrahiere einen Skalar
|
||||
ans =
|
||||
-5 -3 -1 1 3
|
||||
|
||||
>> a .* 2 % Multiplication
|
||||
ans =
|
||||
0 4 8 12 16
|
||||
|
||||
>> a ./ 2 % Division
|
||||
ans =
|
||||
0 1 2 3 4
|
||||
|
||||
>> a(1:3) + a(2:4) % Addieren von 2 Vektoren
|
||||
ans =
|
||||
2 6 10
|
||||
>>
|
||||
>> a(1:2) + a(2:4) % Vektoren muessen gleich gross sein!
|
||||
??? Error using ==> plus
|
||||
Matrix dimensions must agree.
|
||||
\end{lstlisting}
|
||||
\normalsize
|
||||
|
||||
Wird ein Vektor mit einem skalaren Wert verrechnet, dann ist das
|
||||
Problemlos m\"oglich. Bei der Multiplikation (Zeile 10), der Division
|
||||
(Zeile 14) und auch der Potenzierung sollte man mit vorangestellem '.'
|
||||
klar machen, dass es sich um einen \textit{elementweise} Verarbeitung
|
||||
handelt. F\"ur diese elementweisen Operationen kennt Matlab die
|
||||
Operatoren \code{.*, ./} und \code{.\^}. Die einfachen Operatoren sind
|
||||
im Kontext von Vektoren und Matrizen anders belegt, als man es
|
||||
vielleicht erwarten w\"urde. Es sind dann die entsprechenden
|
||||
Matrixoperationen, die man aus der linearen Algebrar kennt (s.u.).
|
||||
|
||||
Zu Beachten ist des Weiteren noch die Fehlermeldung am SChluss von
|
||||
Listing \ref{arrayListing5}. Wenn zwei Vektoren (elementweise)
|
||||
miteinander verrechnet werden sollen muss nicht nur die Anzahl Element
|
||||
übereinstimmen sondern es muss auch das Layout (Zeilen- oder
|
||||
Spaltenvektoren) \"ubereinstimmen.
|
||||
|
||||
|
||||
Will man Elemente aus einem Vektor entfernen, dann weist man den
|
||||
entsprechenden Zellen einen leeren Wert (\code{[]}) zu.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[label=arrayListing6, caption={L\"oschen von Elementen aus einem Vektor.}]
|
||||
>> a = (0:2:8);
|
||||
>> length(a)
|
||||
ans =
|
||||
5
|
||||
|
||||
>> a(1) = [] % loesche das erste Element
|
||||
a = 2 4 6 8
|
||||
|
||||
>> a([1 3]) = []
|
||||
a = 4 8
|
||||
|
||||
>> length(a)
|
||||
ans =
|
||||
2
|
||||
\end{lstlisting}
|
||||
|
||||
Neben dem L\"oschen von Vektorinhalten kann man Vektoren auch
|
||||
erweitern oder zusammensetzen. Auch hier muss das Layout der Vektoren
|
||||
\"ubereinstimmen (Listing \ref{arrayListing7}, Zeile 12). Will man
|
||||
einen Vektor erweitern, kann man \"uber das Ende hinaus
|
||||
zuweisen. Matlab erweitert dann die Variable. Auch hierbei muss auf
|
||||
das Layout geachtet werden. Zudem ist dieser Vorgang
|
||||
``rechenintensiv'' und man sollte, soweit m\"oglich, vermeiden
|
||||
Vektoren bei Bedarf einfach zu erweitern.
|
||||
|
||||
\footnotesize
|
||||
\begin{lstlisting}[caption={Zusammenf\"ugen und erweitern von Vektoren.}, label=arrayListing7]
|
||||
>> a = (0:2:8);
|
||||
>> b = (10:2:19);
|
||||
>> c = [a b] % erstelle einen Vektor aus einer Liste von Vektoren
|
||||
c =
|
||||
0 2 4 6 8 10 12 14 16 18
|
||||
>> length(c)
|
||||
ans =
|
||||
10
|
||||
>> length(a) + length(b)
|
||||
ans =
|
||||
10
|
||||
>> c = [a b'];
|
||||
Error using horzcat
|
||||
Dimensions of matrices being concatenated are not consistent.
|
||||
|
||||
>> b(6:8) = [1 2 3 4];
|
||||
\end{lstlisting}
|
||||
|
||||
|
||||
\subsection{Matrizen}
|
||||
|
||||
\begin{figure}
|
||||
\includegraphics[width=0.5\columnwidth]{matrices}
|
||||
\caption{\textbf{Indices von Vektoren.} Jedes Feld eines Vektors hat
|
||||
einen Index mit dem auf den jeweiligen Inhalt zugegriffen werden
|
||||
kann.}\label{vectorindexingfig}
|
||||
\end{figure}
|
||||
|
||||
|
||||
\begin{figure}
|
||||
\includegraphics[width=0.9\columnwidth]{matrixIndexing}
|
||||
\caption{\textbf{Indices von Vektoren.} Jedes Feld eines Vektors hat
|
||||
einen Index mit dem auf den jeweiligen Inhalt zugegriffen werden
|
||||
kann.}\label{vectorindexingfig}
|
||||
\end{figure}
|
||||
|
||||
\begin{figure}
|
||||
\includegraphics[width=0.9\columnwidth]{matrixLinearIndexing}
|
||||
\caption{\textbf{Indices von Vektoren.} Jedes Feld eines Vektors hat
|
||||
einen Index mit dem auf den jeweiligen Inhalt zugegriffen werden
|
||||
kann.}\label{vectorindexingfig}
|
||||
\end{figure}
|
||||
|
||||
|
||||
|
||||
\section{Boolesche Operationen}
|
||||
|
||||
|
||||
\section{Logisches Indizieren}
|
||||
|
||||
|
||||
\section{Kontrollstrukturen}
|
||||
|
||||
\begin{definition}[Kontrollstrukturen]
|
||||
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 grosser
|
||||
Bedeutung sind hier zwei Strukturen:
|
||||
\begin{enumerate}
|
||||
|
||||
\item Schleifen.
|
||||
\item Bedingte Anweisungen und Verzweigungen.
|
||||
\end{enumerate}
|
||||
\end{definition}
|
||||
|
||||
|
||||
\section{Skripte und Funktionen}
|
||||
|
||||
|
||||
\section{Graphische Darstellung von Daten}
|
||||
|
||||
|
||||
\begin{figure}
|
||||
\includegraphics[width=0.9\columnwidth]{./images/convincing}
|
||||
\caption{Die Folgen schlecht annotierter
|
||||
Plots. \url{www.xkcd.com}} \label{xkcdplotting}
|
||||
\end{figure}
|
||||
@ -1,4 +1,4 @@
|
||||
\documentclass[12pt]{report}
|
||||
g\documentclass[12pt]{report}
|
||||
|
||||
\input{header}
|
||||
|
||||
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@ -26,9 +26,11 @@ Eine klassische Darstellung zeitabh\"angiger neuronaler Aktivit\"at
|
||||
ist das sogenannte Peri Stimulus Zeithistogramm (peri stimulus time
|
||||
histogram, PSTH). Es wird der zeitliche Verlauf der Feuerrate $r(t)$
|
||||
dargestellt. Die Einheit der Feuerrate ist Hertz, das heisst, die
|
||||
Anzahl Aktionspotentiale pro Sekunde. Dabei gibt es verschiedene
|
||||
Methoden diese zu bestimmen. Drei solcher Methoden sind in Abbildung
|
||||
\ref{psthfig} dargestellt.
|
||||
Anzahl Aktionspotentiale pro Sekunde. Es verschiedene Methoden diese
|
||||
zu bestimmen. Drei solcher Methoden sind in Abbildung \ref{psthfig}
|
||||
dargestellt. Alle Methoden haben ihre Berechtigung und ihre Vor- und
|
||||
Nachteile. Im folgenden werden die drei Methoden aus Abbildung
|
||||
\ref{psthfig} n\"aher erl\"autert.
|
||||
|
||||
\begin{figure}
|
||||
\includegraphics[width=\columnwidth]{psth_comparison}
|
||||
@ -40,48 +42,93 @@ Methoden diese zu bestimmen. Drei solcher Methoden sind in Abbildung
|
||||
Gauss Kern bestimmt.}\label{psthfig}
|
||||
\end{figure}
|
||||
|
||||
|
||||
\paragraph{Instantane Feuerrate}
|
||||
Ein sehr einfacher Weg, die zeitabh\"angige Feuerrate zu bestimmen ist
|
||||
die sogenannte \textit{instantane Feuerrate}. Dabie wird die Feuerrate
|
||||
die sogenannte \textit{instantane Feuerrate}. Dabei wird die Feuerrate
|
||||
aus dem Kehrwert des \textit{Interspike Intervalls}, der Zeit zwischen
|
||||
zwei aufeinanderfolgender Aktionspotentiale, bestimmt. Die
|
||||
abgesch\"atzte Feuerrate ist g\"ultig f\"ur das gesammte Interspike
|
||||
Intervall. Sie ist sehr einfach zu berechnen und hat den Vorteil keine
|
||||
Annahme \"uber eine relevante Zeitskala (der codierung oder des
|
||||
Auslesemechanismus der postsynaptischen Zelle) zu machen. $r(t)$ ist
|
||||
keine kontinuierliche Funktion, die Spr\"unge in der Feuerrate können f\"ur
|
||||
manche Analysen nachteilig sein.
|
||||
zwei aufeinander folgenden Aktionspotentialen (Abbildung \ref{isipsth}
|
||||
A), bestimmt. Die abgesch\"atzte Feuerrate (Abbildung \ref{isipsth} B)
|
||||
ist g\"ultig f\"ur das gesammte Interspike Intervall
|
||||
\ref{isipsth}. 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
|
||||
Spr\"unge in der Feuerrate k\"onnen f\"ur manche Analysen nachteilig
|
||||
sein. Des Weiteren ist die Feuerrate nie null, auch wenn lange keine
|
||||
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}
|
||||
\end{figure}
|
||||
|
||||
|
||||
\paragraph{Binning Methode}
|
||||
Bei der Binning Methode wird die Zeitachse in gleichm\"aßige Abschnitte
|
||||
(Bins) eingeteilt und die Anzahl Aktionspotentiale, die in die
|
||||
jeweiligen Bins fallen gez\"ahlt. Um diese Z\"ahlungen in die Feuerrate
|
||||
umzurechnen muss noch mit der Binweite normiert werden. \textbf{Tipp:}
|
||||
Um die Anzahl Spikes pro Bin zu berechnen kann die \code{hist}
|
||||
Funktion benutzt werden. Das so berechnete PSTH hat wiederum eine
|
||||
stufige Form, die von der Wahl der Binweite anh\"angt. Die Binweite
|
||||
bestimmt die zeitliche Auflösung mit der Darstellung. \"Anderungen in
|
||||
der Feuerrate, die innerhalb eines Bins vorkommen koennen nicht
|
||||
aufglöst werden. Die Wahl der Binweite stellt somit eine Annahme \"uber
|
||||
die relevante Zeitskala der Verarbeitung dar. Auch hier ist $r(t)$
|
||||
keine koninuierliche Funktion.
|
||||
Bei der Binning Methode wird die Zeitachse in gleichm\"aßige
|
||||
Abschnitte (Bins) eingeteilt und die Anzahl Aktionspotentiale, die in
|
||||
die jeweiligen Bins fallen, gez\"ahlt (Abbildung \ref{binpsth} A). Um
|
||||
diese Z\"ahlungen in die Feuerrate umzurechnen muss noch mit der
|
||||
Binweite normiert werden. Die bestimmte Feuerrate gilt f\"ur das
|
||||
gesamte Bin (Abbildung \ref{binpsth} B). \textbf{Tipp:} Um die Anzahl
|
||||
Spikes pro Bin zu berechnen kann die \code{hist} Funktion benutzt
|
||||
werden. Das so berechnete PSTH hat wiederum eine stufige Form, die von
|
||||
der Wahl der Binweite anh\"angt. Die Binweite bestimmt die zeitliche
|
||||
Aufl\"osung der Darstellung. \"Anderungen in der Feuerrate, die
|
||||
innerhalb eines Bins vorkommen k\"onnen nicht aufgl\"ost werden. Die
|
||||
Wahl der Binweite stellt somit eine Annahme \"uber die relevante
|
||||
Zeitskala der Verarbeitung dar. Auch hier ist $r(t)$ keine
|
||||
koninuierliche Funktion.
|
||||
|
||||
\begin{figure}[h!]
|
||||
\includegraphics[width=\columnwidth]{bin_method}
|
||||
\caption{\textbf{Bestimmung des PSTH mit der Binning Methode. A)}
|
||||
Skizze eines Rasterplots einer einzelnen neuronalen Antwort. Jeder
|
||||
vertikale Strich notiert den Zeitpunkt eines
|
||||
Aktionspotentials. Die roten gestrichelten Linien stellen die
|
||||
Grenzen der Bins dar und die Zahlen geben den Spike Count pro Bin
|
||||
an. \textbf{B)} Die Feuerrate erh\"alt man indem das
|
||||
Zeithistogramm mit der Binweite normiert.}\label{binpsth}
|
||||
\end{figure}
|
||||
|
||||
|
||||
\paragraph{Faltungsmethode}
|
||||
Bei der Faltungsmethode geht man anders vor. Die Aktionspotentialfolge
|
||||
wird ``bin\"ar'' dargestellt. Eine Antwort wird als Vektor dargestellt,
|
||||
in dem 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 Gausskern bestimmter Breite gefaltet.
|
||||
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
|
||||
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.
|
||||
|
||||
\[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. 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 Aufl\"osung von $r(t)$. Man macht eine Annahme
|
||||
\"uber die relevante Zeitskala.
|
||||
ersetzt (Abbildung \ref{convpsth} 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
|
||||
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
|
||||
Aufl\"osung von $r(t)$. Man macht also eine Annahme \"uber die
|
||||
relevante Zeitskala.
|
||||
|
||||
\begin{figure}[h!]
|
||||
\includegraphics[width=\columnwidth]{conv_method}
|
||||
\caption{\textbf{Schematische Darstellung der Faltungsmethode. A)}
|
||||
Rasterplot einer einzelnen neuronalen Antwort. Jeder vertikale
|
||||
Strich notiert den Zeitpunkt eines Aktionspotentials. In der
|
||||
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}
|
||||
\end{figure}
|
||||
|
||||
|
||||
|
||||
\section{Spike triggered Average}
|
||||
|
||||
Reference in New Issue
Block a user