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

\subject{Einf\"uhrung in die 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}
}

\newcommand{\code}[1]{\texttt{#1}}

\input{../../latex/environments.tex}
\makeatother
 
\begin{document} 

\begin{frame}[plain]
  \frametitle{}
  \vspace{-1cm}
  \titlepage % erzeugt Titelseite
\end{frame}


\begin{frame}[plain]
  \huge{5. Kontrollstrukturen}
\end{frame}

\begin{frame}
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Was ist das?}
  \begin{itemize}
  \item Regeln den Ablauf von Anweisungen.
  \item Was soll unter welchen Bedingungen wie h\"aufig ausgef\"uhrt werden?\vspace{0.5cm}\pause
  \item Im Wesentlichen zwei Arten von Kontrollstrukturen:
    \begin{enumerate}
    \item Schleifen (\code{for} und \code{while} Schleifen).\vspace{0.25cm}
    \item Bedingte Anweisungen und Verzweigungen.
    \end{enumerate}\vspace{0.5cm}\pause
  \end{itemize}
\end{frame}



\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Schleifen}
  
  Schleifen werden gebraucht um wiederholte Ausf\"uhrung desselben
  Codes zu vereinfachen.  Z.B. die Berechnung der Fakult\"at von
  gestern...

\tiny
  \begin{lstlisting}
>> x = 1;
>> x = x * 2;
>> x = x * 3;  
>> x = x * 4;
>> x = x * 5;
>> x
x =
    120
\end{lstlisting}
\normalsize
  \begin{itemize}
  \item Zeilen 2 bis 5 sind sehr \"ahnlich.
  \item Die Verwendung von solchen Codeklonen ist schlechter Programmierstil!
  \item Welche Nachteile hat es sonst noch?
  \end{itemize}
\end{frame}


\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Die \code{for} - Schleife}
  \begin{itemize}
  \item  Wird genutzt um iterativ/wiederholt einen Codeabschnitt auszuf\"uhren.\pause
  \item  Eine \code{for} Schleife besteht aus dem \textit{(Schleifen-) Kopf} und dem \textit{(Schleifen-) K\"orper}.
    \begin{itemize}
    \item Der Schleifenkopf beginnt mit dem Schl\"usselwort
      \textbf{for} auf welches folgend die \textit{Laufvariable}
      definiert wird.
    \item Die Schleife ``l\"auft''/iteriert immer(!) \"uber einen
      Vektor.
    \item Die \textit{Laufvariable} nimmt in jeder Iteration einen
      Wert dieses Vektors an.
    \item Im Schleifenk\"orper k\"onnen beliebige Anweisungen
      ausgef\"uhrt werden.
    \item Die Schleife wird durch das Schl\"usselwort \textbf{end}
      beendet.
    \end{itemize}
  \end{itemize}
  \pause
  \tiny
  \begin{lstlisting}[label=loopListing2]
   for x = 1:5
     % ... etwas sinnvolles mit x ...
   end
   \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Die \code{for} Schleife}

  Zur\"uck zu unserer Implementation der Fakult\"at:
  \tiny
  \begin{lstlisting}
>> x = 1;
>> x = x * 2;
>> x = x * 3;  
>> x = x * 4;
>> x = x * 5;
>> x
x =
    120
\end{lstlisting}
\normalsize
Wie k\"onnte das in einer Schleife gel\"ost werden?
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Die \code{for} Schleife}
  Implementatierung der Fakult\"at mithilfe einer \code{for} Schleife:
  \tiny
  \begin{lstlisting}
    x = 1;
    for i = 1:5
      x = x * i;
    end 
    % oder auch
    iterations = 1:5;
    for i = iterations
      x = x * i;
    end
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Die \code{while} - Schleife}
  \begin{itemize}
  \item \"Ahnlich zur \code{for} Schleife. Iterative Ausf\"uhrung
    von Programmcode:
    \begin{itemize}
    \item Der Schleifenkopf beginnt mit dem Schl\"usselwort \textbf{while}
      gefolgt von einem \underline{Booleschen Ausdruck}.
    \item Solange dieser zu \textit{true} ausgewertet werden kann, wird
      der Code im Schleifenk\"orper ausgef\"uhrt.
    \item Die Schleife wird mit dem Schl\"usselwort \textbf{end} beendet.
    \end{itemize}
  \end{itemize}
  \tiny
  \begin{lstlisting}
    while x == true 
      % fuehre diesen sinnvollen code aus ...
    end
  \end{lstlisting}
  

\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Die \code{while} - Schleife}
  Die Fakult\"at mit einer \code{while} Schleife:
  \tiny
  \begin{lstlisting}
    i = 1;
    x = 1;
    while i <= 5 
      x = x * i;
      i = i + 1;
    end
  \end{lstlisting}
  \pause
  \begin{lstlisting}
    i = 1
    while true %never ending loop!
      disp(x);
      x = x * i;
      i = i + 1;
    end
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Vergleich \code{for} vs. \code{while} Schleife} 
  \begin{itemize}
  \item Beide f\"uhren den Code im Schleifenk\"orper iterative aus.
  \item Der K\"orper einer \code{for} Schleife wird mindestens 1 mal
    betreten.
  \item Der K\"orper einer \code{while} Schleife wird nur dann
    betreten, wenn die Bedinung im Kopf \textbf{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}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen} 
  \framesubtitle{Die \code{if} - Anweisung (bedingte Anweisung)}
  \begin{itemize}
  \item Wird genutzt um Programmcode nur unter bestimmten Bedingungen
    auszuf\"uhren.
    \begin{itemize}
    \item Der Kopf der \code{if} Anweisung beginnt mit dem Schl\"usselwort \textbf{if}.
    \item Dieses wird gefolgt von einem \underline{Booleschen
        Ausdruck}.
    \item Wenn dieser zu \textbf{true} ausgewertet werden kann, wird
      der Code im K\"orper der Anweisung ausgef\"uhrt.
    \item Optional k\"onnen weitere Bedingungen mit dem
      Schl\"usselwort \textbf{elseif} folgen.
    \item Ebenfalls optional ist die Verwendung des \textbf{else}
      Falls, der immer dann ausgef\"uhrt wird wenn die vorherigen
      Bedingungen nicht erf\"ullt werden.
    \item Die \code{if} Anweisung wird mit \textbf{end} beendet.
    \end{itemize}
  \end{itemize}\pause
  \tiny
  \begin{lstlisting}
  if x < y
     % fuehre diesen code aus
  elseif x > y
     % etwas anderes soll getan werden
  else
     % wenn x == y wieder etwas anderes
  end  
  \end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen} 
  \framesubtitle{Die \code{if} - Anweisung (bedingte Anweisung)}
  \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
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Die \code{switch} - Verzweigung} 
  \begin{itemize}
  \item Wird eingesetzt wenn mehrere F\"alle auftreten k\"onnen, die
    einer unterschiedlichen Behandlung bed\"urfen.
    \begin{itemize}
    \item Wird mit dem Schl\"usselwort \textbf{switch} begonnen, gefolgt
      von der \textit{switch Anweisung} (Zahl oder String).
    \item Das Schl\"usselwort \textbf{case} gefolgt von der \textit{case
        Anweisung} definiert gegen welchen Fall auf
      \underline{Gleichheit} getestet wird.
    \item Fuer jeden Fall wird beliebiger Programmcode ausgef\"uhrt.
    \item Optional k\"onnen mit dem Schl\"usselwort \textbf{otherwise}
      alle nicht explizit genannten F\"alle behandelt werden.
    \item Die \code{switch} Anweisung wird mit \textbf{end} beendet.
    \end{itemize}
  \end{itemize}

\tiny
\begin{lstlisting}[label=switch_listing]
  mynumber = input('Enter a number:');
  switch mynumber
    case -1
        disp('negative eins');
    case 1
        disp('positive eins');
    otherwise
        disp('etwas anderes');
  end
\end{lstlisting}
\end{frame}


\begin{frame}
  \frametitle{Kontrollstrukturen}
  \framesubtitle{Vergleich \code{if} und \code{switch} Anweisungen}
  \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}
\end{frame}

\begin{frame}[fragile]
 \frametitle{Kontrollstrukturen}
  \framesubtitle{Die Schl\"usselworte \code{break}  und \code{continue}}

  Wenn die Ausf\"uhrung einer Schleife \"ubersprungen abgebrochen
  werden soll, werden die Schl\"usselworte \textbf{break} und
  \textbf{continue} eingesetzt.\\
  \vspace{0.5cm}
  \noindent Beispiel:
  \tiny
  \begin{lstlisting}
    for x = 1:10 
      if(x > 2 & x < 5)
         continue;
      end
      disp(x);
    end
    
    x = 1;
    while true
      if(x > 5)
         break;
      end
      disp(x);
      x = x + 1
    end
\end{lstlisting}
\end{frame}

\begin{frame}[fragile]
  \frametitle{Kontrollstrukturen}
  \framesubtitle{\"Ubung: 1-D random walk}
  Programmiere einen 1-D random walk:
  \begin{itemize}
  \item In einem random walk ``l\"auft'' ein Objekt zuf\"allig mal in
    die eine oder andere Richtung.
  \item Programmiere 10 Realisationen eines random walk mit jeweils
    1000 Schritten.
  \item Die Position des Objektes ver\"andert sich in jedem Schritt um
    +1 oder -1.
  \item Merke Dir alle Positionen.
  \item Plotte die Positionen als Funktion der Schrittnummer.
  \end{itemize}
\end{frame}

\end{document}
