%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
\chapter{\tr{Programming basics}{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}
  \titlecaption{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:
\begin{lstlisting}[label=varListing1, caption=Erzeugen von Variablen]
  >> y = []
  y = 
  []
  >>
  >> x = 38
  x =
  38
\end{lstlisting}

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
\codeterm{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.

\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}

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 mit den Variablen auch gearbeitet, bzw gerechnet
werden. \matlab{} kennt alle normalen arithmetischen Operatoren wie
\code{+}, \code{-}, \code{*} und \code{/}. Die Potenz wird \"uber das
Dachsymbol \code{\^} dargestellt. Das folgende Listing zeigt, wie sie
benutzt werden.

\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}

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 wird. Wenn der Wert einer Variablen ver\"andert werden
soll, dann muss dieser der Variable explizit 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 \codetterm{integer} - Ganze Zahlen. Hier gibt es mehrere
  Unterarten, die wir in \matlab{} (meist) ignorieren k\"onnen.
\item \codeterm{double} - Flie{\ss}kommazahlen. Im Gegensatz zu den reelen Zahlen, die durch diesen Datentyp dargestellt werden, sind sie abz\"ahlbar.
\item \codeterm{complex} - Komplexe Zahlen.
\item \codeterm{logical} - Boolesche Werte, die als wahr
  (\code{true}) oder falsch (\code{false}) interpretiert werden.
\item \codeterm{char} - ASCII Zeichen
\end{itemize}
Unter den numerischen Datentypen gibt es verschiedene Arten mit
unterschiedlichem Speicherbedarf und Wertebreich.

\begin{table}[!h]
  \centering
  \titlecaption{Grundlegende Datentypen und ihr Wertebereich.}{}
  \label{dtypestab}
  \begin{tabular}{llcl}\hline
    Datentyp & Speicherbedarf & Wertebereich & Beispiel \rule{0pt}{2.5ex} \\ \hline
    double & 64 bit & $\approx -10^{308}$ bis $\approx 10^{308} $&  Flie{\ss}kommazahlen.\rule{0pt}{2.5ex}\\
    int & 64 bit & $-2^{31}$ bis $2^{31}-1$ &  Ganzzahlige Werte  \\
    int16 & 16 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\
    uint8 & 8 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline  
  \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 (Box \ref{daqbox}). 

\begin{ibox}[t]{\label{daqbox}Digitalisierung von Messdaten}
  Szenario: Die elektrische Aktivit\"at (z.B. die Membranspannung)
  einer Nervenzelle wird gemessen. Die gemessene Spannung wird mittels
  Messkarte digitalisiert und auf dem Computer f\"ur weitere Analysen
  gespeichert. Typischerweise k\"onnen mit solchen Messkarten
  Spannungen im Bereich $\pm 10$\,V gemessen werden. Die Aufl\"osung
  der Analog-Digitalwandler betr\"agt heutzutage meistens 16 bit. Das
  heisst, dass der gesamte Spannungsbereich in $2^{16}$ Schritte
  eingeteilt ist. Die gemessenene Spannung wird auf digitalisierte
  Werte abgebildet.\vspace{0.25cm}

  \begin{minipage}{0.5\textwidth}
    \includegraphics[width=0.9\columnwidth]{data_acquisition}
  \end{minipage}
  \begin{minipage}{0.5\textwidth}
    Um die Spannung auf den \code{int16} Datentyp abzubilden:
    \[ y = x \cdot 2^{16}/20\] mit $x$ der gemessenen Spannung und $y$
    dem digitalisierten Wert bei einem Spannungsbereich von
    $\pm10$\,V. Das ergibt ganzzahlige Werte zwischen $-2^{15}=-32768$
    und $2^{15}-1 = 32767$.

    Durch Umkehrung kann der digitalisierte Wert wieder
    in eine Spannung zur\"uckgewandelt werden:
    \[ x = y \cdot 20/2^{16} \]
  \end{minipage}\vspace{0.25cm}

  Um Speicherplatz zu sparen ist es sinnvoll, die gemessenen Daten als
  ``int16'' anstelle der ``double'' Werte im Rechner abzulegen.  Die
  Daten als ``echte'' Spannungen, also als Flie{\ss}kommawerte,
  abzulegen ben\"otigt den 4-fachen Speicherplatz (8 statt 2 Bytes)
  und bietet keine zus\"atzliche Information.
  
\end{ibox}


\section{Vektoren und Matrizen}

Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
\matlab{}. In anderen Programmiersprachen heissen sie ein-
bzw. mehrdimensionalen Felder. Felder sind Datenstrukturen, die
mehrere Werte des geleichen Datentyps in einer Variablen vereinen. Da
\matlab{} seinen Ursprung in der Verarbeitung von mathematischen
Vektoren und Matrizen hat, werden sie hier auch so genannt. \matlab{}
macht keinen Unterschied zwischen Vektoren und Matrizen.  Vektoren
sind 2--dimensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e
1 hat.


\subsection{Vektoren}

Im Gegensatz zu 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}
  \titlecaption{Skalare und Vektoren.}{\textbf{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. 

\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}
Die L\"ange eines Vektors, d.h. die Anzahl der Elemente des Vektors,
kann mithilfe der Funktion \code{length()} bestimmt werden. \"Ahnliche
Information kann \"uber die Funktion \code{size()} erhalten werden. Im
Falle des Vektors \code{a} von oben erh\"alt man folgende Ausgabe:

\begin{lstlisting}[label=arrayListing2, caption={Gr\"o{\ss}e von Vektoren.}]
  >> length(a)
  ans =
  10
  >> size(a)
  ans =
  1  10
\end{lstlisting}

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.

\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}
  \titlecaption{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 fortlaufenden \codeterm{Index}, \"uber den auf die Werte des
Vektors zugegriffen werden kann. Dabei spielt es keine Rolle, ob es
sich um einen Zeilen- oder Spaltenvektor handelt. 
\begin{important}
Anders als viele andere Sprachen beginnt \matlab{} mit dem Index
1.
\end{important}
Die Listings \ref{arrayListing4} und \ref{arrayListing5} zeigen wie
mit Indexen auf die Inhalte eines Vektors zugegriffen werden kann.

\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}

Hierbei kann auf einzelne Werte zugegriffen werden oder, analog zur
Erzeugung von Vektoren, die \code{:} Notation verwendet werden, um auf mehrere
Element gleichzeitig zuzugreifen.

\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 Elemente von Index 2 bis einschliesslich 4
  ans =
  12  13  14 
  >> a(1:2:end) %jedes zweite Element
  ans =
  11  13  15  17  19
\end{lstlisting}

\begin{exercise}{vectorsize.m}{vectorsize.out}
  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?
\end{exercise}

\subsubsection{Operationen auf Vektoren}

Mit Vektoren kann sehr einfach gerechnet werden. Listing
\ref{arrayListing6} zeigt Rechnungen mit Vektoren.

\begin{lstlisting}[caption={Rechnen mit Vektoren.},label=arrayListing6]
  >> 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}

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 mu{\ss} mit vorangestellem '.'
klar gemacht werden, dass es sich um eine \emph{elementweise}
Verarbeitung handeln soll. F\"ur diese elementweisen Operationen kennt
\matlab{} die Operatoren \code{.*}, \code{./} und \code{.\^}. Die
einfachen Operatoren \code{*}, \code{/} und \code{\^} sind mit den
entsprechenden Matrixoperationen aus der linearen Algebrar belegt
(s.u.).

Zu Beachten ist des Weiteren noch die Fehlermeldung am Schluss von
Listing \ref{arrayListing6}. Wenn zwei Vektoren (elementweise)
miteinander verrechnet werden sollen, muss nicht nur die Anzahl der Elemente
ü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.

\begin{lstlisting}[label=arrayListing7, 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 k\"onnen Vektoren auch
erweitert oder zusammengesetzt werden. Auch hier muss das Layout der Vektoren
\"ubereinstimmen (Listing \ref{arrayListing8}, 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 sollte soweit m\"oglich vermieden werden.

\begin{lstlisting}[caption={Zusammenf\"ugen und Erweitern von Vektoren.}, label=arrayListing8]
  >> 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}

Im Gegesatz zu den 1-dimensionalen Vektoren k\"onnen Martizen
n-dimensional sein, das hei{\ss}t, dass sie beliebig viele Dimensionen
haben k\"onnen. Von praktischer Bedeutung sind allerdings nur Matrizen
mit bis zu vier Dimensionen. Meist beschr\"ankt es sich jedoch auf 2-
bis 3-d Matrizen (Abbildung \ref{matrixfig} A,B).

\begin{figure}
  \includegraphics[width=0.5\columnwidth]{matrices}
  \titlecaption{Matrizen.}{\textbf{A)} Eine Variable (``test'') die eine
    2-dimensionale Matrize ist. \textbf{B)} Illustration einer
    3-dimensionalen Matrize. Die Pfeile zeigen den Rang der
    Dimensionen an.}\label{matrixfig}
\end{figure}

Erzeugt werden Matrizen sehr \"ahnlich zu den Vektoren (Listing
\ref{matrixListing}). Die Definition einer Matrize wird, wie beim
Vektor, durch \code{[]} eingeschlossen. Das \code{;} trennt die
einzelnen Zeilen der Matrize. 

\begin{lstlisting}[label=matrixListing, caption={Erzeugen von Matrizen.}]
  >> a = [1 2 3; 4 5 6; 7 8 9] 
  >> a =
  1  2  3
  4  5  6
  7  8  9
  >>
  >> b = ones(3,3,2); 
  >> b
  
  b(:,:,1) =
  1   1   1
  1   1   1
  1   1   1
  
  b(:,:,2) =
  1   1   1
  1   1   1
  1   1   1
\end{lstlisting}

Zur Defintion von mehr-dimensionalen Matrizen ist die Notation in
Zeile 1 nicht geeignet. Es gibt allerdings eine Reihe von
Helferfunktionen, die n-dimensionale Matrizen erstellen k\"onnen
(z.B. \code{ones}, Zeile 7). Sollte sich die Notwendigkeit ergeben
mehrdimensionale Matrizen zusammenzuf\"ugen hilft die \code{cat}
Funktion.

Um Informationen \"uber die Gr\"o{\ss}e einer Matrize zu bekommen ist
die Funktion \code{length} nicht geeignet. Wie oben erw\"ahnt gibt sie
die Gr\"o{\ss}e der l\"angsten Dimension aus. Wann immer es um
Matrizen geht, wird \code{size} benutzt.

\begin{figure}
  \includegraphics[width=0.9\columnwidth]{matrixIndexing}
  \titlecaption{Indices von Matrizen.}{Jedes Feld einer Matrize
    wird durch einen Index individuell angesprochen. Der Index setzt
    sich aus so vielen Zahlen zusammen wie es Dimensionen gibt (links
    2, rechts 3). Dabei steht die 1. Stelle immer f\"ur die Zeile, die
    2. f\"ur die Spalte und die dritte f\"ur das Blatt,
    etc.. }\label{matrixindexingfig}
\end{figure}

Der Zugriff auf Inhalte von Matrizen erfolgt \"uber den Index
(Abbildung \ref{matrixindexingfig}, Listing
\ref{matrixIndexing}). \"Ahnlich zu den Positionen in einem
Koordinatensystem wird jede Zelle einer Matrize mit einem Index
angesprochen, der aus $n$ Zahlen besteht wobei $n$ die
Dimensionalit\"at der Matrize ist. Diese Art des Zugriffs wird
\codeterm{subsript indexing} genannt.

\begin{lstlisting}[caption={Zugriff auf Inhalte von Matrizen,
    Indexierung.}, label=matrixIndexing]
  >> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
  >> size(x)
  ans =
  3 4 5
  >> x(1,1,1); % obere linke Ecke
  ans(1,1,1) = 
  14
  >>
  >> x(1,1,:) % obere linke Ecke entlang der 3. Dimension
  ans(1,1,:) = 
  14
  ans(:,:,2) =
  58
  ans(:,:,3) =
  4
  ans(:,:,4) =
  93
  ans(:,:,5) =
  56 
\end{lstlisting}

Alternativ zum \codeterm{subscript indexing} k\"onnen die Zellen einer
Matrize auch \emph{linear} angesprochen werden (Abbildung
\ref{matrixlinearindexingfig}). Diese Art der Adressierung ist nicht
so intuitiv verst\"andlich, kann aber sehr hilfreich sein. Der
``linare'' Index einer Zelle reicht von 1 bis \code{numel(M)}
Elemente. Wobei dieser erst entlang der 1. Dimension, dann der 2.,
3. etc. Dimension ansteigt. Listing \ref{matrixLinearIndexing} zeigt
ein Beispiel f\"ur den Einsatz des linearen Indexierens z.B. wenn man
den Minimalwert aller Elemente einer Matrize ermitteln m\"ochte.

\begin{figure}
  \includegraphics[width=0.9\columnwidth]{matrixLinearIndexing}
  \titlecaption{Lineares Indexieren von Matrizen.}{Der Index steigt
    linear von 1 bis zur Anzahl Elemente in der Matrize an. Dabei
    steigt der Index zuerst entlang der ersten, zweiten, dritten und
    weiterer Dimensionen an.}\label{matrixlinearindexingfig}
\end{figure}

\begin{lstlisting}[label=matrixLinearIndexing, caption={Lineares Indexieren in Matrizen.}]
  >> x = randi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
  >> size(x)
  ans =
  3 4 5
  >> numel(x)
  ans =
  60
  >> min(min(min(x))) % Minumum uber die Zeilen, Spalten, Blaetter... 
  ans = 
  4
  >> min(x(:)) % oder so
  ans = 
  4
\end{lstlisting}


Beim Rechnen mit Matrizen gelten die gleichen Regeln wie bei
Vektoren. Matrizen k\"onnen solange elementweise miteinander
Verrechnet werden, wie die Dimensionalit\"aten
\"ubereinstimmen. Besondere Vorsicht sollte man immer dann walten
lassen, wenn man Matrizen miteinander mulitplizieren, dividieren oder
potenzieren will. Hier ist es wichtig sich klarzumachen was man will:
Eine elementweise Multiplikation (\code{.*} Operator, Listing
\ref{matrixOperations} Zeile 18) oder ob eine Matrixmultiplikation
(\code{*} Operator, Listing \ref{matrixOperations} Zeile 12)
durchgef\"uhrt werden soll.

\begin{lstlisting}[label=matrixOperations, caption={Zwei Arten von Multiplikationen auf Matrizen.}]
  >> A = randi(10, [3, 3]) % 2-D Matrix 
  A = 
  3     8     2
  2    10     3
  10     7     1
  >> B = randi(10, [3, 3]) % dto
  B = 
  2     1     7
  1     5     9
  5    10     5
  >> 
  >> A * B % Matrix Multiplikation
  ans = 
  24    63   103
  29    82   119
  32    55   138
  >>
  >> A .* B % Elementweise Multiplikation
  ans = 
  6     8    14
  2    50    27
  50    70     5
  >>
\end{lstlisting}

\section{Boolesche Operationen}

Boolesche Ausdr\"ucke sind Anweisungen, die zu \codeterm{wahr} oder
\codeterm{falsch} ausgewertet werden. Man kennt sie z.B. aus der
Mengenlehre. In der Programmierung werdens sie eingesetzt, um z.B. die
Beziehung zwischen Entit\"aten zu testen. Hierzu werden die
\codeterm{relationalen Operatoren} (\code{>}, \code{<}, \code{==},
\code{!}, gr\"o{\ss}er als, kleiner als, gleich und nicht)
eingesetzt. Mehrere Ausdr\"ucke werden mittels der \codeterm{logischen
  Operatoren} (\code{\&}, \code{|}, UND, ODER ) verkn\"upft. Sie sind f\"ur
uns nicht nur wichtig um Codeabschnitte bedingt auszuf\"uhren
(Verzweigungen, \ref{controlstructsec}) sondern auch um aus Vektoren
und Matrizen bequem Elemente auszuw\"ahlen (logisches Indizieren,
\ref{logicalindexingsec}). Die folgenden Tabellen zeigen die
Wahrheitstabellen f\"ur das logische UND (\ref{logicalandor}, links)
aund das logische ODER (\ref{logicalandor}, rechts). Es werden die
Aussagen A und B mit dem Operator verkn\"upft. Beim logischen UND ist
der gesamte Ausdruck nur dann wahr, wenn beide Ausdr\"ucke sich zu
wahr auswerten lassen.

\begin{table}[tp]
  \titlecaption{Wahrheitstabellen logisches UND (links) und logisches ODER (rechts).}{}\label{logicalandor}
  \begin{minipage}[t]{0.4\textwidth}
    \begin{tabular}{llll}
      \multicolumn{2}{l}{\multirow{2}{*}{}}  & \multicolumn{2}{c}{\textbf{B}} \\
      \multicolumn{2}{l}{} & \multicolumn{1}{|c|}{wahr} & falsch \\ \cline{2-4} 
      \multirow{2}{*}{\textbf{A}} & \multicolumn{1}{l|}{wahr}   & \multicolumn{1}{c|}{\textcolor{mygreen}{wahr}} &  \textcolor{red}{falsch}      \\ \cline{2-4} 
      & \multicolumn{1}{l|}{falsch} & \multicolumn{1}{l|}{\textcolor{red}{falsch}} & \textcolor{red}{falsch}      
    \end{tabular}
  \end{minipage}
  \begin{minipage}[t]{0.4\textwidth}
    \begin{tabular}{llll}
      \multicolumn{2}{l}{\multirow{2}{*}{}}            & \multicolumn{2}{c}{\textbf{B}}      \\
      \multicolumn{2}{l}{}                             & \multicolumn{1}{|c|}{wahr} & falsch \\ \cline{2-4} 
      \multirow{2}{*}{\textbf{A}} & \multicolumn{1}{l|}{wahr}   & \multicolumn{1}{c|}{\textcolor{mygreen}{wahr}}     &  \textcolor{mygreen}{wahr}      \\ \cline{2-4} 
      & \multicolumn{1}{l|}{falsch} & \multicolumn{1}{l|}{\textcolor{mygreen}{wahr}}     & \textcolor{red}{falsch}      
    \end{tabular}
  \end{minipage}
\end{table}

Anders ist das beim logischen ODER. Hier ist der gesamte
Ausdruck wahr, wenn sich der eine \emph{oder} der andere Ausdruck zu
wahr auswerten l\"a{\ss}t. Tabelle \ref{logicaloperators} zeigt die
logischen Operatoren, die in \matlab{} definiert sind. Zu bemerken
sind hier noch die \code{\&\&} und \code{||} Operatoren. Man kann
beliebige Ausdr\"ucke verkn\"upfen und h\"aufig kann schon anhand des
ersten Ausdrucks entschieden werden, ob der gesamte Boolesche Ausdruck
zu wahr oder falsch ausgewertet werden wird. Wenn zwei Aussagen mit
einem UND verkn\"upft werden und der erste zu falsch ausgewerte wird,
dann muss der zweite gar nicht mehr gepr\"uft werden. Die Verwendung
der ``short-circuit'' Versionen spart Rechenzeit. Das auschliessende
ODER (XOR) ist in \matlab{} nur als Funktion \code{xor(A, B)}
verf\"ugbar.

\begin{table}[th]
  \titlecaption{\label{logicaloperators}
    Logische  Operatoren in \matlab.}{}
  \begin{center}
    \begin{tabular}{c|c}
      \hline
      \textbf{Operator} & \textbf{Beschreibung} \\ \hline
      $\sim$ & logisches NOT\\
      $\&$ &  logisches UND\\
      $|$ & logisches ODER\\
      $\&\&$ & short-circuit logical UND\\
      $\|$ & short-circuit logical ODER\\
      \hline
    \end{tabular}
  \end{center}
\end{table}

Um Werte miteinander zu vergleichen gibt es die \codeterm{relationalen
  Operatoren} (Tabelle \ref{relationaloperators}). Mit ihnen kann man
auf Dinge wie Gleicheit (\code{==}) gr\"o{\ss}er oder kleiner als
(\code{>}, \code{<}) testen. 

\begin{table}[th]
  \titlecaption{\label{relationaloperators}
    Relationale Operatoren in \matlab.}{}
  \begin{center}
    \begin{tabular}{c|c}
      \hline
      \textbf{Operator} & \textbf{Beschreibung} \\ \hline
      $<$ & kleiner als\\
      $>$ &  gr\"osser als \\
      $==$ & gleich \\
      $>=$ & gr\"osser oder gleich \\
      $<=$ & kleiner oder gleich \\
      $\sim=$ & ungleich\\
      \hline
    \end{tabular}
  \end{center}
\end{table}

Das Ergebnis eines Booleschen Ausdrucks ist immer vom Datentyp
\codeterm{logical}. Man kann jede beliebige Variable zu wahr oder falsch
auswerten indem man in den Typ \code{logical} umwandelt. Dabei
werden von \matlab{} alle Werte, die nicht 0 sind als wahr
eingesch\"atzt. Listing \ref{booleanexpressions} zeigt einige
Beispiele. \matlab{} kennt die Schl\"usselworte \code{true} und
\code{false}. Diese sind jedoch nur Synonyme f\"ur die
\code{logical} Werte 1 und 0. Man beachte, dass der
Zuweisungsoperator \code{=} und der logische Operator \code{==} zwei
grundverschiedene Dinge sind. Da sie umgangsprachlich gleich sind kann
man sie leider leicht verwechseln.

\begin{lstlisting}[caption={Boolesche Ausdr\"ucke.}, label=booleanexpressions]
  >> true
  ans =
  1
  >> false
  ans =
  0
  >> logical(1)
  ans = 
  1
  >> 1 == true
  ans =
  1
  >> 1 == false
  ans =
  0
  >> logical('test')
  ans =
  1   1   1   1

  >> 1 > 2
  ans = 
  0
  >> 1 < 2
  ans =
  1
  >> x = [2 0 0 5 0] & [1 0 3 2 0]
  x =
  1     0     0     1     0

  >> ~([2 0 0 5 0] & [1 0 3 2 0])
  ans =
  0     1     1     0     1 

  >> [2 0 0 5 0] | [1 0 3 2 0]
  ans =
  1     0     1     1     0 
\end{lstlisting}


\section{Logisches Indizieren}\label{logicalindexingsec}

Einer der wichtigsten Einsatzorte f\"ur Bollesche Ausdr\"ucke ist das
logische Indizieren. Das logische Indizieren ist eines der
Schl\"usselkonzepte in \matlab{}. Nur mit diesem k\"onnen
Filteroperationen auf Vektoren und Matrizen effizient durchgef\"uhrt
werden. Es ist sehr m\"achtig und, wenn es einmal verstanden wurde,
sehr intuitiv zu benuzten.

Das Grundkonzept hinter der logischen Indizierung ist, dass man durch
die Verwendung eines Booleschen Ausdrucks auf z.B. einen Vektor einen
logischen Vektor gleicher Gr\"o{\ss}e erh\"alt. Dieser wird nun
benutzt um auf den urspr\"unglichen Vektor zuzugreifen. \matlab{} gibt
nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
\codeterm{wahr} ist (Listing \ref{logicalindexing1}).


\begin{lstlisting}[caption={Beispiel logisches Indizieren.}, label=logicalindexing1]
  >> x = randn(10, 1);
  >> % in zwei Schritten
  >> x_smaller_zero = x < 0; % logischer vektor
  >> elements_smaller_zero = x(x_smaller_zero); % benutzen, um zuzugreifen 
  >> % oder in einem Schritt
  >> elements_smaller_zero = x(x < 0);
\end{lstlisting}

\begin{exercise}{logicalVector.m}{logicalVector.out}
  Erstelle einen Vektor x mit den Werten 0-10.
  \begin{enumerate}
  \item F\"uhre aus: \code{y = x < 5}
  \item Gib den Inhalt von \code{y} auf dem Bildschirm aus.
  \item  Was ist der Datentyp von \code{y}?
  \item  Gibt alle Elemente aus x zur\"uck, die kleiner als 5 sind.
  \end{enumerate}
  
  Die letzte Zeile kann wie folgt gelesen werden: Gib mir die Elemente
  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\"aufiger Fall ist
jedoch, dass die Auswahl aus einem Vektor auf dem 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}
  \titlecaption{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
  Zeitpunkte der Messung speichert und einen zweiten mit den
  jeweiligen Messwerten.
  
  \begin{itemize}
  \item Erstelle einen Vektor \code{t= 0:0.001:10;}, der z.B. die Zeit
    repr\"asentiert.
  \item Erstelle einen zweiten Vektor \code{x} mit Zufallszahlen der
    die gleiche L\"ange hat wie \code{t}. Die Werte darin stellen
    Messungen zu den Zeitpunkten in \code{t} dar.
  \item Benutze das logische Indizieren um die Messwerte
    auszuw\"ahlen, die dem zeitlichen Abschnitt 5-6\,s entsprechen.
  \end{itemize}
\end{exercise}


\section{Kontrollstrukturen}\label{controlstructsec}

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
Bedeutung sind hier zwei Strukturen:

\begin{enumerate}
\item Schleifen.
\item Bedingte Anweisungen und Verzweigungen.
\end{enumerate}

\subsection{Schleifen}

Schleifen werden gebraucht um wiederholte Ausf\"uhrung desselben Codes
zu vereinfachen.  In einer \"Ubung wurde die Fakult\"at von 5 wie in
Listing \ref{facultylisting} berechnet:

\begin{lstlisting}[caption={Berechnung der Fakult\"at von 5 in f\"unf
    Schritten}, label=facultylisting]
>> x = 1;
>> x = x * 2;
>> x = x * 3;  
>> x = x * 4;
>> x = x * 5;
>> x
x =
    120
\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; 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 \code{for} -- Schleife}

Der am h\"aufigsten benutzte Vertreter der Schleifen ist die
\codeterm{for-Schleife}. Sie besteht aus dem \codeterm{Schleifenkopf} und
dem \codeterm{Schleifenk\"orper}. Der Kopf regelt, wie h\"aufig der Code
im K\"orper ausgef\"uhrt wird.  Der Schleifenkopf beginnt mit dem
Schl\"usselwort \code{for} auf welches folgend die
\codeterm{Laufvariable} definiert wird. In \matlab ``l\"auft''/iteriert
eine for-Schleife immer(!) \"uber einen Vektor. Die
\codeterm{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
\code{end} beendet. Listing \ref{looplisting} zeigt das
Grundger\"ust einer for-Schleife.

\begin{lstlisting}[caption={Beispiel einer \code{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 \code{while} -- Schleife}

Eine weiterer Schleifentyp, der weniger h\"aufig eingesetzt wird, ist
die \code{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. Der Schleifenkopf beginnt mit dem Schl\"usselwort
\code{while} gefolgt von einem \underline{Booleschen
  Ausdruck}. Solange dieser zu \code{true} ausgewertet werden kann,
wird der Code im Schleifenk\"orper ausgef\"uhrt.  Die Schleife wird
mit dem Schl\"usselwort \code{end} beendet.


\begin{lstlisting}[caption={Grundstruktur einer \code{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 \code{while}-Schleife.
\end{exercise}


\begin{exercise}{neverendingWhile.m}{}
  Implementiere eine \code{while}-Schleife, die unendlich
  l\"auft. Tipp: wenn der Boolesche Ausdruck hinter dem \code{while}
  zu wahr ausgewertet wird, wird die Schleife weiter ausgef\"uhrt.
\end{exercise}


\subsubsection{Vergleich \code{for} -- und \code{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.  % XXX Nur wenn die Liste im Kopf nicht leer ist, oder ?
\item Der K\"orper einer \code{while} Schleife wird nur dann betreten,
  wenn die Bedingung im Kopf \code{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 \code{if} -- Anweisung}

Am h\"aufigsten genutzter Vertreter ist die \code{if} -
Anweisung. Sie Wird genutzt um Programmcode nur unter bestimmten
Bedingungen auszuf\"uhren. 

Der Kopf der if - Anweisung beginnt mit dem Schl\"usselwort \code{if}
welches von einem \underline{Booleschen Ausdruck} gefolgt wird. Wenn
dieser zu \code{true} ausgewertet werden kann, wird der Code im
K\"orper der Anweisung ausgef\"uhrt.  Optional k\"onnen weitere
Bedingungen mit dem Schl\"usselwort \code{elseif} folgen.  Ebenfalls
optional ist die Verwendung eines finalen \code{else} Falls. Dieser
wird immer dann ausgef\"uhrt wenn alle vorherigen Bedingungen nicht
erf\"ullt werden.  Die \code{if} Anweisung wird mit \code{end}
beendet. Listing \ref{ifelselisting} zeigt den Aufbau einer
if-Anweisung.
  

\begin{lstlisting}[label=ifelselisting, caption={Grundger\"ust einer \code{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 \code{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{exercise}

\subsubsection{Die \code{switch} -- Verzweigung} 

Die \code{switch} Verzweigung Wird eingesetzt wenn mehrere F\"alle
auftreten k\"onnen, die einer unterschiedlichen Behandlung bed\"urfen.

Wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von der
\codeterm{switch Anweisung} (Zahl oder String). Jeder Fall auf den die
Anweisung \"uberpr\"ft werden soll wird mit dem Schl\"usselwort
\code{case} eingeleitet. Diese wird gefolgt von der \codeterm{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 \code{otherwise} alle nicht explizit genannten
F\"alle behandelt werden.  Die \code{switch} Anweisung wird mit
\code{end} beendet (z.B. in Listing \ref{switchlisting}).


\begin{lstlisting}[label=switchlisting, caption={Grundger\"ust einer \code{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 \code{case} auf \underline{Gleichheit} der
switch-Anweisung und der case-Anweisung getestet wird.


\subsubsection{Vergleich \code{if} -- Anweisung  und \code{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 \code{break} und
\code{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 Code-Abschnitten in Schleifen 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 Elemente 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 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\"Ur 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 \codeterm{m-files} gespeichert
(z.B. \filename{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
\codeterm{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 \codeterm{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 \code{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  %XXX es ist vielleicht optional, aber gute stil ware es immer hinzuschreiben, oder?
 mit einem \code{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 Variablen im Workspace sind in der Funktion \emph{nicht} sichtbar.
  \item Variablen, die in der Funktion definiert werden erscheinen
    \emph{nicht} im Workspace.
  \end{itemize}
\item Erh\"oht 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}
Das obige 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 geeignet.
\item Was sie tut, ist festgelegt und kann von au{\ss}en nicht
  beeinflusst oder bestimmt werden.
\item Sie tut drei Dinge aus einmal: Sinus berechnen \emph{und}
  Amplituden \"andern \emph{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 mu{\ss} definiert werden
was das zu l\"osende Problem ist:
\begin{enumerate}
\item Welches Problem soll gel\"ost werden?
\item Aufteilen in Teilprobleme. 
\item Gute Namen finden.
\item Definieren der Schnittstellen --- Was m\"ussen die beteiligten Funktionen
  wissen? Was sollen sie zur\"uckliefern?
\item Daten zur\"uck geben (R\"uckgabewerte definieren). 
\end{enumerate}
Das Beispielproblem aus Listing \ref{badsinewavelisting} kann in drei
Teilprobleme aufgetrennt werden. (i) Berechnen der \emph{einzelnen}
Sinusse. (ii) Plotten der jeweils berechneten Daten und (iii)
Koordination von Berechnung und Darstellung mit unterschiedlichen
Amplituden. 

\paragraph{I. Berechnung eines einzelnen Sinus}

Die Berechnung eines einzelnen Sinus ist ein typischer Fall f\"ur eine
Funktion. Wiederum macht man sich klar, (i) wie die Funktion
hei{\ss}en soll, (ii) welche Information sie ben\"otigt und (iii)
welche Daten sie zur\"uckliefern soll. 

\begin{enumerate}
\item \codeterm{Name:} der Name sollte schon beschreiben, was die Funktion
  tut. In diesem Fall berechnet sie einen Sinus. Ein geeigneter Name
  w\"are also \code{calculate\_sinwave}.
\item \codeterm{Argumente:} die zu brechnende Sinusschwingung sei durch
  ihre Frequenz und die Amplitude bestimmt. Des Weiteren soll noch
  festgelegt werden, wie lang der Sinus sein soll und mit welcher
  zeitlichen Aufl\"osung gerechnet werden soll. Es werden also vier
  Argumente ben\"otigt, sie k\"onnten hei{\ss}en: \code{amplitude},
    \code{frequency}, \code{t\_max}, \code{t\_step}.
\item \codeterm{R\"uckgabewerte:} Um den Sinus korrekt darstellen zu k\"onnen brauchen wir die
  Zeitachse und die entsprechenden Werte. Es werden also zwei
  Variablen zur\"uckgegeben: \code{time, sine}
\end{enumerate}
Mit dieser Information ist es nun gut m\"oglich die Funktion zu
implementieren (Listing \ref{sinefunctionlisting}).

\begin{lstlisting}[caption={Funktion, die einen Sinus berechnet.}, label=sinefunctionlisting]
function [time, sine] = calculate_sinewave(frequency, amplitude, t_max, t_step)
   % The function calculates a sinewave with a given frequency and
   % amplitude. 
   % Arguments: frequency, the frequency of the sine
   %            amplitude, the amplitude of the sine
   %            t_max, the duration of the sine in seconds
   %            t_step, the temporal resolution in seconds
   % Returns:   time, the time axis
   %            sine, the calculated sinewave
   time = (0:t_step:t_max);
   sine = sin(frequency .* time .* 2 * pi) .* amplitude;
\end{lstlisting}
  

\paragraph{II. Plotten einer einzelnen Schwingung}
Diese Aufage kann auch von einer Funktion \"ubernommen werden. Diese
Funktion hat keine andere Aufgabe, als die Daten zu plotten. Ihr Name
sollte sich an dieser Aufgabe orientieren
(z.B. \code{plot\_sinewave}). Um einen einzelnen Sinus zu plotten
werden im Wesentlichen die x-Werte und die zugeh\"origen y-Werte
ben\"otigt. Da mehrere Sinus geplottet werden sollen ist es auch
sinnvoll eine Zeichenkette f\"ur die Legende an die Funktion zu
\"ubergeben. Da diese Funktion keine Berechnung durchf\"uhrt wird kein
R\"uckgabewert ben\"otigt (Listing \ref{sineplotfunctionlisting}).

\begin{lstlisting}[caption={Funktion, die die Daten plottet.}, label=sineplotfunctionlisting]
function plot_sinewave(x_data, y_data, name)
  % Plots x-data against y-data and sets the display name.
  % Arguments: x_data, the x-data
  %            y_data, the y-data
  %            name, the displayname
  plot(x_data, y_data, 'displayname', name) 
\end{lstlisting}


\paragraph{III. Erstellen eines Skriptes zur Koordinierung}
Die letzt Aufgabe ist die Koordinierung der Berechung und des Plottens
f\"ur mehrere Amplituden. Das ist die klassische Aufgabe f\"ur ein
Skript. Auch hier gilt es einen ausdrucksvollen Name zu finden. Da es
keine Argumente und R\"uckgabewerte gibt bleibt und nur, die
ben\"otigten Information direkt in dem Skript zu defninieren. Dies
sind: ein Vektor, f\"ur die Amplituden, je eine Variable f\"ur die
gew\"unschte Frequenz, die maximale Zeit auf der x-Achse und die
zeitliche Aufl\"osung. Das Skript \"offnet schlie{\ss}lich noch eine
neue Abbildung und setzt das \code{hold on} da nur das Skript
wei{\ss}, das mehr als ein Plot erzeugt werden soll. Das Skript ist in
Listing \ref{sinesskriptlisting} dargestellt.

\begin{lstlisting}[caption={Kontrollskript, das die Berechnung und plotting koordiniert.}, label=sinesskriptlisting]
amplitudes = 0.25:0.25:1.25;
frequency = 2;
t_max = 10;
t_step = 0.01;
    
figure()
hold on
 
for i = 1:length(amplitudes)
  [x_data, y_data] = calculate_sinewave(frequency, amplitudes(i), ... 
                                        t_max, t_step);
  plot_sinewave(x_data, y_data, sprintf('freq: %5.2f, ampl: %5.2f',...
                                         frequency, amplitudes(i)))
end
legend('show')
\end{lstlisting}

\begin{exercise}{plotMultipleSinewaves.m}{}
  Erweitert das Programm so, dass auch ein Satz von Frequenzen benutzt
  wird.
\end{exercise}

\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 Aussagen klingen, als ob Skripte zu
verteufeln w\"aren und und vermieden werden sollten. Dem ist nicht
so. In Wahrheit sind sie daf\"ur gemacht, Hand in Hand mit den
Funktionen 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 (Abbildung
\ref{programlayoutfig}).

\begin{figure}
  \includegraphics[width=0.5\columnwidth]{./images/simple_program.pdf}
  \titlecaption{Ein typisches Programmlayout.}{Das Kontrollskript
    koordiniert den Aufruf der Funktionen, \"ubergibt Argumente und
    nimmt R\"uckgabewerte entgegen.}\label{programlayoutfig}
\end{figure}
