491 lines
15 KiB
TeX
491 lines
15 KiB
TeX
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
|
|
\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} |