Merge branch 'master' of raven.am28.uni-tuebingen.de:scientificComputing

programming/exercises/day_1_exercises.tex

@@ -0,0 +1,196 @@
+\documentclass[12pt,a4paper,pdftex]{article}
+
+\usepackage{natbib}
+\usepackage{graphicx}
+\usepackage[margin=1.5in]{geometry}
+\usepackage[small]{caption}
+\usepackage{sidecap}
+\usepackage{pslatex}
+\usepackage{amsmath}
+\usepackage{amssymb}
+\setlength{\marginparwidth}{2cm}
+\usepackage[breaklinks=true,bookmarks=true,bookmarksopen=true,pdfpagemode=UseNone,pdfstartview=FitH,colorlinks=true,citecolor=blue]{hyperref}
+
+%%%%%title
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\title{\bf Einf\"uhrung in die wissenschaftliche Datenanlyse\\ \"Ubungen} 
+\author{Fabian Sinz, Jan Grewe, Jan Benda}
+\date{\noindent\parbox{\textwidth}{\normalsize\itshape Eberhardt Karls Universit\"at
+T\"ubingen, Abt. Neuroethologie }}
+
+%%%%% text size %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+% letter : 8.5 x 11 in
+\setlength{\headheight}{5mm}    % default ~5mm
+\setlength{\headsep}{8mm}       % default ~10mm
+\setlength{\topmargin}{15mm}    % default ~8mm
+\setlength{\textheight}{23cm}
+
+\setlength{\oddsidemargin}{2.5cm}
+\setlength{\evensidemargin}{2.5cm}
+\setlength{\textwidth}{16cm}
+
+\setlength{\voffset}{-1in}
+\setlength{\hoffset}{-1in}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\renewcommand{\baselinestretch}{1.15}
+\makeatletter
+\setlength{\@fptop}{0pt}
+\setlength{\@fpsep}{5ex}
+\makeatother
+
+\begin{document}
+\maketitle
+
+\section{Variablen}
+
+\begin{enumerate}
+\item Erzeuge zwei Variablen \verb+a, b+ und weise ihnen
+  unterschiedliche Werte zu. Schlie{\ss}e die Zeilen mit einem
+  Semikolon ab.
+\item Lasse die Werte der Variablen ausgeben.
+\item F\"uhre einfache mathematische Operationen aus (Addition,
+  Subtraktion, etc.)  Potenzierung erfolgt \"uber das Dach Symbol
+  \verb+^+). Stelle fest, ob sich der der urspruengliche Wert der
+  Variable ge\"andert hat.
+\item Benuzte die Kommandozeile um herauszufinden, welche Variablen
+  es im Workspace gibt.
+\item Finde in der Hilfe mehr Information \"uber das \verb+clear+ Kommando.
+\item L\"osche eine Variable.
+\item L\"osche alle \"ubrigen Variablen.
+\item Berechne die Fakult\"at von 5 indem eine Variable \verb+x+
+  erzeugt wird und ihr der Wert 1 zugewiesen wird. In einzelenen
+  Schritten wird x jeweils das Ergebnis des vorherigen Schrittes
+  zugewiesen.
+\end{enumerate}
+
+\newpage
+\section{Vektoren und Matrizen}
+\subsection{Vektoren}
+  \begin{enumerate}
+  \item Erzeuge Vektoren: 
+    \begin{enumerate}
+    \item Von 1 bis 10 in ganzzahligen Schritten.
+    \item $2:20$ in 2er Schritten.
+    \item mit absteigendem Inhalt von 100 bis 0.
+    \item In 100 Schritten von  0 bis $2\pi$ ($\pi$ ist als Konstante 'pi'
+      in Matlab definiert).
+    \end{enumerate}
+  \item Erzeuge eine Variable und speichere etwas Text in ihr sodass
+    mindestens 2 Worte vorhanden
+    sind. \\ (\verb+x = 'some text'+). Benutze die Indizierung um die
+    Woerter einzeln auszugeben.
+  \item Definiere zwei Vektoren: \verb+x = [3 2 6 8];+ and \verb+y = [4; 1; 3; 5];+
+    \begin{enumerate}
+    \item ... addiere 5 zu jedem Element von \verb+x+.
+    \item ... addiere 3 zu jedem Element zu jedem Element von y, dass einen nicht gerade Index hat.
+    \item ... multipliziere jedes Element von \verb+x+ mit dem
+      entsprechenden Element in \verb+y+ und weise das Ergebnis der
+      Variable \verb+z+ zu.
+    \end{enumerate}
+  \end{enumerate}
+
+\newpage
+\subsection{Matrizen}
+  \begin{enumerate}
+  \item Erstelle eine 5 x 5 Matrix die Zufallszahlen enth\"alt (nutze die 
+    MATLAB Funktion \verb+randn()+, benutze die Hilfe. Was macht sie?). 
+    \begin{enumerate}
+    \item Gib alle Elemente der ersten Zeile aus.
+    \item Gib alle Elemente der zweiten Spalte aus.
+    \item Greife mit einem einzigen Kommando auf die Elemnte jeder
+      2. Spalte zu und speichere die Daten in einer neuen Variable.
+    \end{enumerate}
+  \item Erstelle eine 3-D Matrix aus drei 2-D Matrizen. Benutze die
+    \verb+cat()+ Funktion f\"ur diesen Zweck ( schaue in der Hilfe
+    nach, wie sie benutzt wird).
+    \begin{enumerate}
+    \item Gib alle Elemente des ersten ``Blattes'' aus (Index 1 in der 3. Dimension).
+    \end{enumerate}
+  \item Erstelle eine 3-D Matrix mithilfe der Funktion
+    \verb+ones()+. Multipliziere das erste Blatt mit 1, das zweite mit
+    2, dritte mit 3 etc.
+  \item Erstelle folgende Variablen \verb+x = [1 5 9]+ and
+    \verb+y = [7 1 5]+ und \verb+M = [3 1 6; 5 2 7]+. Welche der
+    folgenden Operationen funktionieren? Wenn nicht, warum
+    funktioneieren sie nicht? Teste Deine Vorhersagen.
+    \begin{enumerate}
+    \item \begin{verbatim} x + y \end{verbatim}
+    \item \begin{verbatim} x * M \end{verbatim}
+    \item \begin{verbatim} x + y' \end{verbatim}
+    \item \begin{verbatim} M - [x y] \end{verbatim}
+    \item \begin{verbatim} [x; y] \end{verbatim}
+    \item \begin{verbatim} M - [x; y] \end{verbatim}
+    \end{enumerate}
+  \item Erzeuge eine 5 x 5 x 5 Matrix die mit ganzzahligen
+    Zufallszahlen zwischen 0 und 100 gefuellt ist.
+    \begin{enumerate}
+    \item  Berechne den Mittelwert aller Bl\"atter dieser Matrix (benutze \verb+mean()+, siehe Hilfe).
+    \end{enumerate}
+  \end{enumerate}
+
+\newpage
+\section{Boolesche Operationen}
+\begin{enumerate}
+  \item Gegeben sind \verb+x = (1:10)+ und
+    \verb+y = [3 1 5 6 8 2 9 4 7 0]+. Try to understand the following
+    commands.
+    \begin{enumerate}
+    \item \verb+x( (y <= 2) )+
+    \item \verb+x( (x > 2) | (y < 8) )+
+    \item \verb+x( (x == 0) \& (y == 0) )+
+    \end{enumerate}
+  \item Erzeuge eine 100x100 2-D Matrix mit Zufallswerten zwischen 0 und 100 (\verb+randi+). Ersetze \verb+x < 33+ mit 0, \verb+x >= 33 und x < 66+ mit 1 und alle \verb+x >= 66+ auf 2.
+  \item Ermittle die Anzahl Elemente fuer jede Klasse mithilfe eines Booleschen Ausdrucks.
+\end{enumerate}
+
+
+\section{Logische Indizierung}
+\begin{enumerate}
+  \item Gegeben sind \verb+x = (1:10)+ und
+    \verb+y = [3 1 5 6 8 2 9 4 7 0]+. Try to understand the following
+    commands.
+    \begin{enumerate}
+    \item \verb+x( (y <= 2) )+
+    \item \verb+x( (x > 2) | (y < 8) )+
+    \item \verb+x( (x == 0) \& (y == 0) )+
+    \end{enumerate}
+  \item Erzeuge eine 100x100 2-D Matrix mit Zufallswerten zwischen 0 und 100 (\verb+randi+). Ersetze \verb+x < 33+ mit 0, \verb+x >= 33 und x < 66+ mit 1 und alle \verb+x >= 66+ auf 2.
+  \item Ermittle die Anzahl Elemente fuer jede Klasse mithilfe eines Booleschen Ausdrucks.
+\end{enumerate}
+
+\newpage
+\section{Kontrollstrukturen}
+
+\begin{enumerate}
+  \item Erzeuge einen Vektor 'x' mit z.B. 50 Zufallszahlen im Bereich 0 - 10.
+    \begin{enumerate}
+    \item Benutze eine Schleife um das arithmetische Mittel zu berechnen. Der Mittelwert ist definiert als:
+      $\overline{x}=\frac{1}{n}\sum\limits_{i=0}^{n}x_i $.
+    \item Benutze eine Schleife um die Standardabweichung zu bestimmen:
+      $\sigma=\sqrt{\frac{1}{n}\sum\limits_{i=0}^{n}(x_i-\overline{x})^2}$).
+    \item Suche in der MATLAB Hilfe nach Funktionen, die das fuer dich tuen :-).
+    \end{enumerate}
+  \item Erzeuge eine 5 x 5 x 5 Matrix mit Zufallszahlen.
+    \begin{enumerate}
+    \item Benutze eine for Schleife um nacheinander die Elemente jedes ``Blattes'' einzeln auszugeben.
+    \item Das gleich mit einer while-Schleife.
+    \end{enumerate}
+  \item Erstelle 'x' einen Vektor mit 10 Zufallszahlen im Bereich 0:10.
+    \begin{enumerate}
+    \item Benutze eine for-Schleife um all die Elemente zu loeschen,
+      die (\verb+x(index) = [];+) kleiner als 5 sind.
+    \item Loesche alle Elemente die kleiner als  5 und groesser als  2 sind.
+    \item Kann man das gleiche auch ohne eine Schleife erledigen?
+    \end{enumerate}
+  \item Teste den Zufallsgenerator! Dazu zaehle die Anzahl der
+    Elemente, die durch folgende Grenzen getrennt werden [0.2 0.4 0.6
+      0.8 1.0]. Speichere die Ergebnisse in einem passenden
+    Vektor. Nutze eine Schleife um 1000 Zufallszahlen mit
+    \verb+rand()+ (siehe Hilfe) zu ziehen. Was waere die Erwartung,
+    was kommt heraus?
+\end{enumerate}
+
+
+\end{document}
+

programming/lectures/programming_basics.tex

@@ -57,6 +57,9 @@
 
 \subject{Einf\"uhrung in wissenschaftliche Datenverarbeitung}
 
+\titlegraphic{
+  \includegraphics[width=0.5\linewidth]{../../resources/UT_WBMW_Rot_RGB}
+}
 %%%%%%%%%% configuration for code
 \lstset{
  basicstyle=\ttfamily,
@@ -96,35 +99,932 @@
 
 \begin{frame}
   \frametitle{Grundlagen der Programmierung}
-  \framesubtitle{Themen}
+  \framesubtitle{Themen Woche 1}
   \begin{enumerate}
   \item MATLAB Entwicklungsumgebung
   \item Variablen und Datentypen
   \item Vektoren und Matrizen
   \item Boolsche Operationen
-  \item Ablaufkontrolle
+  \item Kontrollstrukturen
-  \item Was ist ein Programm
+  \item Was ist ein Programm, Stil und Kommentare
   \item Vom Problem zum Algorithmus
   \item Skripte und Funktionen
-  \item Stil
+  \item Graphische Darstellung von Neuro Daten, PSTH, Rasterplot, STA
-  \item Graphische Darstellung von Daten
   \item Fortgeschrittene Datenstrukturen
   \item String Parsing
-  \item Lesen und speichern von Dateien, navigieren im Dateisystem
+  \item Lesen und schreiben von Dateien, navigieren im Dateisystem
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Themen Woche 1}
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.8\columnwidth]{./images/wueste}
+  \end{figure}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Themen Woche 1}
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.8\columnwidth]{./images/ski_wueste}
+  \end{figure}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Grundlagen der Programmierung}
+  \frametitle{Tagesmen\"u}
+  \begin{enumerate}
+  \item [] Die MATLAB Entwicklungsumgebung \& Das Hilfesystem
+  \item Variablen und Datentypen
+  \item Skalare, Vektore und Matrizen
+  \item Boolsche Operatoren
+  \item Kontrollstrukturen
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[plain]
+\huge{MATLAB IDE \& das Hilfesystem}
+\end{frame}
+
+\begin{frame}[plain]
+\huge{1. Variablen}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Grundlagen der Programmierung}
+  \framesubtitle{Variablen}
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.2\columnwidth]{./images/bucket.png}
+  \end{figure}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Grundlagen der Programmierung}
+  \framesubtitle{Variablen}
+  \huge"Eine Variable ist ein Platz im Speicher."
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.8\columnwidth]{./images/variable.pdf}
+  \end{figure}	
+\end{frame}
+
+\begin{frame}
+  \frametitle{Variablen}
+  \framesubtitle{Datentypen}
+  \begin{itemize}
+  \item \textit{integer} - Ganze zahlen. Hier gibt es mehrere
+    Unterarten, die wir in Matlab weitestgehend ignorieren koennen.
+  \item \textit{double} - Flie{\ss}kommazahlen.
+  \item \textit{complex} - Komplexe Zahlen.
+  \item \textit{logical} - Bool'sche Werte, die als wahr
+    (\textit{true}) oder falsch (\textit{false}) interpretiert werden.
+  \item \textit{char} - ASCII Zeichen
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Variablen}
+  \framesubtitle{Datentypen}
+  \only<1>{
+    \begin{figure}
+      \centering
+      \includegraphics[width=0.8\columnwidth]{./images/variable.pdf}
+    \end{figure}
+  }
+  \only<2>{	
+    \begin{figure}
+      \centering
+      \includegraphics[width=0.8\columnwidth]{./images/variableB.pdf}
+    \end{figure}
+  }
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Variablen}
+  \framesubtitle{Erzeugen von Variablen und Wertezuweisung}
+  \scriptsize
+  \begin{lstlisting}[label=varListing1]
+    >> y = []
+     y = 
+         []
+    >>
+    >> x = 38
+     x =
+         38
+    >>	
+  \end{lstlisting}
+\normalsize
+\end{frame}
+
+%\subsection{Calculations with variables}
+\begin{frame}[fragile]
+  \frametitle{Variablen}
+  \framesubtitle{Rechnen mit Variablen}
+  \tiny
+  \begin{lstlisting}[label=varListing2]
+    >> 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
+  \end{lstlisting}
+\end{frame}
+
+%\subsection{\"Ubungen}
+\begin{frame}[fragile]
+  \frametitle{Variablen}
+  \framesubtitle{\"Ubungen}
+  \vspace{-0.25cm}
+  \begin{enumerate}
+  \item Erzeuge zwei Variablen \verb+a, b+ und weise ihnen
+    unterschiedliche Werte zu. Schlie{\ss}e die Zeilen mit einem
+    Semikolon ab.
+  \item Lasse die Werte der Variablen ausgeben.
+  \item F\"uhre einfache mathematische Operationen aus (Addition,
+    Subtraktion, etc.)  Potenzierung erfolgt \"uber das Dach Symbol
+    \verb+^+). Stelle fest, ob sich der der urspruengliche Wert der
+    Variable ge\"andert hat.
+  \item Benuzte die Kommandozeile um herauszufinden, welche Variablen
+    es im Workspace gibt.
+  \item Finde in der Hilfe mehr Information \"uber das \verb+clear+ Kommando.
+  \item L\"osche eine Variable.
+  \item L\"osche alle \"ubrigen Variablen.
+  \item Berechne die Fakult\"at von 5 indem eine Variable \verb+x+
+    erzeugt wird und ihr der Wert 1 zugewiesen wird. In einzelenen
+    Schritten wird x jeweils das Ergebnis des vorherigen Schrittes
+    zugewiesen.
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[plain]
+  \huge{2. Vektoren und Matrizen}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Vektoren und Matrizen}
+  \framesubtitle{Skalare vs. Vektoren}
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.8\columnwidth]{./images/scalarArray.pdf}
+  \end{figure}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren und Matrizen}
+  \framesubtitle{Erzeugen von Vektoren}
+  \tiny
+  \begin{lstlisting}[label=arrayListing1]
+>> 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}
+\end{frame}
+
+\begin{frame}[fragile]
+ \frametitle{Vektoren und Matrizen}
+ \framesubtitle{Spalten \& Zeilenvektoren}
+ \tiny
+ \begin{lstlisting}[label=arrayListing2]
+>> a = [1 2 3 4 5 6 7 8 9 10] % Erstellen eines Zeilenvektors
+   a =
+     1 2 3 4 5 6 7 8 9 10
+>>
+>> b = [1; 2; 3; 4; 5] % Erstellen eines Spaltenvectors
+   b =
+     1
+     2
+     3 
+     4
+     5
+>>
+>> b = b' % Transponieren
+   b =
+     1 2 3 4 5
+>>
+ \end{lstlisting}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Vektoren}
+  \framesubtitle{Zugriff auf Inhalte von Vektoren}
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.8\columnwidth]{./images/arrayIndexing.pdf}
+  \end{figure}
+  \pause
+  Der Zugriff auf die Inhalte eines Vektors erfolgt \"uber den Index.\\
+  \textbf{Achtung!} Der erste Index ist die 1.
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren}
+  \framesubtitle{Zugriff auf Inhalte von Vektoren}
+  \vspace{-0.5cm}
+\tiny
+\begin{lstlisting}
+>> 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}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren}
+  \framesubtitle{Zugriff auf Inhalte von Vektoren}
+  \vspace{-0.5cm}
+\tiny
+\begin{lstlisting}
+>> a([1 3 5]) % das 1., 3. und 5. Element
+   ans =
+       11  13  15
+>>
+>> a(2:4) % alle element von Index 2 bis 4
+   ans =
+       12  13  14 
+>>
+>> a(1:2:end) %retrieve every second element
+>> and =
+>>      11  13  15  17  19
+>> 
+\end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren}
+  \framesubtitle{Grundlegende Operationen}
+  \vspace{-0.25cm}
+  \tiny
+  \begin{lstlisting}[label=arrayListing4]
+>> a = (0:2:8);
+>> a + 5 % addiere einen Skalar
+   ans =
+       5  7  9  11  13
+>>
+>>  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 gro{\ss} sein!
+    ??? Error using ==> plus
+    Matrix dimensions must agree.
+  \end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren}
+  \framesubtitle{Grundlegende Operationen}
+  \vspace{-0.25cm}
+  \tiny
+  Wie bekomme ich Informationen \"uber einen Vektor?
+  \begin{lstlisting}
+>> a = (0:2:8);
+>> % die Laenge eines
+>> length(a)
+   ans = 
+       5
+>> 
+>> size(a)
+   ans =
+      1   5
+>>		
+  \end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren}
+  \framesubtitle{Grundlegende Operationen}
+  \vspace{-0.25cm}
+  L\"oschen von Elementen:
+  \tiny
+  \begin{lstlisting}
+>> 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}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren}
+  \framesubtitle{Grundlegende Operationen}
+  \vspace{-0.25cm}
+  \tiny
+  Verkettung von Vektoren:
+  \begin{lstlisting}
+>> 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
+  \end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Vektoren}
+  \framesubtitle{\"Ubungen}
+  \begin{enumerate}
+  \item Erzeuge Vektoren: 
+    \begin{enumerate}
+    \item Von 1 bis 10 in ganzzahligen Schritten.
+    \item $2:20$ in 2er Schritten.
+    \item mit absteigendem Inhalt von 100 bis 0.
+    \item In 100 Schritten von  0 bis $2\pi$ ($\pi$ ist als Konstante 'pi'
+      in Matlab definiert).
+    \end{enumerate}
+  \item Erzeuge eine Variable und speichere etwas Text in ihr sodass
+    mindestens 2 Worte vorhanden
+    sind. \\ (\verb+x = 'some text'+). Benutze die Indizierung um die
+    Woerter einzeln auszugeben.
+  \item Definiere zwei Vektoren: \verb+x = [3 2 6 8];+ and \verb+y = [4; 1; 3; 5];+
+    \begin{enumerate}
+    \item ... addiere 5 zu jedem Element von \verb+x+.
+    \item ... addiere 3 zu jedem Element zu jedem Element von y, dass einen nicht gerade Index hat.
+    \item ... multipliziere jedes Element von \verb+x+ mit dem
+      entsprechenden Element in \verb+y+ und weise das Ergebnis der
+      Variable \verb+z+ zu.
+    \end{enumerate}
   \end{enumerate}
 \end{frame}
 
+\begin{frame}{Matrizen}
+  \vspace{-0.5cm}
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.65\columnwidth]{./images/matrices}
+  \end{figure}
+\end{frame}
+
+
+
+\begin{frame}[fragile]
+  \frametitle{Matrizen}
+  \framesubtitle{Erzeugen von Matrizen}
+  \tiny
+  \begin{lstlisting}
+>> 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}
+\end{frame}
+
+
 \begin{frame}
-\frametitle{Grundlagen der Programmierung}
+  \frametitle{Matrizen}
-\frametitle{Tagesplan}
+  \framesubtitle{Indexierung und Zugriff auf Inhalte}
+  \vspace{-0.5cm}
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.9\columnwidth]{./images/matrixIndexing}
+  \end{figure}	
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Matrizen}
+  \framesubtitle{Indexierung}
+\tiny
+\begin{lstlisting}
+>> x = roundi(100, [3, 4, 5]); % 3-D Matrix mit Zufallszahlen
+>> 
+>> 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}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Matrizen}
+  \framesubtitle{Grundlegende Operationen}
+  \vspace{-0.5 cm}
+  \tiny
+\begin{lstlisting}
+>> 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}
+\end{frame}
 
 
+\begin{frame}[plain]
+\huge{Interludium: Matrixmultiplikation}
 \end{frame}
 
 
+\begin{frame}[fragile]
+  \frametitle{Matrizen}
+  \framesubtitle{\"Ubungen}
+  \begin{enumerate}
+  \item Erstelle eine 5 x 5 Matrix die Zufallszahlen enth\"alt (nutze die 
+    MATLAB Funktion \verb+randn()+, benutze die Hilfe. Was macht sie?). 
+    \begin{enumerate}
+    \item Gib alle Elemente der ersten Zeile aus.
+    \item Gib alle Elemente der zweiten Spalte aus.
+    \item Greife mit einem einzigen Kommando auf die Elemnte jeder
+      2. Spalte zu und speichere die Daten in einer neuen Variable.
+    \end{enumerate}
+  \item Erstelle eine 3-D Matrix aus drei 2-D Matrizen. Benutze die
+    \verb+cat()+ Funktion f\"ur diesen Zweck ( schaue in der Hilfe
+    nach, wie sie benutzt wird).
+    \begin{enumerate}
+    \item Gib alle Elemente des ersten ``Blattes'' aus (Index 1 in der 3. Dimension).
+    \end{enumerate}
+  \item Erstelle eine 3-D Matrix mithilfe der Funktion
+    \verb+ones()+. Multipliziere das erste Blatt mit 1, das zweite mit
+    2, dritte mit 3 etc.
+  \end{enumerate}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Matrizen}
+  \framesubtitle{\"Ubungen}
+  \begin{enumerate}\setcounter{enumi}{3}
+  \item Erstelle folgende Variablen \verb+x = [1 5 9]+ and
+    \verb+y = [7 1 5]+ und \verb+M = [3 1 6; 5 2 7]+. Welche der
+    folgenden Operationen funktionieren? Wenn nicht, warum
+    funktioneieren sie nicht? Teste Deine Vorhersagen.
+    \begin{enumerate}
+    \item \begin{verbatim} x + y \end{verbatim}
+    \item \begin{verbatim} x * M \end{verbatim}
+    \item \begin{verbatim} x + y' \end{verbatim}
+    \item \begin{verbatim} M - [x y] \end{verbatim}
+    \item \begin{verbatim} [x; y] \end{verbatim}
+    \item \begin{verbatim} M - [x; y] \end{verbatim}
+    \end{enumerate}
+  \item Erzeuge eine 5 x 5 x 5 Matrix die mit ganzzahligen
+    Zufallszahlen zwischen 0 und 100 gefuellt ist.
+    \begin{enumerate}
+    \item  Berechne den Mittelwert aller Bl\"atter dieser Matrix (benutze \verb+mean()+, siehe Hilfe).
+    \end{enumerate}
+  \end{enumerate}
+\end{frame}
+
 \begin{frame}
-\frametitle{Grundlagen der Programmierung}
+\frametitle{Matrizen}
-\framesubtitle{Variablen}
+\framesubtitle{Nachtrag Indexierung}
+Alternativ zum ``subscript indexing'' koennen die Elemente von Matrizen auch linear addressiert werden.
+ \begin{figure}
+    \centering
+    \includegraphics[width=0.75\columnwidth]{./images/matrixLinearIndexing}
+  \end{figure}
+\end{frame}
+
+
+\begin{frame}[plain]
+  \huge{3. Boolesche Operationen}
 \end{frame}
 
+\begin{frame}
+  \frametitle{Boolesche Operationen} \framesubtitle{Was ist das?}
+  Boolesche Operationen sind Operationen, die sich zu Wahr oder Falsch
+  auswerten lassen. Auf Mengen angewendet (Zeichnungen geklaut bei
+  Cornelia M\"uhlich, Uni-Jena):
+  \only<1> {
+  \begin{figure}
+    \centering
+    \includegraphics[width=0.75\columnwidth]{./images/grundmenge}
+  \end{figure}
+  }
+  \only<2> {
+    \begin{figure}
+      \centering
+      \includegraphics[height=0.65\textheight]{./images/beete}
+    \end{figure}
+  }
+  \only<3> {
+    \begin{figure}
+      \centering
+      \includegraphics[height=0.65\textheight]{./images/AvB}
+    \end{figure}
+  }
+  \only<4> {
+    \begin{figure}
+      \centering
+      \includegraphics[height=0.65\textheight]{./images/AundB}
+    \end{figure}
+  }
+  \only<5> {
+    \begin{figure}
+      \centering
+      \includegraphics[height=0.65\textheight]{./images/AnotB}
+    \end{figure}
+  }
+  \only<6> {
+    \begin{figure}
+      \centering
+      \includegraphics[height=0.65\textheight]{./images/AxorB}
+    \end{figure}
+  }
+\end{frame}
+
+\begin{frame}[fragile]
+\frametitle{Boolesche Operationen}
+\framesubtitle{Logische Operatoren}
+  \begin{table}[th]
+    \caption{\label{logicalOperatorsTab}
+      \textbf{Logical operators.}}
+    \begin{center}
+      \begin{tabular}{c|c}
+        \hline
+        \textbf{Operator} & \textbf{Beschreibung} \\ \hline
+        $\sim$ & logisches NOT\\
+        $\&$ &  logisches UND\\
+        $|$ & logisches ODER\\
+        $\&\&$ & short-circuit logical AND\\
+        $\|$ & short-circuit logical OR\\
+        \hline
+      \end{tabular}
+    \end{center}
+    \vspace{1em}
+    Das auschliessende ODER (XOR) ist nur als Funktion \verb+xor(A, B)+ verf\"ugbar.
+  \end{table}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Boolesche Operationen}
+  \framesubtitle{Relationale Operatoren}
+  \begin{table}[th]
+  \caption{\label{relOperatorsTab}
+    \textbf{Relational Operators.}} 
+  \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}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Boolean operations}
+  \framesubtitle{Beispiele}
+  \tiny
+  \begin{lstlisting}
+  >> 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}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Boolesche Operationen}
+  \framesubtitle{\"Ubungen}
+  \vspace{-0.5cm}
+  \begin{enumerate}
+  \item Gegeben sind zwei Vektoren \verb+x = [1 5 2 8 9 0 1]+ und
+    \verb+y = [5 2 2 6 0 0 2]+. F\"uhre aus und erkl\"are.
+    \begin{enumerate}
+    \item \verb+x > y+
+    \item \verb+y < x+
+    \item \verb+x == y+
+    \item \verb+x ~= y+
+    \item \verb+x & ~y+
+    \item \verb+x | y+
+    \end{enumerate}
+  \end{enumerate}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Logische Indexierung}
+  \framesubtitle{\"Ubungen}
+  Boolesche Operationen koennen eingesetzt werden um aus Vektoren und
+  Matrizen Elemente auszuwaehlen, die einer bestimmten Bedingung
+  entsprechen.
+  \begin{enumerate}
+  \item Gegeben sind \verb+x = (1:10)+ und
+    \verb+y = [3 1 5 6 8 2 9 4 7 0]+. Try to understand the following
+    commands.
+    \begin{enumerate}
+    \item \verb+x( (y <= 2) )+
+    \item \verb+x( (x > 2) | (y < 8) )+
+    \item \verb+x( (x == 0) \& (y == 0) )+
+    \end{enumerate}
+  \item Erzeuge eine 100x100 2-D Matrix mit Zufallswerten zwischen 0 und 100 (\verb+randi+). Ersetze \verb+x < 33+ mit 0, \verb+x >= 33 und x < 66+ mit 1 und alle \verb+x >= 66+ auf 2.
+  \item Ermittle die Anzahl Elemente fuer jede Klasse mithilfe eines Booleschen Ausdrucks.
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[plain]
+  \huge{4. Kontrollstrukturen}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Kontrollstrukturen}
+  \framesubtitle{Schleifen}
+  Schleifen werden gebrauch um wiederholte Ausfuehrung desselben Codes zu vereinfachen.
+  \tiny
+  \begin{lstlisting}
+>> x = 1; % Startwert fuer x
+    ...   % etwas sinnvolles mit x
+>> x = x + 1;
+    ...   
+>> x = x + 1;
+    ...   
+>> x = x + 1;
+    ...   
+>> x = x + 1;
+    ...   
+>> x = x + 1;
+>> 
+>> x
+   x =
+       6
+\end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Kontrollstrukturen}
+  \framesubtitle{for - Schleife}
+  \tiny
+  \begin{lstlisting}[label=loopListing2]
+>> for x = 1:5
+    ...   % etwas sinnvolles mit x ...
+   end
+>> disp(x);
+    5
+>>
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Kontrollstrukturen}
+  \framesubtitle{while - Schleife}
+  \tiny
+  \begin{lstlisting}
+>> x = 1;
+>> while x <= 5 
+      ...   % etwas sinnvolles mit x ...
+      disp(x);
+      x = x + 1;
+   end
+      1      
+      2
+      3
+      4
+      5
+>> disp(x)
+     6
+>>
+>> while true %never ending loop!
+     disp(x);
+     x = x + 1;
+   end
+     1
+     2
+    ...
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Kontrollstrukturen}
+  \framesubtitle{if - Anweisung (bedingte Anweisung)} 
+
+  Wird eingesetzt um bestimmte Code Abschnitte
+  nur unter bestimmten Umst\"anden auszuf\"uhren.
+  
+  \tiny
+\begin{lstlisting}[label=loopListing4]
+>> x = rand(1); % eine einzelne Zufallszahl
+>> if x < 0.5
+      disp('x is less than 0.5');
+   end
+>>
+>> if x < 0.5
+      disp('x is less than 0.5!');
+   else
+      disp('x is greater than or equal to 0.5!')
+   end
+>> 
+>> if x < 0.5
+      disp('x is less than 0.5!');
+   elseif x < 0.75
+      disp('x is greater than 0.5 but less than 0.75!');
+   else
+      disp('x is greater than or equal to 0.75!')
+   end
+>>
+>> if x < 0.75
+      disp('x is less than 0.75!');
+   elseif x < 0.5
+      disp('x is less than 0.5!');
+   else
+      disp('x is greater than or equal to 0.75!')
+   end
+\end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+ \frametitle{Kontrollstrukturen}
+  \framesubtitle{break  unnd continue}
+  \vspace{-0.5cm}
+  \tiny
+  \begin{lstlisting}
+>> for x = 1:5 % using continue
+     if(x > 2 & x < 5)
+        continue;
+     end
+     disp(x);
+   end
+     1
+     2
+     5
+>> 
+>> for x = 1:5000 % using break
+     if(x > 5)
+        break;
+     end
+     disp(x);
+   end
+     1
+     2
+     3
+     4
+     5
+>>
+\end{lstlisting}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Kontrollstrukturen}
+  \framesubtitle{\"Ubungen}
+  \begin{enumerate}
+  \item Erzeuge einen Vektor 'x' mit z.B. 50 Zufallszahlen im Bereich 0 - 10.
+    \begin{enumerate}
+    \item Benutze eine Schleife um das arithmetische Mittel zu berechnen. Der Mittelwert ist definiert als:
+      $\overline{x}=\frac{1}{n}\sum\limits_{i=0}^{n}x_i $.
+    \item Benutze eine Schleife um die Standardabweichung zu bestimmen:
+      $\sigma=\sqrt{\frac{1}{n}\sum\limits_{i=0}^{n}(x_i-\overline{x})^2}$).
+    \item Suche in der MATLAB Hilfe nach Funktionen, die das fuer dich tuen :-).
+    \end{enumerate}
+  \item Erzeuge eine 5 x 5 x 5 Matrix mit Zufallszahlen.
+    \begin{enumerate}
+    \item Benutze eine for Schleife um nacheinander die Elemente jedes ``Blattes'' einzeln auszugeben.
+    \item Das gleich mit einer while-Schleife.
+    \end{enumerate}
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Kontrollstrukturen}
+  \framesubtitle{\"Ubungen}
+  \vspace{-0.5cm}
+  \begin{enumerate}\setcounter{enumi}{2}
+  \item Erstelle 'x' einen Vektor mit 10 Zufallszahlen im Bereich 0:10.
+    \begin{enumerate}
+    \item Benutze eine for-Schleife um all die Elemente zu loeschen,
+      die (\verb+x(index) = [];+) kleiner als 5 sind.
+    \item Loesche alle Elemente die kleiner als  5 und groesser als  2 sind.
+    \item Kann man das gleiche auch ohne eine Schleife erledigen?
+    \end{enumerate}
+  \item Teste den Zufallsgenerator! Dazu zaehle die Anzahl der
+    Elemente, die durch folgende Grenzen getrennt werden [0.2 0.4 0.6
+      0.8 1.0]. Speichere die Ergebnisse in einem passenden
+    Vektor. Nutze eine Schleife um 1000 Zufallszahlen mit
+    \verb+rand()+ (siehe Hilfe) zu ziehen. Was waere die Erwartung,
+    was kommt heraus?
+\end{enumerate}
+\end{frame}
+
+
 \end{document}

programming/lectures/scripts_functions.tex

@@ -0,0 +1,379 @@
+\documentclass{beamer}
+\usepackage{xcolor}
+\usepackage{listings}
+\usepackage{pgf}
+%\usepackage{pgf,pgfarrows,pgfnodes,pgfautomata,pgfheaps,pgfshade} 
+%\usepackage{multimedia}
+
+\usepackage[english]{babel}
+\usepackage{movie15}
+\usepackage[latin1]{inputenc}
+\usepackage{times}
+\usepackage{amsmath}
+\usepackage{bm} 
+\usepackage[T1]{fontenc}
+\usepackage[scaled=.90]{helvet}
+\usepackage{scalefnt}
+\usepackage{tikz}
+\usepackage{ textcomp }
+\usepackage{soul}
+\usepackage{hyperref}
+\definecolor{lightblue}{rgb}{.7,.7,1.}
+\definecolor{mygreen}{rgb}{0,1.,0}
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\mode<presentation>
+{
+  \usetheme{Singapore}
+  \setbeamercovered{opaque}
+  \usecolortheme{tuebingen}
+  \setbeamertemplate{navigation symbols}{}
+  \usefonttheme{default}
+  \useoutertheme{infolines}
+  % \useoutertheme{miniframes}
+}
+
+\AtBeginSection[]
+{
+  \begin{frame}<beamer>
+    \begin{center}
+      \Huge \insertsectionhead
+    \end{center}
+    % \frametitle{\insertsectionhead}
+    % \tableofcontents[currentsection,hideothersubsections]
+  \end{frame}
+}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%5
+
+\setbeamertemplate{blocks}[rounded][shadow=true]
+
+\title[]{Scientific Computing -- Grundlagen der Programmierung }
+\author[]{Jan Grewe\\Abteilung f\"ur Neuroethologie\\
+  Universit\"at T\"ubingen}
+
+\institute[Wissenschaftliche Datenverarbeitung]{}
+ \date{03.10.2014 - 07.11.2014}
+ %\logo{\pgfuseimage{../../resources/UT_BM_Rot_RGB.pdf}}
+
+\subject{Einf\"uhrung in wissenschaftliche Datenverarbeitung}
+\vspace{1em}
+\titlegraphic{
+  \includegraphics[width=0.5\linewidth]{../../resources/UT_WBMW_Rot_RGB}
+}
+%%%%%%%%%% configuration for code
+\lstset{
+ basicstyle=\ttfamily,
+ numbers=left,
+ showstringspaces=false,
+ language=Matlab,
+ commentstyle=\itshape\color{darkgray},
+ keywordstyle=\color{blue},
+ stringstyle=\color{green},
+ backgroundcolor=\color{blue!10},
+ breaklines=true,
+ breakautoindent=true,
+ columns=flexible,
+ frame=single,
+ captionpos=b,
+ xleftmargin=1em,
+ xrightmargin=1em,
+ aboveskip=10pt
+ }
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\newcommand{\mycite}[1]{
+\begin{flushright}
+\tiny \color{black!80} #1
+\end{flushright}
+}
+
+\input{../../latex/environments.tex}
+\makeatother
+ 
+\begin{document} 
+
+\begin{frame}[plain]
+  \frametitle{}
+  \vspace{-1cm}
+  \titlepage % erzeugt Titelseite
+\end{frame}
+
+\begin{frame}[plain]
+  \frametitle{Rekapitulation}
+  \begin{enumerate}
+  \item Variablen\pause
+  \item Vektoren\pause
+  \item Matrizen\pause
+  \item Boolesche Operationen\pause
+  \item Logische Indizierung\pause
+  \item Kontrollstrukturen
+  \end{enumerate}
+\end{frame}
+
+
+\begin{frame}
+  \frametitle{Grundlagen der Programmierung}
+  \frametitle{Tagesmen\"u}
+  \begin{enumerate}
+  \item Was ist ein Program?
+  \item Skripte und Funktionen
+  \item G\"ultigkeitsbereiche
+  \item Vom Problem zum Algorithmus
+  \item \"Ubungen, \"Ubungen, \"Ubungen. 
+  \end{enumerate}
+\end{frame}
+
+
+\begin{frame}[plain]
+  \huge{1. Was ist ein Programm?}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Was ist ein Programm?}
+  \framesubtitle{Und wo lebt es?}
+  Ein Programm ist ...
+  \begin{itemize}
+  \item ... eine Sammlung von Anweisungen.
+  \end{itemize}\pause
+  Es lebt in ...
+  \begin{itemize}
+  \item ... einer Datei auf dem Rechner.
+  \end{itemize}\pause
+  Wenn es zum Leben erweckt wird...
+  \begin{itemize}
+  \item ... wird es Zeile fuer Zeile von oben nach unten ausgef\"urht.
+  \end{itemize}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Was ist ein Programm?}
+  \framesubtitle{In Matlab}
+  \begin{itemize}
+  \item Matlab kennt verschieden Arten von Programmen:
+    \begin{enumerate}
+    \item Skripte
+    \item Funktionen
+    \item Objekte (werden wir ignorieren)
+    \end{enumerate}\pause
+  \item Alle werden in sogenannte m-files gespeichert (z.B. \textit{meinProgramm.m}).
+  \item Koennen dann von der Kommandozeile aufgerufen werden.
+  \item Programme erhoehen die Wiederverwertbarkeit von Programmcode.
+  \item Programme koennen andere Programme aufrufen.
+  \end{itemize}
+\end{frame}
+
+
+\begin{frame}[plain]
+  \huge{2. Skripte und Funktionen}
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Skripte und Funktionen}
+  \framesubtitle{Skripte}
+  Beispiel: Plot von Sinusschwingungen
+  \footnotesize
+  \begin{lstlisting}
+>> x = (0:0.01:2*pi);
+>> frequenz_1 = 1;
+>> frequenz_2 = 2;
+>> y = sin(frequenz_1 * x);
+>> y2 = sin(frequenz_2 * x);
+>> plot(x, y);
+>> hold on;
+>> plot(x, y2);
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Skripte und Funktionen}
+  \framesubtitle{\"Ubungen}
+  \begin{enumerate}
+  \item \"Offnet den Editor und schreibt ein Skript, das f\"unf Sinus
+    mit den Amplituden \verb+amplitude = [0.25, 0.5, 1.0, 2.0]+ in
+    einen Graphen plottet. Benutzt eine \verb+for+ Schleife um die Amplituden abzuarbeiten. 
+  \item Speichert das Skript und f\"uhrt es von der Kommandozeile aus.
+  \item Erzeuge ein zweites Skript, das nun die Frequenz setzt und das
+    erste aufruft. Benutzt eine \verb+for+ Schleife um folgende
+    Frequenzen abzuarbeiten \verb+frequenzen = [1.0, 2.0]+.
+  \item Speichert und ruft dieses Skript \"uber die Kommandozeile auf.
+  \item Was ist geplottet, passt es zu den Erwartungen? 
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Skripte und Funktionen}
+  \framesubtitle{Funktionen}
+  Vorherige \"Ubung hat gezeigt, dass die Verwendung von globalen Variablen gef\"ahrlich ist.
+  Wie l\"ost man dieses Problem?\\
+  \vspace{3em}
+  \huge{Funktionen!}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Funktionen} \framesubtitle{Funktionen}
+  Funktionen haben ihren eingenen G\"ultigkeitsbereich. Variablen im
+  \textit{Workspace} sind ohne Konsequenzen f\"ur die Funktion.
+    \footnotesize
+  \begin{lstlisting}
+function plot_sinus_mit_amplituden() % Funktionskopf
+   x = (0:0.01:2*pi); % 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 * x) * amplituden(i);
+       plot(x, y)
+       hold on;
+   end 
+\end{lstlisting}\pause
+Ist das eine gute Funktion?
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Funktionen}
+  \framesubtitle{Argumente und R\"uckgabewerte}
+  Grundlegende Idee ist $y = f(x)$.\\
+  \"Ahnlich dazu kann man den Funktionskopf mit Argumenten und R\"uckgabewerten definieren
+  \footnotesize
+  \begin{lstlisting}
+function y = plot_sinus(frequenz, amplitude)
+%          ^                         ^            ^
+%  Rueckgabewert         Argument_1       Argument_2
+\end{lstlisting}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Skripte und Funktionen}
+  \framesubtitle{Programmierstil}
+  Programmierstil ist:
+  \begin{enumerate}
+    \item Die Namensgebung fuer Variablen und Konstanten.
+    \item Die Namensgebung von Skripten und Funktionen.  
+    \item Die Verwendung von Einr\"uckungen und Leerzeilen um Bl\"ocke im Code hervorzuheben.
+    \item Verwendung von Kommentaren und Hilfetexten.
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Funktionen}
+  \framesubtitle{Zusammenfassung}
+  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\"ueltigkeitsbereich haben.
+    \item ... Skripten fast immer vorzuziehen sind.
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[plain]
+\huge{3. Programmierstil}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Programmierstil}
+  \framesubtitle{Was soll das?}
+  \begin{enumerate}
+    \item Die Namensgebung fuer Variablen und Konstanten.
+    \item Die Namensgebung von Skripten und Funktionen.  
+    \item Die Verwendung von Einr\"uckungen und Leerzeilen um Bl\"ocke im Code hervorzuheben.
+    \item Verwendung von Kommentaren und Hilfetexten.
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Skripte und Funktionen}
+  \framesubtitle{Programmierstil}
+  In verschiednen Sprachen verschiedene Konventionen. In MATLAB ...
+  \begin{itemize}
+  \item Funktionen, Skripte: Kleinbuchstaben, Abk\"urzungen. (z.B. \verb+xcorr+, \verb+repmat+)
+  \item Konvertierungen immer mit format2format (z.B. \verb+num2str+)
+  \item Variablen immer klein, h\"aufig Abk\"urzungen.
+  \item Kommentare h\"aufig fuer interne Zwecke aber ausf\"uhrliche Dokumentation mit Hilftexten.
+  \end{itemize}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Skripte und Funktionen} \framesubtitle{Programmierstil}
+  Es gibt verschiedene ''Religionen''. Ein m\"ogliches Credo k\"onnte
+  sein: \\
+  \textbf{``Programmcode muss lesbar sein.''}\pause
+  \begin{enumerate}
+  \item Variablen werden klein geschrieben. Wenn n\"otig entweder im
+    \textit{camelCase} oder mit Unterstrichen (z.B. \verb+spikeCount+
+    oder \verb+spike\_count+).
+  \item Funktionen und Skripte mit ausdrucksstarken Namen (z.B. \verb+loadSpikeData+).
+  \item Kommentare sparsam. Eventuell um Abschnitte zu trennen.
+  \item Hilfetexte: Ein Problem; sie m\"ussen aktuell sein sonst sind
+    sie sch\"adlicher als wenn sie gar nicht da w\"aren.
+  \item Einr\"uckung ist Pflicht.
+  \item Bl\"ocke im Code werden durch 1 Leerzeichen getrennt.
+  \end{enumerate}
+\end{frame}
+
+\begin{frame}[fragile]
+  \frametitle{Programmierstil}
+  Ihr d\"urft all das missachten und einen eingenen Stil entwickeln. Aber:\\
+  \vspace{2.5cm}
+  \centering
+  \huge{Bleibt konsitent!}\pause
+  \vspace{2.5cm}
+  \normalsize
+  
+  Es gibt dazu ganze B\"ucher. z.B. Robert C. Martin: \textit{Clean
+    Code: A Handbook of Agile Software Craftmanship}, Prentice Hall
+\end{frame}
+
+
+\begin{frame}[fragile]
+  \frametitle{Funktionen}
+  \frametitle{\"Ubungen}
+  \begin{enumerate}
+  \item Schreibe eine Funktion \verb+plotSineWave+ die die amplitude
+    des Sinus als Argument entgegennimmt.
+  \item Erweitere die Funktion in der Weise, dass sie zus\"atzlich die
+    gew\"uenschte Frequnez \"ubernimmt.
+  \item Erweitere \verb+plotSineWave+ so, dass sie eine Schar von
+    Sinuswellen unterschiedlicher Frequenz plottet.
+  \item Erweitere \verb+plotSinWave+ so, dass auch die Amplitude als
+    Vektor \"ubergeben werden kann. Die Funktion soll alle m\"oglichen
+    Kombinationen darstellen.
+  \item Erweitere \verb+plotSinWave+ so, dass die berechnete Sinus in einer 2-D Matrize zurckgegeben werden.
+  \item Fuege zwei weitere R\"uckgabeparameter hinzu, die fuer jede
+    Berechnung die Amplitude und Frequenz zur\"uckgeben.
+  \end{enumerate}
+\end{frame}
+
+
+\begin{frame}[plain]
+  \huge{4. Vom Problem zum Algorithmus zum Programm}\\
+  \begin{figure}
+    \centering
+    \includegraphics[height=0.6\textheight]{./images/turtur}
+  \end{figure}
+\end{frame}
+
+\begin{frame}
+  \frametitle{Vom Problem zum Algorithmus}
+  \framesubtitle{Uff, schwierig...}
+  \begin{enumerate}
+  \item Am besten faengt man mit einem weissen Blatt an. :-) \pause
+  \item Begr\"abt alle Angst vor Fehlern. \pause
+  \item Macht sich klar, was das die Ausgangsituation ist.\pause
+  \item Macht sich klar, was das Ziel ist.\pause
+  \item Zerlegt das Problem in kleinere Teile und wendet Schritte 1 - 5 auf jedes Teilproblem an.
+  \end{enumerate}  
+\end{frame}
+
+\begin{frame}
+  \frametitle{Vom Problem zum Algorithmus}
+  \framesubtitle{Uff, schwierig...}
+  Wie w\"are es mit folgendem Problem:\\ 
+  Ich habe die Aufnahme des Membranpotentials einer Nervenzelle und m\"ochte die
+  Anzahl und die Zeitpunkte der Aktionspotentiale ermitteln.
+\end{frame}
+
+
+\end{document}