\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{13.10.2014 - 07.11.2014}
 %\logo{\pgfuseimage{../../resources/UT_BM_Rot_RGB.pdf}}

\subject{Einf\"uhrung in wissenschaftliche Datenverarbeitung}

\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}
  \frametitle{Grundlagen der Programmierung}
  \frametitle{Resourcen}
  \begin{enumerate}
  \item Kursmaterialien auf Ilias \url{https://ovidius.uni-tuebingen.de/ilias3/goto.php?target=crs_869632&client_id=pr02}
  \item Wintersemester 2014--2015 $\rightarrow$ 7
    Mathematisch--Naturwissenschaftliche Fakultät $\rightarrow$ Biologie
    $\rightarrow$ Biologie -- Master $\rightarrow$ Neurobiologie
    $\rightarrow$ W1 Einführung is wissenschaftlich
    Datenverarbeitung\pause
  \item Einloggen mit Uni-Kennung und Passwort
  \item Zugriff auf den Kurs mit dem geheimen Passwort ``Spikes'' \pause
  \item Ladet eure Lösungen in den entsprechenden Ordner hoch.
  \end{enumerate}
\end{frame}


\begin{frame}
  \frametitle{Grundlagen der Programmierung}
  \framesubtitle{Themen Woche 1}
  \begin{enumerate}
  \item MATLAB Entwicklungsumgebung
  \item Variablen und Datentypen
  \item Vektoren und Matrizen
  \item Boolesche Operationen
  \item Kontrollstrukturen
  \item Was ist ein Programm, Stil und Kommentare
  \item Vom Problem zum Algorithmus
  \item Skripte und Funktionen
  \item Graphische Darstellung von Neuro Daten, PSTH, Rasterplot, STA
  \item Fortgeschrittene Datenstrukturen
  \item String Parsing
  \item Lesen und schreiben von Dateien, Navigation im Dateisystem
  \end{enumerate}
\end{frame}


\begin{frame}
  \frametitle{Grundlagen der Programmierung}
  \frametitle{Themen Woche 1}
  \begin{figure}
    \centering
    \includegraphics[width=0.8\columnwidth]{./images/wueste}
  \end{figure}
\end{frame}

\begin{frame}
  \frametitle{Grundlagen der Programmierung}
  \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 Boolesche 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 weitgehend ignorieren koennen.
  \item \textit{double} - Flie{\ss}kommazahlen.
  \item \textit{complex} - Komplexe Zahlen.
  \item \textit{logical} - Boolesche Werte, die als wahr
    (\textit{true}) oder falsch (\textit{false}) interpretiert werden.
  \item \textit{char} - ASCII Zeichen
  \end{itemize}
\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 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{Matrizen}
  \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{Matrizen}
\framesubtitle{Nachtrag: Lineare 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 L\"osche 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 z\"ahle 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 w\"are die Erwartung,
    was kommt heraus?
\end{enumerate}
\end{frame}


\end{document}
