%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 
\chapter{Programming in Python}

Python is a rather young and very dynamic programming languages which
attracts more and more users in the sciences. One of the reasons is
that python is an expressive language, that means, the program code
can often be literally read and understood. Another aspect is the
strong community support. Most packages are developed by open-source
enthusiasts who are willing to share their code and knowledge thus,
answers to most problems can be found with a simple internet search.

\begin{important}[What is Python?]
  It is important to understand what Python is and what it is
  not. After installing python on a machine, one may expect to find an
  elaborated graphical user interface or so called \enterm{Integrated
    Development Environment, IDE} as e.g known in \matlab{}. You can
  have it, if you want but this is not the Python core. Python is a
  programming language, it defines the \enterm{syntax}, the grammar
  and the keywords of the language, as well as the
  \enterm{interpreter} that interprets your commands and executes
  them. With the installation you get the python interpreter that,
  called to work will open a console interface that can be used to
  execute commands. Throughout the whole introduction we will use a
  python console, or the command line. All examples should work with
  the simplest python console. It is, however, nicer to use e.g. the
  \emph{ipython} console for it offers some more convenience
  methods. For bigger programs IDEs (e.g. spyder, pycharm, etc. ) come
  in handy but they are building on top of Python, they are not
  Python.
\end{important}

\section{Variables and Datatypes}

Befor we can start to solve programming problems we have to know a few
basic things about the programming language. In this chapter the
basic concepts and the python syntax will be introduced.  

\subsection{Variables}

A \enterm{variable} is basically a pointer to a place in a computer's
memory. This pointer has a human readable name, or label, and a
\enterm{data type} (figure \ref{variablefig}). In the memory the
variable's content is encoded as a pattern of \enterm[bit]{bits} (a
sequence of zeros and ones). Upon access of the variable's content the
stored data type is used to interpret the \enterm{bit pattern}. That
is, the same bit pattern may be interpreted in different ways
depending on the data type. In the example shown in figure
\ref{variablefig} the same bitpattern is stored but the interpretation
as an 8-bit \enterm{integer} leads to the numeric value of 38 while an
interpretation as a \enterm{character} lead to the ampersand symbol.

\begin{figure}
  \centering
  \begin{subfigure}{.5\textwidth}
    \includegraphics[width=0.9\textwidth]{variable}
    \label{variable:a}
  \end{subfigure}%
  \begin{subfigure}{.5\textwidth}
    \includegraphics[width=.9\textwidth]{variableB}
    \label{variable:b}
  \end{subfigure}
  \titlecaption{Variables.}{Variables are Pointers to a memory address
    in the memory of the computer. These pointers have names and store
    the data type of the stored value. The value itself is
    represented as a binary pattern of zeros and ones (a
    bit pattern). Depending on the data type, the readout of the same
    bit pattern leads to very different results.}\label{variablefig}
\end{figure}


\subsection{Creation of variables}
Variables can be created at any time at any place in a python
program. Listing \ref{varListing1} shows different ways to do this:

\begin{lstlisting}[label=varListing1, caption={Creating variables.}, language=python]
In[0]: w = 3.1415
In[1]: x = 38
In[2]: y = 'A'
In[3]: z = None
\end{lstlisting}

Line one creates a simple variable named 'w' that contains the value
$3.14.15$. The command can be read as ``Create a variable named
\varcode{w} and assign the value $3.1415$ to it.'' The equals sign in
this context is called the \codeterm{Assignment operator} that is used
when a value is \emph{assigned} to a variable.  The following lines
create further variables containing differen values. Python belongs to
the class of so called \codeterm[interpreted language]{interpreted
  languages}, i.e. a command (like those in listing\ref{varListing1})
is prompted, the Python \coderterm{interpreter} executes it, creates
the variable, checks for the type of data to be stored and assigns the
value. If we want to check for the variables that have been created or
find out their data type we can ask for this information by the
commands in listing \ref{varListing2}

\begin{lstlisting}[label=varListing2, caption={Checking for variables and data types.}]
In [4]: who
w	x	y	z	

In[5]: whos
Variable   Type        Data/Info
--------------------------------
w          float       3.1415
x          int         38
y          str         A
z          NoneType    None

In[6]: type(w)
Out[6]: float

In[7]: type(x)
Out[7]: int
\end{lstlisting}

To simply list the names of all \enterm{declared} variables, the command \code{who} can be used, in the \emph{ipython}
Der Datentyp einer Variable kann mit \code{class()} abgefragt werden.
Eine Liste aller definierten Variablen gibt \code{who}
zur\"uck. Detailliertere Informationen \"uber Variablen zeigt
\code{whos} an.

\begin{lstlisting}[label=varListing2, caption={Erfragen des Datentyps einer Variable, Listen aller definierten Variablen.}]
>>class(x)
ans =
      double

>> who
Your variables are:

x  y  z 

>> whos
  Name      Size            Bytes  Class     Attributes

  x         1x1                 8  double              
  y         0x0                 0  double              
  z         1x1                 2  char                
\end{lstlisting}

\begin{important}[Namen von Variablen]
  Bei der Namensgebung ist zu beachten, dass \matlab{} auf Gro{\ss}-
  und Kleinschreibung achtet und ein Variablenname mit einem
  alphabetischen Zeichen beginnen muss. Umlaute, Sonder- und
  Leerzeichen sind in Variablennamen nicht erlaubt.
\end{important}

\subsection{Arbeiten mit Variablen}

Nat\"urlich kann mit den Variablen auch gearbeitet, bzw. gerechnet
werden. \matlab{} kennt alle normalen
\codeterm[Operator!arithmetischer]{arithmetischen Operatoren} wie
\code[Operator!arithmetischer!1add@+]{+},
\code[Operator!arithmetischer!2sub@-]{-},
\code[Operator!arithmetischer!3mul@*]{*} und
\code[Operator!arithmetischer!4div@/]{/}. Die Potenz wird \"uber das
Dachsymbol \code[Operator!arithmetischer!5pow@\^{}]{\^{}}
dargestellt. Listing \ref{varListing3} zeigt, wie sie benutzt werden.

\pagebreak[4]
\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      % loesche die Variable z
\end{lstlisting}

Beachtenswert ist in Zeilen 2 und 6, dass mit dem Inhalt einer
Variablen gerechnet werden kann, ohne dass dadurch ihr Wert
ver\"andert wird. Wenn der Wert einer Variablen ver\"andert werden
soll, dann muss der neue Wert explizit einer Variablen zugewiesen werden
(mit dem \code[Operator!Zuweisung!=]{=} Zuweisungsoperator,
z.B. Zeilen 14 und 18). Zeile 23 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:
\begin{itemize}
\item \codeterm{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 (siehe
Tabelle~\ref{dtypestab}).

\begin{table}[t]
  \centering
  \titlecaption{Grundlegende numerische Datentypen und ihr Wertebereich.}{}
  \label{dtypestab}
  \begin{tabular}{llcl}\hline
    Datentyp & Speicherbedarf & Wertebereich & Beispiel \erh \\ \hline
    \code{double} & 64 bit & $\approx -10^{308}$ bis $\approx 10^{308} $&  Flie{\ss}kommazahlen.\erb\\
    \code{int} & 64 bit & $-2^{31}$ bis $2^{31}-1$ &  Ganzzahlige Werte  \\
    \code{int16} & 16 bit & $-2^{15}$ bis $2^{15}-1$ & Digitalisierte Spannungen. \\
    \code{uint8} & 8 bit & $0$ bis $255$ & Digitalisierte Imaging Daten. \\ \hline  
  \end{tabular}
\end{table}

\matlab{} arbeitet meist mit dem \codeterm{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
  \code{int16} anstelle der \code{double} Werte im Rechner abzulegen.  Die
  Daten als Spannungswerte, 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 hei{\ss}en sie ein-
bzw. mehrdimensionalen Felder. Felder sind Datenstrukturen, die
mehrere Werte des gleichen Datentyps in einer Variablen vereinen. Da
\matlab{} seinen Ursprung in der Verarbeitung von mathematischen
Vektoren und Matrizen hat, werden sie hier auch so genannt. Dabei
macht \matlab{} intern 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 \varcode{a}
enth\"alt im Beispiel in Abbildung \ref{vectorfig} 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 Spaltenvektoren
    (columnvector).}\label{vectorfig}
\end{figure}

Das folgende Listing \ref{generatevectorslisting} zeigt, wie Vektoren erstellt
werden k\"onnen.

\begin{lstlisting}[label=generatevectorslisting, 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 Funktionen \code{length()} und \code{numel()}
bestimmt werden. \"Ahnliche Information kann \"uber die Funktion
\code{size()} erhalten werden (Listing \ref{vectorsizeslisting}). Der
Vektor \varcode{a} von oben hat folgende Gr\"o{\ss}en:

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

Die Ausgabe der \code{size()}-Funktion zeigt, dass Vektoren im Grunde
2-dimensional sind. Bei einem Zeilenvektor hat die erste Dimension die
Gr\"o{\ss}e 1. \code[length()]{length(a)} gibt die l\"angste
Ausdehnung an. Im folgenden Listing \ref{columnvectorlisting} transponiert der
\code[Operator!Matrix!']{'} - Operator einen Spaltenvektor
zu einem Zeilenvektor (Zeilen 14 ff.).

\begin{lstlisting}[label=columnvectorlisting, 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
b = 
    1   2   3   4   5   6   7   8   9  10

>> size(b)
ans =
      1  10
\end{lstlisting}


\subsubsection{Zugriff auf Inhalte von Vektoren}
\begin{figure}
  \includegraphics[width=0.4\columnwidth]{arrayIndexing_py}
  \titlecaption{Indices von Vektoren.}{Jedes Feld eines Vektors hat
    einen Index (kleine Zahl) mit dem auf den jeweiligen Inhalt
    (gro{\ss}e Zahl) 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}[Indizieren]
  Der Zugriff auf Inhalte eines Vektors mittels seines Indexes wird
  Indizieren genannnt.

  Der Index des ersten Elements eines Vektors ist in \matlab{} die Eins.

  Der Index des letzten Elements entspricht der L\"ange des Vektors.
\end{important}

Die Listings \ref{vectorelementslisting} und \ref{vectorrangelisting} zeigen wie
mit Indexen auf die Inhalte eines Vektors zugegriffen werden kann.
Hierbei kann auf einzelne Werte zugegriffen werden oder, analog zur
Erzeugung von Vektoren, die \code[Operator!Matrix!:]{:} Notation
verwendet werden, um auf mehrere Element gleichzeitig zuzugreifen.

\begin{lstlisting}[label=vectorelementslisting, caption={Zugriff auf den Inhalt von Vektoren: einzelne Elemente}]
>> a = (11:20)
a = 
    11    12    13    14    15    16    17    18    19    20

>> a(1)     % das 1. Element
ans = 11 

>> a(5)     % das 5. Element
ans = 15

>> a(end)   % das letzte Element
ans = 20
\end{lstlisting}

\begin{lstlisting}[caption={Zugriff auf den Inhalt von Vektoren: Bereiche}, label=vectorrangelisting]
>> 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

>> a(:)         % alle Elemente als Zeilenvektor
ans = 
      11  12  13  14  15  16  17  18  19  20
\end{lstlisting}

\begin{exercise}{vectorsize.m}{vectorsize.out}
  Der R\"uckgabewert von \code[size()]{size(a)} ist wieder ein Vektor der
  L\"ange 2. Wie k\"onnte also die Gr\"o{\ss}e von \varcode{a} in der
  zweiten Dimension herausgefunden werden?
\end{exercise}

\subsubsection{Operationen auf Vektoren}

Mit Vektoren kann sehr einfach gerechnet werden. Listing
\ref{vectorscalarlisting} zeigt die Verrechnung von Vektoren mit Skalaren
mit den Operatoren \code[Operator!arithmetischer!1add@+]{+},
\code[Operator!arithmetischer!2sub@-]{-},
\code[Operator!arithmetischer!3mul@*]{*},
\code[Operator!arithmetischer!4div@/]{/}
\code[Operator!arithmetischer!5pow@.\^{}]{.\^}.

\begin{lstlisting}[caption={Rechnen mit Vektoren und Skalaren.},label=vectorscalarlisting]
>> a = (0:2:8)
a =
      0   2   4   6   8

>> a + 5           % Addition von einem Skalar
ans =
      5   7   9  11  13

>> a - 5           % Subtraktion von einem Skalar
ans =
     -5  -3  -1   1   3

>>  a * 2          % Multiplikation mit einem Skalar
ans =
      0   4   8  12  16

>> a / 2           % Division mit einem Skalar
ans =
      0   1   2   3   4

>> a .^ 2           % Potenzierung mit einem Skalar
ans =
      0   4  16  36  64
\end{lstlisting}

Bei der elementweisen Verrechnung von zwei Vektoren muss
sichergestellt werden, dass sie die gleiche L\"ange und das gleiche
Layout (Spalten- oder Zeilenvektor) haben. Addition und Subtraktion
erfolgt immer elementweise (Listing~\ref{vectoradditionlisting}).

\begin{lstlisting}[caption={Elementweise Addition und Subtraktion von
    Vektoren.},label=vectoradditionlisting]
>> a = [4   9  12];
>> b = [4   3   2];
>> a + b           % Addition von 2 Vektoren
ans = 
        8  12  14

>> a - b           % Subtraktion von 2 Vektoren
ans = 
        0   6  10

>> c = [8   4];
>> a + c           % Beide Vektoren muessen gleich gross sein!
Error using +
Matrix dimensions must agree.
>> d = [8;  4; 2];
>> a + d           % Beide Vektoren muessen das gleiche Layout haben!
Error using +
Matrix dimensions must agree.
\end{lstlisting}

Bei der Multiplikation, der Division und der Potenzierung mu{\ss} mit
vorangestellem '.'  angezeigt werden, dass es sich um eine
\emph{elementweise} Verarbeitung handeln soll. F\"ur diese
elementweisen Operationen kennt \matlab{} die Operatoren
\code[Operator!arithmetischer!3mule@.*]{.*},
\code[Operator!arithmetischer!4dive@./]{./} und
\code[Operator!arithmetischer!5powe@.\^{}]{.\^{}} 
(Listing~\ref{vectorelemmultiplicationlisting}).

\begin{lstlisting}[caption={Elementweise Multiplikation, Division und
    Potenzierung von Vektoren.},label=vectorelemmultiplicationlisting]
>> a .* b           % Elementweise Multiplikation
ans = 
       16    27    24 

>> a ./ b           % Elementweise Division
ans = 
        1     3     6

>> a ./ b           % Elementweise Potenzierung
ans = 
      256   729   144

>> a .* c           % Beide Vektoren muessen gleich gross sein!
Error using .*
Matrix dimensions must agree.
>> a .* d           % Beide Vektoren muessen das gleiche Layout haben!
Error using .*
Matrix dimensions must agree.
\end{lstlisting}

Die einfachen Operatoren \code[Operator!arithmetischer!3mul@*]{*},
\code[Operator!arithmetischer!4div@/]{/} und
\code[Operator!arithmetischer!5pow@\^{}]{\^{}} sind mit den
entsprechenden Matrixoperationen aus der linearen Algebrar belegt (Box
\ref{matrixmultiplication}). Insbesondere ist die Multiplikation eines
Zeilenvektors $\vec a$ mit einem Spaltenvektor $\vec b$ das Skalarprodukt
$\sum_i = a_i b_i$.

\begin{lstlisting}[caption={Multiplikation von Vektoren.},label=vectormultiplicationlisting]
>> a * b            % Multiplikation zweier Zeilenvektoren
Error using  * 
Inner matrix dimensions must agree.
>> a' * b'          % Multiplikation zweier Spaltenvektoren
Error using  * 
Inner matrix dimensions must agree.

>> a * b'           % Multiplikation Zeilenvektor mit Spaltenvektor
ans = 
      67

>> a' * b           % Multiplikation Spaltenvektor mit Zeilenvektor
ans = 
    16    12     8
    36    27    18
    48    36    24
\end{lstlisting}

\pagebreak[4]
Zum Entfernen von Elementen aus einem Vektor, wird den
entsprechenden Zellen ein leeren Wert (\code[Operator!Matrix!{[]}]{[]}) zugewiesen:
\begin{lstlisting}[label=vectoreraselisting, 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]) = []   % loesche das erste und dritte Element
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{vectorinsertlisting}, Zeile
10). Zum Erweitern eines Vektors kann \"uber das Ende hinaus
zugewiesen werden (Zeile 20). \matlab{} erweitert dann die Variable
entsprechend.  Dieser Vorgang ist rechenintensiv da der ganze Vektor
an eine neue Stelle im Arbeitsspeicher kopiert wird und sollte, soweit
m\"oglich, vermieden werden.

\begin{lstlisting}[caption={Zusammenf\"ugen und Erweitern von Vektoren.}, label=vectorinsertlisting]
>> a = [4  3   2  1];
>> b = [10 12 14 16];
>> c = [a b]        % erstelle einen Vektor aus einer Liste von Vektoren
c =  
     4     3     2     1    10    12    14    16
>> length(c) 
ans = 8
>> length(a) + length(b) 
ans = 8

>> c = [a b'];           % Vektorlayout muss uebereinstimmen
Error using horzcat
Dimensions of matrices being concatenated are not consistent.

>> a(1:3) = [5  6  7]    % Weise den ersten drei Elementen neue Werte zu
a =
     5     6     7     1
>> a(1:3) = [1 2 3 4];   % Laenge der Vektoren muss uebereinstimmen
In an assignment  A(I) = B, the number of elements in B and I must be the same. 

>> a(3:6) = [1  2  3  4] % Zuweisung ueber die Laenge des Vektors hinweg
a =
     5     6     1     2     3     4
\end{lstlisting}


\subsection{Matrizen}

Vektoren sind 1-dimensionale Spezialf\"alle von $n$-dimensionalen
Matrizen. Matrizen k\"onnen in \matlab{} beliebig viele Dimensionen
haben. 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[Operator!Matrix!{[]}]{[]} eingeschlossen. Das
Semikolon \code[Operator!Matrix!;]{;} 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, 4, 2)
b(:,:,1) =
     1     1     1     1
     1     1     1     1
     1     1     1     1
b(:,:,2) =
     1     1     1     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). Die \code{cat()}-Funktion kann
mehrdimensionale Matrizen zusammenzuf\"ugen.

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. Die \code{size()}-Funktion
gibt dagegen die L\"ange jeder Dimension als Vektor zur\"uck.

\begin{figure}
  \includegraphics[width=0.9\columnwidth]{matrixIndexing_py}
  \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{subscript indexing} genannt. Dabei bestimmt die errste Zahl
die Zeilennumer, die zweite die Splatennumer.

\begin{lstlisting}[caption={Zugriff auf Inhalte von Matrizen,
    Indizierung.}, label=matrixIndexing]
>> x=rand(3,4)  % 2-D Matrix mit Zufallszahlen mit 3 Zeilen und 4 Spalten
x =
    0.8147    0.9134    0.2785    0.9649
    0.9058    0.6324    0.5469    0.1576
    0.1270    0.0975    0.9575    0.9706
>> size(x)
ans =
     3     4

>> x(1,1)       % obere linke Ecke
ans =
    0.8147
>> x(2,3)       % Element der 2. Zeile, 3. Spalte
ans =
    0.5469

>> x(1,:)       % erste Zeile
ans =
    0.8147    0.9134    0.2785    0.9649
>> x(:,2)       % zweite Spalte
ans =
    0.9134
    0.6324
    0.0975
\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 lineare
Index einer Zelle reicht von 1 bis \code{numel()} 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 Indizierens, z.B. zum Ermitteln des kleinsten
Wertes in einer Matrize.

\begin{figure}
  \includegraphics[width=0.9\columnwidth]{matrixLinearIndexing}
  \titlecaption{Lineares Indizieren 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 Indizieren 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))) % Minimum ueber die Zeilen, Spalten, Blaetter... 
ans = 
4
>> min(x(:))        % oder so
ans = 
4
\end{lstlisting}

\begin{ibox}[t]{\label{matrixmultiplication} Matrixmultiplikation.}
  Die Matrixmuliplikation aus der linearen Algebra ist nicht eine
  elementweise Multiplikation.  Die Matrixmultiplikation ist nur dann
  m\"oglich, wenn die Anzahl Spalten der ersten Matrize gleich der
  Anzahl Zeilen in der zweiten Matrize ist. Formaler: zwei Matrizen
  $\mathbf{A}$ und $\mathbf{B}$ k\"onnen mulipiziert $(\mathbf{A}
  \cdot \mathbf{B})$ werden, wenn $\mathbf{A}$ die Gr\"o{\ss}e $(m \times n)$ und
  $\mathbf{B}$ die Gr\"o{\ss}e $(n \times k)$ hat. Die Mulitplikation ist
  m\"oglich wenn die \determ{inneren Dimensionen} $n$ gleich sind.

  Dann sind die Elemente $c_{i,j}$ des Matrixprodukts $\mathbf{C} =
  \mathbf{A} \cdot \mathbf{B}$ gegeben durch das Skalarprodukt jeder
  Zeile von $\mathbf{A}$ mit jeder Spalte aus $\mathbf{B}$:
  \[ c_{i,j} = \sum_{k=1}^n a_{i,k} \; b_{k,j} \; . \]

  Die Matrixmultiplikation ist im Allgemeinen auch nicht kommutativ:
  \[ \mathbf{A} \cdot \mathbf{B} \ne \mathbf{B} \cdot \mathbf{A} \; . \]

  Als Beispiel betrachten wir die beiden Matrizen
  \[\mathbf{A}_{(3 \times 2)} =  \begin{pmatrix} 1 & 2  \\ 5 & 4 \\ -2 & 3  \end{pmatrix} 
  \quad \text{und} \quad \mathbf{B}_{(2 \times 2)} = \begin{pmatrix}
    -1 & 2 \\ -2 & 5 \end{pmatrix} \; . \] 
  F\"ur das Produkt $\mathbf{A} \cdot \mathbf{B}$ stimmen die inneren
  Dimensionen der Matrizen \"uberein ($(3 \times 2) \cdot (2
  \times 2)$), die Matrixmultiplikation ist also m\"oglich. Nachdem
  $\mathbf{A}$ drei Zeilen und $\mathbf{B}$ zwei Spalten hat, hat das
  Ergebnis von $\mathbf{A} \cdot \mathbf{B}$ die Gr\"o{\ss}e $(3
  \times 2)$:
  \[ \mathbf{A} \cdot \mathbf{B} = \begin{pmatrix} 1 \cdot -1 + 2 \cdot -2 & 1 \cdot 2 + 2\cdot 5 \\
    5 \cdot -1 + 4 \cdot -2 & 5 \cdot 2 + 4 \cdot 5\\
    -2 \cdot -1 + 3 \cdot -2 & -2 \cdot 2 + 3 \cdot 5  \end{pmatrix}
  = \begin{pmatrix} -5 & 12 \\ -13 & 30 \\ -4 & 11\end{pmatrix} \; . \]

  Das Produkt $\mathbf{B} \cdot \mathbf{A}$ ist dagegen nicht
  definiert, da die inneren Dimensionen nicht \"ubereinstimmen
  ($(2 \times 2) \cdot (3 \times 2)$).
\end{ibox}

Beim Rechnen mit Matrizen gelten die gleichen Regeln wie bei
Vektoren. Matrizen k\"onnen solange elementweise miteinander
verrechnet werden, wie die Dimensionalit\"aten
\"ubereinstimmen. Wichtig ist auch hier wieder die Unterscheidung
zwischen elementweiser Multiplikation
(\code[Operator!arithmetischer!3mule@.*]{.*} Operator, Listing
\ref{matrixOperations} Zeile 10) oder Matrixmultiplikation
(\code[Operator!arithmetischer!3mul@*]{*} Operator, Listing
\ref{matrixOperations} Zeile 14, 17 und 21, Box~\ref{matrixmultiplication}).
Bei der Matrixmultiplikation m\"ussen die inneren Dimensionen der Matrizen \"ubereinstimmen
(Box~\ref{matrixmultiplication}).

\pagebreak[4]
\begin{lstlisting}[label=matrixOperations, caption={Zwei Arten der Multiplikation von Matrizen.}]
>> A = randi(5, [2, 3])   % 2-D Matrix 
A =
     1     5     3
     3     2     2
>> B = randi(5, [2, 3])   % dito
B =
     4     3     5
     2     4     5

>> A .* B           % elementweise Multiplikation
ans =
     4    15    15
     6     8    10
>> A * B            % Matrixmultiplikation 
Error using  * 
Inner matrix dimensions must agree. 
>> A * B'           % Matrixmultiplikation 
ans =
    34    37
    28    24
>> A' * B           % Matrixmultiplikation 
ans =
    10    15    20
    24    23    35
    16    17    25
\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 werden sie eingesetzt, um z.B. die
Beziehung zwischen Entit\"aten zu testen. Hierzu werden die
\codeterm{relationalen Operatoren} (\code[Operator!relationaler!>]{>},
\code[Operator!relationaler!<]{<},
\code[Operator!relationaler!==]{==},
\code[Operator!relationaler!"!]{!}, gr\"o{\ss}er als, kleiner als,
gleich und nicht) eingesetzt. Mehrere Ausdr\"ucke werden mittels der
\codeterm[Operator!logischer]{logischen Operatoren}
(\code[Operator!logischer!and1@\&]{\&}, \code[Operator!logischer!or1@{"|} {}]{|},
UND, ODER) verkn\"upft. Sie sind 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 Tabellen \ref{logicalandor} zeigen die Wahrheitstabellen f\"ur das
logische UND, das logische ODER und das logische XOR
(entweder-oder). 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.  Anders
ist das beim logischen ODER. Hier ist der gesamte Ausdruck wahr, wenn
sich der eine \emph{oder} der andere Ausdruck, oder beide Ausdr\"ucke
zu wahr auswerten lassen. Das auschlie{\ss}ende ODER (XOR) ist nur
wahr, wenn entweder der eine oder der andere Ausdruck wahr ist und ist
in \matlab{} als Funktion \code[xor()]{xor(A, B)} verf\"ugbar.

\begin{table}[tp]
  \titlecaption{Wahrheitstabellen logisches UND, ODER und XOR.}{}\label{logicalandor}
  \begin{tabular}{llll}
    \multicolumn{2}{l}{\multirow{2}{*}{}}  & \multicolumn{2}{c}{\textbf{B}} \\
    & \sffamily{\textbf{und}} & \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} \erb \\ 
    & \multicolumn{1}{l|}{falsch} & \multicolumn{1}{l}{\textcolor{red}{falsch}} & \textcolor{red}{falsch}      
  \end{tabular}
  \hfill
  \begin{tabular}{llll}
    \multicolumn{2}{l}{\multirow{2}{*}{}} & \multicolumn{2}{c}{\textbf{B}}      \\
    & \sffamily{\textbf{oder}} & \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}  \erb    \\
    & \multicolumn{1}{l|}{falsch} & \multicolumn{1}{l}{\textcolor{mygreen}{wahr}}     & \textcolor{red}{falsch}      
  \end{tabular}
  \hfill
  \begin{tabular}{llll}
    \multicolumn{2}{l}{\multirow{2}{*}{}} & \multicolumn{2}{c}{\textbf{B}}      \\
    & \sffamily{\textbf{xor}} & \multicolumn{1}{|c}{wahr} & falsch \\ \cline{2-4} 
    \multirow{2}{*}{\textbf{A}} & \multicolumn{1}{l|}{wahr}   & \multicolumn{1}{c}{\textcolor{red}{falsch}}     &  \textcolor{mygreen}{wahr}  \erb    \\
    & \multicolumn{1}{l|}{falsch} & \multicolumn{1}{l}{\textcolor{mygreen}{wahr}} & \textcolor{red}{falsch}      
  \end{tabular}
\end{table}

Tabelle \ref{logicalrelationaloperators} zeigt die logischen Operatoren, die in
\matlab{} definiert sind. Zu bemerken sind hier noch die
\code[Operator!logischer!and2@\&\&]{\&\&} und
\code[Operator!logischer!or2@{"|}{"|} {}]{||} 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 ausgewertet wird,
muss der zweite gar nicht mehr gepr\"uft werden. Die Verwendung der
\enterm{short-circuit} Versionen spart Rechenzeit, da die Ausdr\"ucke
nur sowei wie n\"otig ausgewertet werden. 

\begin{table}[t]
  \titlecaption{\label{logicalrelationaloperators}
    Logische (links) und relationale (rechts)  Operatoren in \matlab.}{}
  \begin{tabular}{cc}
    \hline
    \textbf{Operator} & \textbf{Beschreibung} \erh \\ \hline
    \varcode{$\sim$} & logisches NICHT \erb \\
    \varcode{$\&$} &  logisches UND\\
    \varcode{$|$} & logisches ODER\\
    \varcode{$\&\&$} & short-circuit logisches UND\\
    \varcode{$\|$} & short-circuit logisches ODER\\
    \hline
  \end{tabular}
  \hfill
  \begin{tabular}{cc}
    \hline
    \textbf{Operator} & \textbf{Beschreibung} \erh \\ \hline
    \varcode{$==$} & gleich \erb \\
    \varcode{$\sim=$} & ungleich\\
    \varcode{$>$} &  gr\"o{\ss}er als \\
    \varcode{$<$} & kleiner als \\
    \varcode{$>=$} & gr\"o{\ss}er oder gleich \\
    \varcode{$<=$} & kleiner oder gleich \\
    \hline
  \end{tabular}
\end{table}

Um Werte miteinander zu vergleichen gibt es die
\codeterm[Operator!relationaler]{relationalen Operatoren} (Tabelle
\ref{logicalrelationaloperators}). Mit ihnen kann man auf Dinge wie
Gleichheit (\varcode{==}) gr\"o{\ss}er oder kleiner als (\varcode{>},
\varcode{<}) testen.

\begin{important}[Zuweisungs- und Gleichheitsoperator]
  Der Zuweisungsoperator \code[Operator!Zuweisung!=]{=} und der
  logische Operator \code[Operator!logischer!==]{==} sind zwei
  grundverschiedene Dinge. Da sie umgangsprachlich gleich sind
  k\"onnen sie leider leicht verwechselt werden.
\end{important}

Das Ergebnis eines Booleschen Ausdrucks ist immer vom Datentyp
\codeterm{logical}. Jede beliebige Variable zu wahr oder falsch
ausgewertet werden indem diese in den Typ \code{logical} umgewandelt
wird. 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 Synonyme f\"ur die \code{logical} Werte 1 und
0.

\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 Boolesche Ausdr\"ucke ist das
logische Indizieren. Logisches 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 durch die
Verwendung eines Booleschen Ausdrucks auf z.B. einen Vektor ein
logischer Vektor gleicher Gr\"o{\ss}e zur\"uckgegeben wird. Dieser
wird benutzt um die Elemente des urspr\"unglichen Vektors
auszuw\"ahlen, bei denen der logische Vektor \codeterm{wahr} ist
(Listing \ref{logicalindexing1}).  Zeile 14 kann wie
folgt gelesen werden: Gib die Elemente von \varcode{x} an den
Stellen, an denen \varcode{x < 0} wahr ist, zur\"uck.

\begin{lstlisting}[caption={Beispiel logisches Indizieren.}, label=logicalindexing1]
>> x = randn(1, 6)              % Zeilenvektor mit 6 Zufallszahlen
x =
   -1.4023   -1.4224    0.4882   -0.1774   -0.1961    1.4193

>> % logisches Indizieren in zwei Schritten:
>> x_smaller_zero = x < 0                    % logischer Vektor
x_smaller_zero =
     1     1     0     1     1     0
>> elements_smaller_zero = x(x_smaller_zero) % benutzen, um zuzugreifen 
elements_smaller_zero =
   -1.4023   -1.4224   -0.1774   -0.1961

>> % logisches Indizieren in einem Schritten:
>> elements_smaller_zero = x(x < 0)
elements_smaller_zero =
   -1.4023   -1.4224   -0.1774   -0.1961
\end{lstlisting}

\begin{exercise}{logicalVector.m}{logicalVector.out}
  Erstelle einen Vektor \varcode{x} mit den Werten 0--10.
  \begin{enumerate}
  \item F\"uhre aus: \varcode{y = x < 5}
  \item Gib den Inhalt von \varcode{y} auf dem Bildschirm aus.
  \item  Was ist der Datentyp von \varcode{y}?
  \item  Gibt alle Elemente aus \varcode{x} zur\"uck, die kleiner als 5 sind.
  \end{enumerate}
  \pagebreak[4]
\end{exercise}

\begin{figure}[t]
  \includegraphics[width= 0.9\columnwidth]{logicalIndexingTime}
  \titlecaption{Beispiel f\"ur logisches Indizieren.}
    {Der rot markierte Abschnitt aus den Daten wurde indirekt
    mit logischem Indizieren auf dem Zeitvektor
    ausgew\"ahlt (\varcode{x(t > 5 \& t < 6)}).}\label{logicalindexingfig}
\end{figure}

Logisches Indizieren wurde oben so benutzt, dass die Auswahl auf dem
Inhalt desselben Vektors beruhte. Ein weiterer sehr h\"aufiger Fall
ist jedoch, dass die Auswahl aus einem Vektor auf dem Inhalt eines
zweiten Vektors basiert. Ein Beispiel ist, dass \"uber einen
gewissen Zeitraum Daten aufgenommen werden und aus diesen die Daten eines
bestimmten Zeitraums ausgew\"ahlt werden sollen (\figref{logicalindexingfig}).

\begin{exercise}{logicalIndexingTime.m}{}
  Angenommen es werden \"uber einen bestimmten Zeitraum Messwerte
  genommen. Bei solchen Messungen erh\"alt man einen Vektor, der die
  Zeitpunkte der Messung speichert und einen zweiten mit den
  jeweiligen Messwerten.
  
  \begin{itemize}
  \item Erstelle einen Vektor \varcode{t = 0:0.001:10;}, der die Zeit
    repr\"asentiert.
  \item Erstelle einen zweiten Vektor \varcode{x} mit Zufallszahlen, der
    die gleiche L\"ange hat wie \varcode{t}. Die Werte darin stellen
    Messungen zu den Zeitpunkten in \varcode{t} dar.
  \item Benutze 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 wiederholt oder nur
unter bestimmten Bedingungen ausgef\"uhrt werden sollen. 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 Wiederholungen einzelner
Zeilen oder ganzer 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 Wiederholungen die entscheidende
  \"Anderung auch wirklich vorzunehmen.
  \shortquote{Copy and paste is a design error.}{David Parnas}
\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 ein Fehler gemacht wurde, dann muss der Fehler in
  allen Wiederholungen korrigiert werden (sehr leicht wird dabei etwas
  \"ubersehen).
\item Verst\"andlichkeit: Solche Abschnitte sind schwerer zu lesen und
  schwer 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. Zum Anderen
  f\"uhrt Codeduplication zu langen, un\"ubersichtlichen Programmen.
\end{enumerate}
Alle Programmiersprachen bieten zur L\"osung dieses Problems die
Schleifen. Eine Schleife wird immer dann eingesetzt, wenn 
Abschnitte wiederholt ausgef\"uhrt werden sollen. 

\subsubsection{Die \code{for} -- Schleife}

Der am h\"aufigsten benutzte Vertreter der Schleifen ist die
\codeterm{for-Schleife}. Sie besteht aus dem
\codeterm[Schleife!Schleifenkopf]{Schleifenkopf} und dem
\codeterm[Schleife!Schleifenk{\"o}rper]{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 \varcode{for}-Schleife.}, label=looplisting]
>> for x = 1:3
     x
   end
% die Laufvariable x nimmt mit jeder Iteration der Schleife 
% einen Wert des Vektors 1:3 an:
     1
     2
     3
\end{lstlisting}


\begin{exercise}{facultyLoop.m}{facultyLoop.out}
  Wie k\"onnte Fakult\"at mit einer Schleife implementiert werden?
  Implementiere eine \code{for} Schleife, die die Fakul\"at von einer
  Zahl \varcode{n} berechnet.
\end{exercise}


\subsubsection{Die \varcode{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 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 \varcode{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.
  Das Programm kann mit \keycode{Ctrl+C} abgebrochen werden.
\end{exercise}


\subsubsection{Vergleich \varcode{for} -- und \varcode{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 (au{\ss}er wenn der Vektor im Schleifenkopf leer ist). 
\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 \varcode{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 \code{if} - Anweisung beginnt mit dem Schl\"usselwort \code{if}
welches von einem 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 wurden.  Die \code{if} - Anweisung wird mit \code{end}
beendet. Listing \ref{ifelselisting} zeigt den Aufbau einer
\code{if} - Anweisung.
  

\begin{lstlisting}[label=ifelselisting, caption={Grundger\"ust einer \varcode{if} Anweisung.}]
if x < y
   % fuehre diesen code aus wenn x < y
elseif x > y
   % etwas anderes soll getan werden fuer x > y
else
   % wenn x == y, wieder etwas anderes
end  
  \end{lstlisting}

\begin{exercise}{ifelse.m}{}
  Ziehe eine Zufallszahl und \"uberpr\"ufe mit einer geeigneten \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 (i) kleiner als 0.5, (ii) gr\"o{\ss}er oder gleich 0.5 aber kleiner
    als 0.75 oder (iii) gr\"o{\ss}er oder gleich 0.75 ist.
  \end{enumerate}
\end{exercise}

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

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

Sie wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von der
\codeterm{switch Anweisung} (Zahl oder String). Jeder Fall, auf den diese
Anweisung \"uberpr\"uft werden soll, wird mit dem Schl\"usselwort
\code{case} eingeleitet. Dieses wird gefolgt von der \codeterm{case
  Anweisung}, die definiert gegen welchen Fall auf
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 \varcode{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 Gleichheit der
switch-Anweisung und der case-Anweisung getestet wird.


\subsubsection{Vergleich \varcode{if} -- Anweisung  und \varcode{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 (Listings \ref{continuelisting}
und \ref{continuelisting} zeigen, wie sie eingesetzt werden k\"onnen).

\begin{lstlisting}[caption={Abbrechen von Schleifen mit \varcode{break}.}, label=breaklisting]
>> x = 1;
   while true
     if (x > 3)
       break;
     end
     disp(x);
     x = x + 1;
   end
% output:
     1
     2
     3
\end{lstlisting}

\begin{lstlisting}[caption={\"Uberspringen von Code-Abschnitten in Schleifen mit \varcode{continue}.}, label=continuelisting]
for x = 1:5 
  if(x > 2 & x < 5)
    continue;
  end
  disp(x);
end
% output:
     1
     2
     5
\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 \codeterm[Skript]{Skripte}
\item \codeterm[Funktion]{Funktionen}
\item \codeterm[Objekt]{Objekte} (werden wir hier nicht behandeln)
\end{enumerate}
Alle Programme werden in den sogenannten \codeterm{m-files} gespeichert
(z.B. \file{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 erzeugt 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[Funktion]{Funktionen}.

\subsection{Funktionen}

Eine Funktion in \matlab{} wird \"ahnlich zu einer mathematischen
Funktion definiert:
\[ y = f(x) \]
Die Funktion hat einen Namen $f$, sie \"uber das Argument $x$
einen Input und liefert ein Ergebnis in $y$ zur\"uck. Listing
\ref{functiondefinitionlisting} zeigt wie das in \matlab{} umgesetzt
wird.

\begin{lstlisting}[caption={Funktionsdefinition in \matlab{}}, label=functiondefinitionlisting]
function [y] = functionName(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={Ein schlechtes Beispiel einer Funktion, die eine Reihe Sinusse plottet.},label=badsinewavelisting]
function meineErsteFunktion() % 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
\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 auf 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 und 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[Funktion!Name]{Name}: der Name sollte beschreiben, was
  die Funktion tut. In diesem Fall berechnet sie einen Sinus. Ein
  geeigneter, kurzer Name w\"are also \code{sinewave()}.
\item \codeterm[Funktion!Argumente]{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: \varcode{amplitude}, \varcode{frequency},
  \varcode{t\_max}, \varcode{t\_step}.
\item \codeterm[Funktion!R{\"u}ckgabewerte]{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: \varcode{time}, \varcode{sine}
\end{enumerate}
Mit dieser Information ist es nun gut m\"oglich die Funktion zu
implementieren (Listing \ref{sinefunctionlisting}).

\begin{lstlisting}[caption={Funktion zur Berechnung eines Sinus.}, label=sinefunctionlisting]
function [time, sine] = sinewave(frequency, amplitude, t_max, t_step)
% Calculate a sinewave of a given frequency, amplitude, 
% duration and temporal resolution. 
%
% [time, sine] = sinewave(frequency, amplitude, t_max, t_step)
%
% 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: vector of the time axis
%   sine: vector of the calculated sinewave
   time = (0:t_step:t_max);
   sine = sin(frequency .* time .* 2 * pi) .* amplitude;
end
\end{lstlisting}
  

\paragraph{II. Plotten einer einzelnen Schwingung}
Das Plotten der berechneten Sinuschwingung 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{plotFunction()}). 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 zur graphischen Darstellung der Daten.}, label=sineplotfunctionlisting]
function plotFunction(x_data, y_data, name)
% Plots x-data against y-data and sets the display name.
%
% plotFunction(x_data, y_data, name)
%
% Arguments: 
%   x_data: vector of the x-data
%   y_data: vector of the y-data
%   name  : the displayname
  plot(x_data, y_data, 'displayname', name) 
end
\end{lstlisting}


\paragraph{III. Erstellen eines Skriptes zur Koordinierung}
Die letzte Aufgabe ist die Koordinierung der Berechung und des
Plottens f\"ur mehrere Amplituden. Das ist die klassische Aufgabe
f\"ur ein \codeterm{Skript}. Auch hier gilt es einen ausdrucksvollen
Name zu finden. Da es keine Argumente und R\"uckgabewerte gibt,
m\"ussen die ben\"otigten Informationen direkt in dem Skript
defniniert werden. Es werden ben\"otigt: 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 mit
\code{figure()} 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 zur Koordination von Berechnung und graphischer Darstellung.},label=sinesskriptlisting]
amplitudes = 0.25:0.25:1.25;
frequency = 2.0;
t_max = 10.0;
t_step = 0.01;

figure()
hold on
for i = 1:length(amplitudes)
  [x_data, y_data] = sinewave(frequency, amplitudes(i), ... 
                              t_max, t_step);
  plotFunction(x_data, y_data, sprintf('freq: %5.2f, ampl: %5.2f',...
                                       frequency, amplitudes(i)))
end
hold off
legend('show')
\end{lstlisting}

\begin{exercise}{plotMultipleSinewaves.m}{}
  Erweiter das Programm so, dass die Sinusse f\"ur einen Satz von
  Frequenzen geplottet wird.
  \pagebreak[4]
\end{exercise}

\subsection{Fazit}

Funktionen sind kleine Codefragmente, 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 Problem zu l\"osen. W\"ahrend die Funktionen relativ
kleine ``verdauliche'' Teilprobleme l\"osen, sind Skripte daf\"ur
gemacht den Rahmen zu bilden und den Ablauf zu koordinieren (Abbildung
\ref{programlayoutfig}).

\begin{figure}
  \includegraphics[width=0.5\columnwidth]{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}
