Fixed programming chapter
This commit is contained in:
parent
3417248f72
commit
4804946112
2
Makefile
2
Makefile
@ -1,7 +1,7 @@
|
||||
BASENAME=scientificcomputing-script
|
||||
|
||||
SUBDIRS=designpattern statistics bootstrap regression likelihood pointprocesses
|
||||
#programming
|
||||
# programming
|
||||
SUBTEXS=$(foreach subd, $(SUBDIRS), $(subd)/lecture/$(subd).tex)
|
||||
|
||||
pdf : chapters $(BASENAME).pdf
|
||||
|
||||
@ -6,4 +6,9 @@ size_of_a = size(a); % get the size and store it in a new variable
|
||||
fprintf('number of dimensions (rank) of size_of_a: %i\n', length(size_of_a))
|
||||
|
||||
% get the value of the second element of size_of_a
|
||||
fprintf('number of entries in the 2nd dimesion of a: %i\n', size_of_a(2))
|
||||
fprintf('number of entries in the 2nd dimesion of a: %i\n', size_of_a(2))
|
||||
|
||||
%% Uebersichtliche Alternative?
|
||||
s = size(a); % Speicher den Rueckgabewert von size() in einer Variablen
|
||||
s(2) % Inhalt der zweiten Zahl, d.h. Laenge der 2. Dimension
|
||||
size(a,2) % Kurze Alternative
|
||||
|
||||
@ -24,6 +24,6 @@ ax.set_xlabel("time [s]")
|
||||
ax.set_ylabel("intensity")
|
||||
ax.legend(fontsize=8)
|
||||
fig.tight_layout()
|
||||
fig.savefig("images/logicalIndexingTime.pdf")
|
||||
fig.savefig("logicalIndexingTime.pdf")
|
||||
|
||||
|
||||
|
||||
@ -53,7 +53,7 @@ Listing zeigt zwei M\"oglichkeiten:
|
||||
Die Zeile 1 kann etwa so gelesen werden:''Erzeuge eine Variable mit
|
||||
dem Namen y und weise ihr einen leeren Wert zu.'' Das
|
||||
Gleichheitszeichen ist der sogenannte
|
||||
\textit{Zuweisungsoperator}. Zeile 5 definiert eine Variable x, der
|
||||
\emph{Zuweisungsoperator}. Zeile 5 definiert eine Variable x, der
|
||||
nun der Zahlenwert 38 zugewiesen wird. Da \matlab{}, wenn nicht anders
|
||||
angegeben immer den ``double'' Datentypen benutzt, haben beide
|
||||
Variablen diesen Datentyp.
|
||||
@ -125,7 +125,7 @@ interpretiert werden. Die wichtigsten Datentpyen sind folgende:
|
||||
\item \textit{double} - Flie{\ss}kommazahlen. Im Gegensatz zu den reelen Zahlen, die durch diesen Datentyp dargestellt werden, sind sie abz\"ahlbar.
|
||||
\item \textit{complex} - Komplexe Zahlen.
|
||||
\item \textit{logical} - Boolesche Werte, die als wahr
|
||||
(\textit{true}) oder falsch (\textit{false}) interpretiert werden.
|
||||
(\code{true}) oder falsch (\code{false}) interpretiert werden.
|
||||
\item \textit{char} - ASCII Zeichen
|
||||
\end{itemize}
|
||||
|
||||
@ -166,16 +166,15 @@ ben\"otigen.
|
||||
|
||||
% \begin{definition}[Vektoren und Matrizen]
|
||||
Vektoren und Matrizen sind die wichtigsten Datenstrukturen in
|
||||
\matlab. In anderen Programmiersprachen spricht man von ein-
|
||||
bzw. mehrdimensionalen Feldern. Felder sind Datenstrukturen, die
|
||||
mehrere Werte des geleichen Datentyps in einer Variablen
|
||||
vereinen. Da Matalb seinen Ursprung in der Verarbeitung von
|
||||
mathematischen Vektoren und Matrizen hat, werden sie hier auch so
|
||||
genannt.
|
||||
\matlab. In anderen Programmiersprachen heissen sie ein-
|
||||
bzw. mehrdimensionalen Felder. Felder sind Datenstrukturen, die
|
||||
mehrere Werte des geleichen Datentyps in einer Variablen vereinen. Da
|
||||
Matalb seinen Ursprung in der Verarbeitung von mathematischen Vektoren
|
||||
und Matrizen hat, werden sie hier auch so genannt.
|
||||
|
||||
\matlab{} macht keinen Unterschied zwischen Vektoren und Matrizen.
|
||||
Vektoren sind 2-dimsensionale Matrizen bei denen eine Dimension die Gr\"o{\ss}e 1
|
||||
hat.
|
||||
Vektoren sind 2-dimensionale Matrizen bei denen eine Dimension die
|
||||
Gr\"o{\ss}e 1 hat.
|
||||
% \end{definition}
|
||||
|
||||
|
||||
@ -268,7 +267,7 @@ Vektors zugegriffen werden kann. Dabei spielt es keine Rolle, ob es
|
||||
sich um einen Zeilen- oder Spaltenvektor handelt. \textbf{Achtung!}
|
||||
Anders als viele andere Sprachen beginnt \matlab{} mit dem Index
|
||||
1. Die Listings \ref{arrayListing4} und \ref{arrayListing5} zeigen wie
|
||||
man mit dem Index auf die Inhalte zugreifen kann.
|
||||
mit Indexen auf die Inhalte eines Vektors zugegriffen werden kann.
|
||||
|
||||
\begin{lstlisting}[label=arrayListing4, caption={Zugriff auf den Inhalt von Vektoren I}]
|
||||
>> a = (11:20);
|
||||
@ -340,7 +339,7 @@ Mit Vektoren kann sehr einfach gerechnet werden. Listing
|
||||
Wird ein Vektor mit einem skalaren Wert verrechnet, dann ist das
|
||||
problemlos m\"oglich. Bei der Multiplikation (Zeile 10), der Division
|
||||
(Zeile 14) und auch der Potenzierung mu{\ss} mit vorangestellem '.'
|
||||
klar gemacht werden, dass es sich um eine \textit{elementweise}
|
||||
klar gemacht werden, dass es sich um eine \emph{elementweise}
|
||||
Verarbeitung handeln soll. F\"ur diese elementweisen Operationen kennt
|
||||
\matlab{} die Operatoren \code{.*}, \code{./} und \code{.\^}. Die
|
||||
einfachen Operatoren \code{*}, \code{/} und \code{\^} sind mit den
|
||||
@ -571,17 +570,17 @@ durchgef\"uhrt werden soll.
|
||||
|
||||
\section{Boolesche Operationen}
|
||||
|
||||
Boolesche Ausdr\"ucke sind Anweisungen, die zu \textit{wahr} oder
|
||||
\textit{falsch} ausgewertet werden. Man kennt sie z.B. aus der
|
||||
Boolesche Ausdr\"ucke sind Anweisungen, die zu \emph{wahr} oder
|
||||
\emph{falsch} ausgewertet werden. Man kennt sie z.B. aus der
|
||||
Mengenlehre. In der Programmierung werdens sie eingesetzt, um z.B. die
|
||||
Beziehung zwischen Entit\"aten zu testen. Hierzu werden die
|
||||
\textit{relationalen Operatoren} (\code{>, <, ==, !}, gr\"o{\ss}er
|
||||
als, kleiner als, gleich und nicht) eingesetzt. Mehrere Ausdr\"ucke
|
||||
werden mittels der \textit{logischen Operatoren} (\code{\&, |}, UND,
|
||||
ODER ) verkn\"upft. Sie sind f\"ur uns nicht nur wichtig um
|
||||
Codeabschnitte bedingt auszuf\"uhren (Verzweigungen,
|
||||
\ref{controlstructsec}) sondern auch um aus Vektoren und Matrizen
|
||||
bequem Elemente auszuw\"ahlen (logisches Indizieren,
|
||||
\emph{relationalen Operatoren} (\code{>}, \code{<}, \code{==},
|
||||
\code{!}, gr\"o{\ss}er als, kleiner als, gleich und nicht)
|
||||
eingesetzt. Mehrere Ausdr\"ucke werden mittels der \textit{logischen
|
||||
Operatoren} (\code{\&}, \code{|}}, UND, ODER ) verkn\"upft. Sie sind f\"ur
|
||||
uns nicht nur wichtig um Codeabschnitte bedingt auszuf\"uhren
|
||||
(Verzweigungen, \ref{controlstructsec}) sondern auch um aus Vektoren
|
||||
und Matrizen bequem Elemente auszuw\"ahlen (logisches Indizieren,
|
||||
\ref{logicalindexingsec}). Die folgenden Tabellen zeigen die
|
||||
Wahrheitstabellen f\"ur das logische UND (\ref{logicalandor}, links)
|
||||
aund das logische ODER (\ref{logicalandor}, rechts). Es werden die
|
||||
@ -589,8 +588,7 @@ Aussagen A und B mit dem Operator verkn\"upft. Beim logischen UND ist
|
||||
der gesamte Ausdruck nur dann wahr, wenn beide Ausdr\"ucke sich zu
|
||||
wahr auswerten lassen.
|
||||
|
||||
|
||||
\begin{table}[]
|
||||
\begin{table}[tp]
|
||||
\caption{Wahrheitstabellen logisches UND (links) und logisches ODER (rechts).}\label{logicalandor}
|
||||
\begin{minipage}[t]{0.4\textwidth}
|
||||
\begin{tabular}{llll}
|
||||
@ -610,8 +608,8 @@ wahr auswerten lassen.
|
||||
\end{minipage}
|
||||
\end{table}
|
||||
|
||||
\noindent Anders ist das beim logischen ODER. Hier ist der gesamte
|
||||
Ausdruck wahr, wenn sich der eine \textit{oder} der andere Ausdruck zu
|
||||
Anders ist das beim logischen ODER. Hier ist der gesamte
|
||||
Ausdruck wahr, wenn sich der eine \emph{oder} der andere Ausdruck zu
|
||||
wahr auswerten l\"a{\ss}t. Tabelle \ref{logicaloperators} zeigt die
|
||||
logischen Operatoren, die in \matlab{} definiert sind. Zu bemerken
|
||||
sind hier noch die \code{\&\&} und \code{||} Operatoren. Man kann
|
||||
@ -641,10 +639,10 @@ verf\"ugbar.
|
||||
\end{center}
|
||||
\end{table}
|
||||
|
||||
\noindent Um Werte miteinander zu vergleichen gibt es die \textit{relationalen
|
||||
Um Werte miteinander zu vergleichen gibt es die \textit{relationalen
|
||||
Operatoren} (Tabelle \ref{relationaloperators}). Mit ihnen kann man
|
||||
auf Dinge wie Gleicheit (\code{==}) gr\"o{\ss}er oder kleiner als
|
||||
(\code{>, <}) testen.
|
||||
(\code{>}, \code{<}) testen.
|
||||
|
||||
\begin{table}[th]
|
||||
\caption{\label{relationaloperators}
|
||||
@ -664,7 +662,7 @@ auf Dinge wie Gleicheit (\code{==}) gr\"o{\ss}er oder kleiner als
|
||||
\end{center}
|
||||
\end{table}
|
||||
|
||||
\noindent Das Ergebnis eines Booleschen Ausdrucks ist immer vom Datentyp
|
||||
Das Ergebnis eines Booleschen Ausdrucks ist immer vom Datentyp
|
||||
\textit{logical}. Man kann jede beliebige Variable zu wahr oder falsch
|
||||
auswerten indem man in den Typ \textit{logical} umwandelt. Dabei
|
||||
werden von \matlab{} alle Werte, die nicht 0 sind als wahr
|
||||
@ -733,7 +731,7 @@ nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
|
||||
\textit{wahr} ist (Listing \ref{logicalindexing1}).
|
||||
|
||||
|
||||
\begin{lstlisting}[caption={Beispiel Logischen Indizieren.}, label=logicalindexing1]
|
||||
\begin{lstlisting}[caption={Beispiel logisches Indizieren.}, label=logicalindexing1]
|
||||
>> x = randn(10, 1);
|
||||
>> % in zwei Schritten
|
||||
>> x_smaller_zero = x < 0; % logischer vektor
|
||||
@ -755,7 +753,7 @@ nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
|
||||
von (\code{x}) an den Stellen, an denen \code{x < 5} wahr ist.
|
||||
\end{exercise}
|
||||
|
||||
\noindent Logisches Indizieren wurde oben so benutzt, dass die Auswahl
|
||||
Logisches Indizieren wurde oben so benutzt, dass die Auswahl
|
||||
auf dem Inhalt desselben Vektors beruhte. Ein sehr h\"auiger Fall ist
|
||||
jedoch, dass man die Auswahl aus einem Vektor auf den Inhalt eines
|
||||
zweiten Vektors basiert. Ein Beispiel ist, dass man \"uber einen
|
||||
@ -766,7 +764,7 @@ bestimmten Zeitraums ausw\"ahlen m\"ochte (Abbildung
|
||||
|
||||
\begin{figure}[h]
|
||||
\includegraphics[width= 0.9\columnwidth]{logicalIndexingTime}
|
||||
\caption{\texbf{Beispiel f\"ur ``indirektes'' logisches Indizieren.}
|
||||
\caption{\textbf{Beispiel f\"ur ``indirektes'' logisches Indizieren.}
|
||||
Der rot markierte Abschnitt aus den Daten wurde ``indirekt''
|
||||
anhand logischen Indizierens auf dem Zeitvektor
|
||||
ausgew\"ahlt.}\label{logicalindexingfig}
|
||||
@ -821,7 +819,7 @@ x =
|
||||
120
|
||||
\end{lstlisting}
|
||||
|
||||
\noindent Im Prinzip ist das obige Programm v\"ollig in Ordnung. Es f\"allt
|
||||
Im Prinzip ist das obige Programm v\"ollig in Ordnung. Es f\"allt
|
||||
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
|
||||
@ -842,27 +840,26 @@ einen \"asthetischen Aspekt sondern vielmehr darum, dass es schwerwiegende Nacht
|
||||
wiederholende Zeilen zu springen (ist ja eh das gleiche...) und dann
|
||||
den entscheidenden Teil verpasst.
|
||||
\end{enumerate}
|
||||
|
||||
\noindent Alle Programmiersprachen bieten zur L\"osung dieses Problems die
|
||||
Alle Programmiersprachen bieten zur L\"osung dieses Problems die
|
||||
Schleifen. Eine Schleife wird immer dann eingesetzt, wenn man
|
||||
Abschnitte wiederholt ausf\"uhren will.
|
||||
|
||||
\subsubsection{Die \textbf{for} --- Schleife}
|
||||
\subsubsection{Die \code{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. Der Schleifenkopf beginnt mit dem
|
||||
Schl\"usselwort \textbf{for} auf welches folgend die
|
||||
Schl\"usselwort \code{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} zeigt das
|
||||
\code{end} beendet. Listing \ref{looplisting} zeigt das
|
||||
Grundger\"ust einer for-Schleife.
|
||||
|
||||
\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]
|
||||
\begin{lstlisting}[caption={Beispiel einer \code{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
|
||||
@ -876,20 +873,20 @@ end
|
||||
\end{exercise}
|
||||
|
||||
|
||||
\subsubsection{Die \textbf{while} --- Schleife}
|
||||
\subsubsection{Die \code{while} -- Schleife}
|
||||
|
||||
Eine weiterer Schleifentyp, der weniger h\"aufig eingesetzt wird, ist
|
||||
die \textot{while}-Schleife. Auch sie hat ihre Entsprechungen in fast
|
||||
die \code{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 iterativ
|
||||
ausgef\"uhrt. Der Schleifenkopf beginnt mit dem Schl\"usselwort
|
||||
\textbf{while} gefolgt von einem \underline{Booleschen
|
||||
Ausdruck}. Solange dieser zu \textit{true} ausgewertet werden kann,
|
||||
\code{while} gefolgt von einem \underline{Booleschen
|
||||
Ausdruck}. Solange dieser zu \code{true} ausgewertet werden kann,
|
||||
wird der Code im Schleifenk\"orper ausgef\"uhrt. Die Schleife wird
|
||||
mit dem Schl\"usselwort \textbf{end} beendet.
|
||||
mit dem Schl\"usselwort \code{end} beendet.
|
||||
|
||||
|
||||
\begin{lstlisting}[caption={Grundstruktur einer \textbf{while} Schleife.}, label=whileloop]
|
||||
\begin{lstlisting}[caption={Grundstruktur einer \code{while} Schleife.}, label=whileloop]
|
||||
while x == true
|
||||
% fuehre diesen sinnvollen code aus ...
|
||||
end
|
||||
@ -897,24 +894,24 @@ end
|
||||
|
||||
|
||||
\begin{exercise}{facultyWhileLoop.m}{}
|
||||
Implementiere die Fakult\"at mit einer \textbf{while}-Schleife.
|
||||
Implementiere die Fakult\"at mit einer \code{while}-Schleife.
|
||||
\end{exercise}
|
||||
|
||||
|
||||
\begin{exercise}{neverendingWhile.m}{}
|
||||
Implementiere eine \textbf{while}-Schleife, die unendlich
|
||||
l\"auft. Tipp: wenn der Boolesche Ausdruck hinter dem \textbf{while}
|
||||
Implementiere eine \code{while}-Schleife, die unendlich
|
||||
l\"auft. Tipp: wenn der Boolesche Ausdruck hinter dem \code{while}
|
||||
zu wahr ausgewertet wird, wird die Schleife weiter ausgef\"uhrt.
|
||||
\end{exercise}
|
||||
|
||||
|
||||
\subsubsection{Vergleich \textbf{for} und \textbf{while} Schleife}
|
||||
\subsubsection{Vergleich \code{for} -- und \code{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.
|
||||
betreten. % XXX Nur wenn die Liste im Kopf nicht leer ist, oder ?
|
||||
\item Der K\"orper einer \code{while} Schleife wird nur dann betreten,
|
||||
wenn die Bedinung im Kopf \textbf{true} ist. \\$\rightarrow$ auch
|
||||
wenn die Bedingung im Kopf \code{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.
|
||||
@ -931,25 +928,25 @@ Bedingte Anweisungen und Verzweigungen sind Kontrollstrukturen, die
|
||||
regeln, dass der in ihnen eingeschlossene Programmcode nur unter
|
||||
bestimmten Bedingungen ausgef\"uhrt wird.
|
||||
|
||||
\subsubsection{Die if --- Anweisung}
|
||||
\subsubsection{Die \code{if} -- Anweisung}
|
||||
|
||||
Am h\"aufigsten genutzter Vertreter ist die \textbf{if} -
|
||||
Am h\"aufigsten genutzter Vertreter ist die \code{if} -
|
||||
Anweisung. Sie Wird genutzt um Programmcode nur unter bestimmten
|
||||
Bedingungen auszuf\"uhren.
|
||||
\begin{definition}
|
||||
Der Kopf der if - Anweisung beginnt mit dem Schl\"usselwort
|
||||
\textbf{if} welches von einem \underline{Booleschen Ausdruck}
|
||||
gefolgt wird. Wenn dieser zu \textbf{true} ausgewertet werden kann,
|
||||
\code{if} welches von einem \underline{Booleschen Ausdruck}
|
||||
gefolgt wird. Wenn dieser zu \code{true} ausgewertet werden kann,
|
||||
wird der Code im K\"orper der Anweisung ausgef\"uhrt. Optional
|
||||
k\"onnen weitere Bedingungen mit dem Schl\"usselwort \textbf{elseif}
|
||||
k\"onnen weitere Bedingungen mit dem Schl\"usselwort \code{elseif}
|
||||
folgen. Ebenfalls optional ist die Verwendung eines finalen
|
||||
\textbf{else} Falls. Dieser wird immer dann ausgef\"uhrt wenn alle
|
||||
\code{else} Falls. Dieser wird immer dann ausgef\"uhrt wenn alle
|
||||
vorherigen Bedingungen nicht erf\"ullt werden. Die \code{if}
|
||||
Anweisung wird mit \textbf{end} beendet. Listing \ref{ifelselisting}
|
||||
Anweisung wird mit \code{end} beendet. Listing \ref{ifelselisting}
|
||||
zeigt den Aufbau einer if-Anweisung.
|
||||
\end{definition}
|
||||
|
||||
\begin{lstlisting}[label=ifelselisting, caption={Grundger\"ust einer \textbf{if} Anweisung.}]
|
||||
\begin{lstlisting}[label=ifelselisting, caption={Grundger\"ust einer \code{if} Anweisung.}]
|
||||
if x < y
|
||||
% fuehre diesen code aus
|
||||
elseif x > y
|
||||
@ -960,7 +957,7 @@ end
|
||||
\end{lstlisting}
|
||||
|
||||
\begin{exercise}{ifelse.m}{}
|
||||
Ziehe eine Zufallszahl und \"uberpr\"ufe mit einer geegnet \textbf{if} Anweisung, ob sie:
|
||||
Ziehe eine Zufallszahl und \"uberpr\"ufe mit einer geegnet \ciode{if} Anweisung, ob sie:
|
||||
\begin{enumerate}
|
||||
\item ... kleiner als 0.5 ist.
|
||||
\item ... kleiner oder gr\"o{\ss}er-gleich 0.5 ist.
|
||||
@ -969,27 +966,27 @@ end
|
||||
\end{enumerate}
|
||||
\end{execise}
|
||||
|
||||
\subsubsection{Die \code{switch} - Verzweigung}
|
||||
\subsubsection{Die \code{switch} -- Verzweigung}
|
||||
|
||||
Die \textbf{switch} Verzweigung Wird eingesetzt wenn mehrere F\"alle
|
||||
Die \code{switch} Verzweigung Wird eingesetzt wenn mehrere F\"alle
|
||||
auftreten k\"onnen, die einer unterschiedlichen Behandlung bed\"urfen.
|
||||
|
||||
\begin{definition}
|
||||
Wird mit dem Schl\"usselwort \textbf{switch} begonnen, gefolgt von
|
||||
Wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von
|
||||
der \textit{switch Anweisung} (Zahl oder String). Jeder Fall auf den
|
||||
die Anweisung \"uberpr\"ft werden soll wird mit dem Schl\"usselwort
|
||||
\textbf{case} eingeleitet. Diese wird gefolgt von der \textit{case
|
||||
\code{case} eingeleitet. Diese wird gefolgt von der \textit{case
|
||||
Anweisung} welche definiert gegen welchen Fall auf
|
||||
\underline{Gleichheit} getestet wird. F\"ur jeden Fall wird der
|
||||
Programmcode angegeben, der ausgef\"uhrt werden soll Optional
|
||||
k\"onnen mit dem Schl\"usselwort \textbf{otherwise} alle nicht
|
||||
k\"onnen mit dem Schl\"usselwort \code{otherwise} alle nicht
|
||||
explizit genannten F\"alle behandelt werden. Die \code{switch}
|
||||
Anweisung wird mit \textbf{end} beendet (z.B. in Listing
|
||||
Anweisung wird mit \code{end} beendet (z.B. in Listing
|
||||
\ref{switchlisting}).
|
||||
\end{definition}
|
||||
|
||||
|
||||
\begin{lstlisting}[label=switchlisting, caption={Grundger\"ust einer \textbf{switch} Anweisung.}]
|
||||
\begin{lstlisting}[label=switchlisting, caption={Grundger\"ust einer \code{switch} Anweisung.}]
|
||||
mynumber = input('Enter a number:');
|
||||
switch mynumber
|
||||
case -1
|
||||
@ -1001,11 +998,11 @@ switch mynumber
|
||||
end
|
||||
\end{lstlisting}
|
||||
|
||||
Wichtig ist hier, dass in jedem \textbf{case} auf \underline{Gleichheit} der
|
||||
Wichtig ist hier, dass in jedem \code{case} auf \underline{Gleichheit} der
|
||||
switch-Anweisung und der case-Anweisung getestet wird.
|
||||
|
||||
|
||||
\subsubsection{Vergleich if - Anweisung und switch Verzweigung}
|
||||
\subsubsection{Vergleich \code{if} -- Anweisung und \code{switch} -- Verzweigung}
|
||||
\begin{itemize}
|
||||
\item Mit der \code{if} Anweisung k\"onnen beliebige F\"alle
|
||||
unterschieden und entsprechender code ausgef\"uhrt werden.
|
||||
@ -1021,8 +1018,8 @@ switch-Anweisung und der case-Anweisung getestet wird.
|
||||
\subsection{Die Schl\"usselworte \code{break} und \code{continue}}
|
||||
|
||||
Soll die Ausf\"uhrung einer Schleife abgebrochen oder \"ubersprungen
|
||||
werden, werden die Schl\"usselworte \textbf{break} und
|
||||
\textbf{continue} eingesetzt (Listing \ref{breakcontinuelisting}
|
||||
werden, werden die Schl\"usselworte \code{break} und
|
||||
\code{continue} eingesetzt (Listing \ref{breakcontinuelisting}
|
||||
zeigt, wie sie eingesetzt werden k\"onnen).
|
||||
|
||||
\begin{lstlisting}[caption={Ensatz der \code{continue} und \code{break} Schl\"usselworte um die Ausf\"uhrung von Abschnitte in Schleife zu \"uberspringen oder abzubrechen.}, label=breakcontinuelisting]
|
||||
@ -1087,8 +1084,7 @@ wird, dann wird es Zeile f\"r Zeile von oben nach unten ausgef\"uhrt.
|
||||
\item Funktionen
|
||||
\item Objekte (werden wir ignorieren)
|
||||
\end{enumerate}
|
||||
|
||||
\noindent Alle Programme werden in den sogenannten \textit{m-files} gespeichert
|
||||
Alle Programme werden in den sogenannten \textit{m-files} gespeichert
|
||||
(z.B. \textit{meinProgramm.m}). Um sie zu benutzen werden sie von der
|
||||
Kommandozeile aufgerufen oder in anderen Programmen
|
||||
verwendet. Programme erh\"ohen die Wiederverwertbarkeit von
|
||||
@ -1102,16 +1098,14 @@ definierte Variable und weist ihr einen neuen Wert zu, dann kann das
|
||||
erw\"unscht und praktisch sein. Wenn es aber unbeabsichtigt passiert
|
||||
kann es zu Fehlern kommen, die nur sehr schwer erkennbar sind, da ja
|
||||
jedes Skript f\"ur sich enwandtfrei arbeitet. Eine L\"osung f\"ur
|
||||
dieses Problem bieten die \textbf{Funktionen}.
|
||||
dieses Problem bieten die \emph{Funktionen}.
|
||||
|
||||
\subsection{Funktionen}
|
||||
|
||||
Eine Funktion in \matlab{} wird \"ahnlich zu einer mathematischen
|
||||
Funktion definiert:
|
||||
|
||||
\[ y = f(x) \]
|
||||
|
||||
\noindent Die Funktion hat einen Namen $f$, sie h\"angt von einem Argument $x$
|
||||
Die Funktion hat einen Namen $f$, sie h\"angt von einem Argument $x$
|
||||
ab und liefert ein Ergebnis $y$ zur\"uck. Listing
|
||||
\ref{functiondefinitionlisting} zeigt wie das in \matlab{} umgesetzt
|
||||
wird.
|
||||
@ -1122,29 +1116,28 @@ function [y] = function_name(arg_1, arg_2)
|
||||
% Rueckgabewert Argument_1, Argument_2
|
||||
\end{lstlisting}
|
||||
|
||||
\noindent Ein Funktion beginnt mit dem Schl\"usselwort \textbf{function} gefolgt
|
||||
Ein Funktion beginnt mit dem Schl\"usselwort \code{function} gefolgt
|
||||
von den R\"uckgabewerte(n), dem Funktionsnamen und (in Klammern) den
|
||||
Argumenten. Auf den Funktionskopf folgt der auszuf\"uhrende
|
||||
Programmcode im Funktionsk\"orper. Die Funktionsdefinition wird
|
||||
optional mit einem \textbf{end} abgeschlossen. Jede Funktion, die vom
|
||||
Nutzer direkt verwendet werden soll ist in einer eigenen Datei
|
||||
definiert. \"uber die Definition/Benutzung von Funktionen wird folgendes erreicht:
|
||||
|
||||
% optional %XXX es ist vielleicht optional, aber gute stil ware es immer hinzuschreiben, oder?
|
||||
mit einem \code{end} abgeschlossen. Jede Funktion, die vom
|
||||
Nutzer direkt verwendet werden soll, ist in einer eigenen Datei
|
||||
definiert. \"Uber die Definition/Benutzung von Funktionen wird folgendes erreicht:
|
||||
\begin{itemize}
|
||||
\item Kapseln von Programmcode, der f\"ur sich eine Aufgabe l\"ost.
|
||||
\item Definierte Schnittstelle.
|
||||
\item Eigener G\"ultigkeitsbereich:
|
||||
\begin{itemize}
|
||||
\item Variablen im Workspace sind in der Funktion \textbf{nicht} sichtbar.
|
||||
\item Variablen im Workspace sind in der Funktion \emph{nicht} sichtbar.
|
||||
\item Variablen, die in der Funktion definiert werden erscheinen
|
||||
\textbf{nicht} im Workspace.
|
||||
\emph{nicht} im Workspace.
|
||||
\end{itemize}
|
||||
\item Erhöht die Wiederverwendbarkeit von Programmcode.
|
||||
\item Erh\"oht die Wiederverwendbarkeit von Programmcode.
|
||||
\item Erh\"oht die Lesbarkeit von Programmen, da sie
|
||||
\"ubersichtlicher werden.
|
||||
\end{itemize}
|
||||
|
||||
\noindent Das Folgende Beispiel (Listing \ref{badsinewavelisting}) zeigt eine
|
||||
Das Folgende Beispiel (Listing \ref{badsinewavelisting}) zeigt eine
|
||||
Funktion, die eine Reihe von Sinusschwingungen unterschiedlicher
|
||||
Frequenzen berechnet und graphisch darstellt.
|
||||
|
||||
@ -1160,25 +1153,23 @@ function meine_erste_funktion() % Funktionskopf
|
||||
hold on;
|
||||
end
|
||||
\end{lstlisting}
|
||||
|
||||
\noindent Das obige Beispiel ist ein Paradebeispiel f\"ur eine schlechte
|
||||
Das obige Beispiel ist ein Paradebeispiel f\"ur eine schlechte
|
||||
Funktion. Sie hat folgende Probleme:
|
||||
\begin{itemize}
|
||||
\item Der Name ist nicht aussagekr\"aftig.
|
||||
\item Die Funktion ist f\"ur genau einen Zweck geeignet.
|
||||
\item Was sie tut, ist festgelegt und kann von au{\ss}en nicht
|
||||
beeinflusst oder bestimmt werden.
|
||||
\item Sie tut drei Dinge aus einmal: Sinus berechnen \textbf{und}
|
||||
Amplituden \"andern \textbf{und} graphisch darstellen.
|
||||
\item Sie tut drei Dinge aus einmal: Sinus berechnen \emph{und}
|
||||
Amplituden \"andern \emph{und} graphisch darstellen.
|
||||
\item Es ist nicht (einfach) m\"oglich an die berechneten Daten zu
|
||||
kommen.
|
||||
\item Keinerlei Dokumentation. Man muss den code lesen um zu
|
||||
rekonstruieren, was sie tut.
|
||||
\end{itemize}
|
||||
|
||||
\noindent Bevor wir anfangen die Funktion zu verbessern mu{\ss} definiert werden
|
||||
Bevor wir anfangen die Funktion zu verbessern mu{\ss} definiert werden
|
||||
was das zu l\"osende Problem ist:
|
||||
|
||||
\begin{enumerate}
|
||||
\item Welches Problem soll gel\"ost werden?
|
||||
\item Aufteilen in Teilprobleme.
|
||||
@ -1187,9 +1178,8 @@ was das zu l\"osende Problem ist:
|
||||
wissen? Was sollen sie zur\"uckliefern?
|
||||
\item Daten zur\"uck geben (R\"uckgabewerte definieren).
|
||||
\end{enumerate}
|
||||
|
||||
\noindent Das Beispielproblem aus Listing \ref{badsinewavelisting} kann in drei
|
||||
Teilprobleme aufgetrennt werden. (i) Berechnen der \textbf{einzelnen}
|
||||
Das Beispielproblem aus Listing \ref{badsinewavelisting} kann in drei
|
||||
Teilprobleme aufgetrennt werden. (i) Berechnen der \emph{einzelnen}
|
||||
Sinus. (ii) Plotten der jeweils berechneten Daten und (iii)
|
||||
Koordination von Berechnung und Darstellung mit unterschiedlichen
|
||||
Amplituden.
|
||||
@ -1204,19 +1194,18 @@ welche Daten sie zur\"uckliefern soll.
|
||||
\begin{enumerate}
|
||||
\item \textbf{Name:} der Name sollte schon beschreiben, was die Funktion
|
||||
tut. In diesem Fall berechnet sie einen Sinus. Ein geeigneter Name
|
||||
w\"are also \textit{calculate\_sinwave}.
|
||||
w\"are also \code{calculate\_sinwave}.
|
||||
\item \textbf{Argumente:} die zu brechnende Sinusschwingung sei durch
|
||||
ihre Frequenz und die Amplitude bestimmt. Des Weiteren soll noch
|
||||
festgelegt werden, wie lang der Sinus sein soll und mit welcher
|
||||
zeitlichen Aufl\"osung gerechnet werden soll. Es werden also vier
|
||||
Argumente ben\"otigt, sie k\"onnten hei{\ss}en: \textit{amplitude,
|
||||
frequency, t\_max, t\_step}.
|
||||
Argumente ben\"otigt, sie k\"onnten hei{\ss}en: \code{amplitude},
|
||||
\code{frequency}, \code{t\_max}, \code{t\_step}.
|
||||
\item \textbf{R\"uckgabewerte:} Um den Sinus korrekt darstellen zu k\"onnen brauchen wir die
|
||||
Zeitachse und die entsprechenden Werte. Es werden also zwei
|
||||
Variablen zur\"uckgegeben: \textit{time, sine}
|
||||
Variablen zur\"uckgegeben: \code{time, sine}
|
||||
\end{enumerate}
|
||||
|
||||
\noindent Mit dieser Information ist es nun gut m\"oglich die Funktion zu
|
||||
Mit dieser Information ist es nun gut m\"oglich die Funktion zu
|
||||
implementieren (Listing \ref{sinefunctionlisting}).
|
||||
|
||||
\begin{lstlisting}[caption={Funktion, die einen Sinus berechnet.}, label=sinefunctionlisting]
|
||||
@ -1238,7 +1227,7 @@ function [time, sine] = calculate_sinewave(frequency, amplitude, t_max, t_step)
|
||||
Diese Aufage kann auch von einer Funktion \"ubernommen werden. Diese
|
||||
Funktion hat keine andere Aufgabe, als die Daten zu plotten. Ihr Name
|
||||
sollte sich an dieser Aufgabe orientieren
|
||||
(z.B. \textit{plot\_sinewave}). Um einen einzelnen Sinus zu plotten
|
||||
(z.B. \code{plot\_sinewave}). Um einen einzelnen Sinus zu plotten
|
||||
werden im Wesentlichen die x-Werte und die zugeh\"origen y-Werte
|
||||
ben\"otigt. Da mehrere Sinus geplottet werden sollen ist es auch
|
||||
sinnvoll eine Zeichenkette f\"ur die Legende an die Funktion zu
|
||||
@ -1301,8 +1290,7 @@ Funktionen sind kleine Code Fragmente, die
|
||||
\item ... ihren eigenen G\"ultigkeitsbereich haben.
|
||||
\item ... Skripten fast immer vorzuziehen sind.
|
||||
\end{enumerate}
|
||||
|
||||
\noindent Die vorangegangene Aussagen klingen, als ob Skripte zu
|
||||
Die vorangegangene Aussagen klingen, als ob Skripte zu
|
||||
verteufeln w\"aren und und vermieden werden sollten. Dem ist nicht
|
||||
so. In Wahrheit sind sie daf\"ur gemacht, Hand in Hand mit den
|
||||
Funktionen ein Probelm zu l\"osen. W\"ahrend die Funktionen relativ
|
||||
@ -1310,7 +1298,6 @@ kleine ``verdauliche'' Teilprobleme l\"osen. Sind die Skripte daf\"ur
|
||||
gemacht den Rahmen zu bilden und den Ablauf zu koordinieren (Abbildung
|
||||
\ref{programlayoutfig}).
|
||||
|
||||
|
||||
\begin{figure}
|
||||
\includegraphics[width=0.5\columnwidth]{./images/simple_program.pdf}
|
||||
\caption{\textbf{Ein typisches Programmlayout.} Das Kontrollskript
|
||||
|
||||
Reference in New Issue
Block a user