loops done

programming/code/facultyLoop.m

@@ -0,0 +1,6 @@
+n = 5;
+x = 1;
+for i = 1:n
+	  x = x * i;
+end 
+fprintf('Faculty of %i is: %i\n', n, x)

programming/code/facultyLoop.out

@@ -0,0 +1,2 @@
+>> facultyLoop
+Faculty of 5 is: 120

programming/code/facultyWhileLoop.m

@@ -0,0 +1,7 @@
+n = 5;
+counter = 1;
+x = 1;
+while counter <= n
+    x = x * counter;
+end
+fprintf('Faculty of %i is: %i\n', n, x)

programming/code/neverendingWhile.m

@@ -0,0 +1,6 @@
+i = 1;
+while true % this is always true
+    disp(x);
+    x = x * i;
+    i = i + 1;
+end

programming/lectures/programming.tex

@@ -784,7 +784,7 @@ nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
 In der Regel wird ein Programm Zeile f\"ur Zeile von oben nach unten
 ausgef\"uhrt. Manchmal muss der Kontrollfluss aber so gesteuert
 werden, dass bestimmte Teile des Programmcodes wiederholt oder nur
-unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro[\ss]er
+unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro{\ss}er
 Bedeutung sind hier zwei Strukturen:
 
 \begin{enumerate}
@@ -799,7 +799,7 @@ zu vereinfachen.  In einer \"Ubung wurde die Fakult\"at von 5 wie in
 Listing \ref{facultylisting1} berechnet:
 
 \begin{lstlisting}[caption={Berechnung der Fakult\"at von 5 in f\"unf
-    Schritten}, label=facultylisting1]
+    Schritten}, label=facultylisting]
 >> x = 1;
 >> x = x * 2;
 >> x = x * 3;  
@@ -811,69 +811,113 @@ x =
 \end{lstlisting}
 
 Im Prinzip ist das obige Programm v\"ollig in Ordnung. Es f\"allt
-jedoch auf, dass die Zeilen 2 bis 5 sehr \"ahnlich sind und 
+jedoch auf, dass die Zeilen 2 bis 5 sehr \"ahnlich sind; bis auf die
+Multiplikation mit einer ansteigenden Zahl \"andert sich nichts. Die
+Verwendung von mehr oder weniger exakten Klonen einzelner Zeilen oder
+Abschnitte ist schlechter Prgrammierstil. Dabei geht es nicht nur um
+einen \"asthetischen Aspekt sondern vielmehr darum, dass es schwerwiegende Nachteile gibt.
+\begin{enumerate}
+\item Fehleranf\"alligkeit: Beim ``Copy-and-paste'' kann leicht
+  vergessen werden in einzelnen Klonen die entscheidende \"Anderung
+  auch wirklich vorzunehmen.
+\item Flexibilit\"at: Das obige Programm ist f\"ur genau einen Zweck,
+  Berechnung der Fakult\"at von f\"unf, gemacht und kann nichts
+  anderes.
+\item Wartung: Wenn ich einen Fehler gemacht habe, dann muss ich den
+  Fehler in allen Klonen korrigieren (sehr wird dabei der ein oder
+  andere Klon \"ubersehen).
+\item Verst\"andlichkeit: Solche Abschnitte sind schwerer zu lesen/zu
+  verstehen. Das liegt zum Teil daran, dass man dazu neigt \"uber sich
+  wiederholende Zeilen zu springen (ist ja eh das gleiche...) und dann
+  den entscheidenden Teil verpasst.
+\end{enumerate}
 
-  \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}
+Alle Programmiersprachen bieten zur L\"osung dieses Problems die
+Schleifen. Eine Schleife wird immer dann eingesetzt, wenn man
+Abschnitte wiederholt ausf\"uhren will. 
 
+\subsubsection{\textbf{for}- Schleife}
 
+Der am h\"aufigsten benutzte Vertreter der Schleifen ist die
+\textit{for-Schleife}. Sie besteht aus dem \textit{Schleifenkopf} und
+dem \textit{Schleifenk\"orper}. Der Kopf regelt, wie h\"aufig der Code
+im K\"orper ausgef\"uhrt wird.
 
-  \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}
+\begin{definition}
+  Der Schleifenkopf beginnt mit dem Schl\"usselwort \textbf{for} auf
+  welches folgend die \textit{Laufvariable} definiert wird. In \matlab
+  ``l\"auft''/iteriert eine for-Schleife immer(!) \"uber einen
+  Vektor. Die \textit{Laufvariable} nimmt mit jeder Iteration einen
+  Wert dieses Vektors an.  Im Schleifenk\"orper k\"onnen beliebige
+  Anweisungen ausgef\"uhrt werden. Die Schleife wird durch das
+  Schl\"usselwort \textbf{end} beendet. Listing \ref{looplisting}
+\end{definition}
 
-  \begin{lstlisting}[label=loopListing2]
-   for x = 1:5
-     % ... etwas sinnvolles mit x ...
-   end
-   \end{lstlisting}
-
-
-
-  Zur\"uck zu unserer Implementation der Fakult\"at:
-  \begin{lstlisting}
->> x = 1;
->> x = x * 2;
->> x = x * 3;  
->> x = x * 4;
->> x = x * 5;
->> x
-x =
-    120
+\begin{lstlisting}[caption={Beispiel einer \textbf{for} Schleife. Die Laufvariable \code{x} nimmt mit jeder Iteration der Schleife einen Wert des Vektors \code{1:5} an.}, label=looplisting]
+for x = 1:5
+  % ... etwas sinnvolles mit x ...
+end
 \end{lstlisting}
-\normalsize
-Wie k\"onnte das in einer Schleife gel\"ost werden?
 
 
-  Implementatierung der Fakult\"at mithilfe einer \code{for} Schleife:
-  \begin{lstlisting}
-    x = 1;
-    for i = 1:5
-      x = x * i;
-    end 
-    % oder auch
-    iterations = 1:5;
-    for i = iterations
-      x = x * i;
-    end
+\begin{exercise}{facultyLoop.m}{facultyLoop.out}
+  Wie k\"onnte Fakult\"at mit einer Schleife implementiert werden?
+  Implementiere eine for Schleife, die die Fakul\"at von einer Zahl
+  \code{n} berechnet.
+\end{exercise}
+
+
+\subsubsection{Die \textbf{while}-Schleife}
+
+Eine weiterer Schleifentyp, der weniger h\"aufig eingesetzt wird, ist
+die \textot{while}-Schleife. Auch sie hat ihre Entsprechungen in fast
+allen Programmiersprachen.  \"Ahnlich zur \code{for} Schleife wird
+auch hier der in der Schleife definierte Programmcode iterative
+ausgef\"uhrt.
+
+\begin{definition}
+  Der Schleifenkopf beginnt mit dem Schl\"usselwort \textbf{while}
+  gefolgt von einem \underline{Booleschen Ausdruck}. Solange dieser zu
+  \textit{true} ausgewertet werden kann, wird der Code im
+  Schleifenk\"orper ausgef\"uhrt.  Die Schleife wird mit dem
+  Schl\"usselwort \textbf{end} beendet.
+\end{definition}
+
+
+\begin{lstlisting}[caption={Grundstruktur einer \textbf{while} Schleife.}, label=whileloop]
+while x == true 
+   % fuehre diesen sinnvollen code aus ...
+end
 \end{lstlisting}
+  
+
+\begin{exercise}{facultyWhileLoop.m}{}
+  Implementiere die Fakult\"at mit einer \textbf{while}-Schleife.
+\end{exercise}
+
+
+\begin{exercise}{neverendingWhile.m}{}
+  Implementiere eine \textbf{while}-Schleife, die unendlich
+  l\"auft. Tipp: der Boolesche Ausdruck hinter dem \textbf{while} muss
+  immer zu wahr ausgewertet werden.
+\end{exercise}
+
+
+\subsubsection{Vergleich \textbf{for} und \textbf{while} Schleife}
+\begin{itemize}
+\item Beide f\"uhren den Code im Schleifenk\"orper iterativ 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}
 
 
 \subsection{Bedingte Anweisungen und Verzweigungen}