finalized version of the control-structures lecture
This commit is contained in:
parent
2a20eac341
commit
61db2859d2
@ -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}
|
||||
|
||||
Reference in New Issue
Block a user