From 61db2859d275af286261e53f384939b145167c25 Mon Sep 17 00:00:00 2001 From: Jan Grewe Date: Fri, 9 Oct 2015 11:39:35 +0200 Subject: [PATCH] finalized version of the control-structures lecture --- programming/lectures/control_structures.tex | 353 +++++++++++++------- 1 file changed, 240 insertions(+), 113 deletions(-) diff --git a/programming/lectures/control_structures.tex b/programming/lectures/control_structures.tex index e256ebc..0ad8b8b 100644 --- a/programming/lectures/control_structures.tex +++ b/programming/lectures/control_structures.tex @@ -115,11 +115,6 @@ \item Schleifen (\code{for} und \code{while} Schleifen).\vspace{0.25cm} \item Bedingte Anweisungen und Verzweigungen. \end{enumerate}\vspace{0.5cm}\pause - \item Geh\"oren nicht zu den Kontrollstrukturen, werden wir hier - aber kurz ansprechen: - \begin{enumerate} - \item Ausnahmebehandlungen. - \end{enumerate} \end{itemize} \end{frame} @@ -155,158 +150,290 @@ x = \begin{frame}[fragile] \frametitle{Kontrollstrukturen} - \framesubtitle{for - Schleife} + \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 ... + for x = 1:5 + % ... etwas sinnvolles mit x ... end ->> disp(x); - 5 ->> -\end{lstlisting} + \end{lstlisting} \end{frame} \begin{frame}[fragile] \frametitle{Kontrollstrukturen} - \framesubtitle{while - Schleife} + \framesubtitle{Die \code{for} Schleife} + + Zur\"uck zu unserer Implementation der Fakult\"at: \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 - ... +>> 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{if - Anweisung (bedingte Anweisung)} + \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} - Wird eingesetzt um bestimmte Code Abschnitte - nur unter bestimmten Umst\"anden auszuf\"uhren. +\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 + x = rand(1); % eine einzelne Zufallszahl + if x < 0.5 disp('x is less than 0.5'); end ->> ->> if x < 0.5 + + + 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 + + + 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 ->> + \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}[fragile] +\begin{frame} \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} + \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{\"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} + \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}