finalized version of the control-structures lecture

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
+   for x = 1:5
-    ...   % etwas sinnvolles mit x ...
+     % ... etwas sinnvolles mit x ...
    end
->> disp(x);
+   \end{lstlisting}
-    5
->>
-\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 
+>> x = x * 2;
-      ...   % etwas sinnvolles mit x ...
+>> x = x * 3;  
-      disp(x);
+>> x = x * 4;
-      x = x + 1;
+>> 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
-      1      
+  \end{lstlisting}
-      2
+  
-      3
+
-      4
+\end{frame}
-      5
+
->> disp(x)
+\begin{frame}[fragile]
-     6
+  \frametitle{Kontrollstrukturen}
->>
+  \framesubtitle{Die \code{while} - Schleife}
->> while true %never ending loop!
+  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 + 1;
+      x = x * i;
+      i = i + 1;
     end
-     1
-     2
-    ...
 \end{lstlisting}
 \end{frame}
 
 \begin{frame}[fragile]
   \frametitle{Kontrollstrukturen}
-  \framesubtitle{if - Anweisung (bedingte Anweisung)} 
+  \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}
 
-  Wird eingesetzt um bestimmte Code Abschnitte
+\begin{frame}[fragile]
-  nur unter bestimmten Umst\"anden auszuf\"uhren.
+  \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
+   x = rand(1); % eine einzelne Zufallszahl
->> if x < 0.5
+   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
->>
+\end{lstlisting}
->> if x < 0.75
+\end{frame}
-      disp('x is less than 0.75!');
+
-   elseif x < 0.5
+\begin{frame}[fragile]
-      disp('x is less than 0.5!');
+  \frametitle{Kontrollstrukturen}
-   else
+  \framesubtitle{Die \code{switch} - Verzweigung} 
-      disp('x is greater than or equal to 0.75!')
+  \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{break  unnd continue}
+  \framesubtitle{Die Schl\"usselworte \code{break}  und \code{continue}}
-  \vspace{-0.5cm}
+
+  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:5 % using continue
+    for x = 1:10 
       if(x > 2 & x < 5)
          continue;
       end
       disp(x);
     end
-     1
+    
-     2
+    x = 1;
-     5
+    while true
->> 
->> for x = 1:5000 % using break
       if(x > 5)
          break;
       end
       disp(x);
+      x = x + 1
     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}
+  \framesubtitle{\"Ubung: 1-D random walk}
-  \vspace{-0.5cm}
+  Programmiere einen 1-D random walk:
-  \begin{enumerate}\setcounter{enumi}{2}
+  \begin{itemize}
-  \item Erstelle 'x' einen Vektor mit 10 Zufallszahlen im Bereich 0:10.
+  \item In einem random walk ``l\"auft'' ein Objekt zuf\"allig mal in
-    \begin{enumerate}
+    die eine oder andere Richtung.
-    \item Benutze eine for-Schleife um all die Elemente zu loeschen,
+  \item Programmiere 10 Realisationen eines random walk mit jeweils
-      die (\verb+x(index) = [];+) kleiner als 5 sind.
+    1000 Schritten.
-    \item L\"osche alle Elemente die kleiner als  5 und groesser als  2 sind.
+  \item Die Position des Objektes ver\"andert sich in jedem Schritt um
-    \item Kann man das gleiche auch ohne eine Schleife erledigen?
+    +1 oder -1.
-    \end{enumerate}
+  \item Merke Dir alle Positionen.
-  \item Teste den Zufallsgenerator! Dazu z\"ahle die Anzahl der
+  \item Plotte die Positionen als Funktion der Schrittnummer.
-    Elemente, die durch folgende Grenzen getrennt werden [0.2 0.4 0.6
+  \end{itemize}
-      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}