440 lines
12 KiB
TeX
440 lines
12 KiB
TeX
\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}
|