language and code fixes
This commit is contained in:
parent
508b6bb5cc
commit
29c5e4d8ed
@ -1,6 +1,6 @@
|
||||
n = 5;
|
||||
x = 1;
|
||||
for i = 1:n
|
||||
x = x * i;
|
||||
x = x * i;
|
||||
end
|
||||
fprintf('Faculty of %i is: %i\n', n, x)
|
||||
fprintf('Faculty of %i is: %i\n', n, x)
|
||||
|
||||
@ -7,7 +7,7 @@ figure()
|
||||
hold on
|
||||
|
||||
for i = 1:length(amplitudes)
|
||||
for j = i:length(frequencies)
|
||||
for j = 1:length(frequencies)
|
||||
[x_data, y_data] = calculate_sinewave(frequencies(j), ...
|
||||
amplitudes(i), t_max, t_step);
|
||||
plot_sinewave(x_data, y_data, sprintf('freq: %5.2f, ampl: %5.2f',...
|
||||
|
||||
@ -600,7 +600,7 @@ Eine elementweise Multiplikation (\code{.*} Operator, Listing
|
||||
|
||||
Boolesche Ausdr\"ucke sind Anweisungen, die zu \codeterm{wahr} oder
|
||||
\codeterm{falsch} ausgewertet werden. Man kennt sie z.B. aus der
|
||||
Mengenlehre. In der Programmierung werdens sie eingesetzt, um z.B. die
|
||||
Mengenlehre. In der Programmierung werden sie eingesetzt, um z.B. die
|
||||
Beziehung zwischen Entit\"aten zu testen. Hierzu werden die
|
||||
\codeterm{relationalen Operatoren} (\code{>}, \code{<}, \code{==},
|
||||
\code{!}, gr\"o{\ss}er als, kleiner als, gleich und nicht)
|
||||
@ -609,9 +609,9 @@ eingesetzt. Mehrere Ausdr\"ucke werden mittels der \codeterm{logischen
|
||||
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
|
||||
\ref{logicalindexingsec}). Die Tabellen \ref{logicalandor} zeigen die
|
||||
Wahrheitstabellen f\"ur das logische UND (Tabelle \ref{logicalandor}, links)
|
||||
und das logische ODER (Tabelle \ref{logicalandor}, rechts). Es werden die
|
||||
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.
|
||||
@ -636,19 +636,18 @@ wahr auswerten lassen.
|
||||
\end{minipage}
|
||||
\end{table}
|
||||
|
||||
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
|
||||
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
|
||||
beliebige Ausdr\"ucke verkn\"upfen und h\"aufig kann schon anhand des
|
||||
ersten Ausdrucks entschieden werden, ob der gesamte Boolesche Ausdruck
|
||||
zu wahr oder falsch ausgewertet werden wird. Wenn zwei Aussagen mit
|
||||
einem UND verkn\"upft werden und der erste zu falsch ausgewerte wird,
|
||||
dann muss der zweite gar nicht mehr gepr\"uft werden. Die Verwendung
|
||||
der ``short-circuit'' Versionen spart Rechenzeit. Das auschliessende
|
||||
ODER (XOR) ist in \matlab{} nur als Funktion \code{xor(A, B)}
|
||||
verf\"ugbar.
|
||||
einem UND verkn\"upft werden und der erste zu falsch ausgewertet wird,
|
||||
muss der zweite gar nicht mehr gepr\"uft werden. Die Verwendung der
|
||||
``short-circuit'' Versionen spart Rechenzeit. Das auschlie{\ss}ende ODER
|
||||
(XOR) ist in \matlab{} nur als Funktion \code{xor(A, B)} verf\"ugbar.
|
||||
|
||||
\begin{table}[th]
|
||||
\titlecaption{\label{logicaloperators}
|
||||
@ -660,8 +659,8 @@ verf\"ugbar.
|
||||
$\sim$ & logisches NOT\\
|
||||
$\&$ & logisches UND\\
|
||||
$|$ & logisches ODER\\
|
||||
$\&\&$ & short-circuit logical UND\\
|
||||
$\|$ & short-circuit logical ODER\\
|
||||
$\&\&$ & short-circuit logisches UND\\
|
||||
$\|$ & short-circuit logisches ODER\\
|
||||
\hline
|
||||
\end{tabular}
|
||||
\end{center}
|
||||
@ -669,7 +668,7 @@ verf\"ugbar.
|
||||
|
||||
Um Werte miteinander zu vergleichen gibt es die \codeterm{relationalen
|
||||
Operatoren} (Tabelle \ref{relationaloperators}). Mit ihnen kann man
|
||||
auf Dinge wie Gleicheit (\code{==}) gr\"o{\ss}er oder kleiner als
|
||||
auf Dinge wie Gleichheit (\code{==}) gr\"o{\ss}er oder kleiner als
|
||||
(\code{>}, \code{<}) testen.
|
||||
|
||||
\begin{table}[th]
|
||||
@ -680,9 +679,9 @@ auf Dinge wie Gleicheit (\code{==}) gr\"o{\ss}er oder kleiner als
|
||||
\hline
|
||||
\textbf{Operator} & \textbf{Beschreibung} \\ \hline
|
||||
$<$ & kleiner als\\
|
||||
$>$ & gr\"osser als \\
|
||||
$>$ & gr\"o{\ss}er als \\
|
||||
$==$ & gleich \\
|
||||
$>=$ & gr\"osser oder gleich \\
|
||||
$>=$ & gr\"o{\ss}er oder gleich \\
|
||||
$<=$ & kleiner oder gleich \\
|
||||
$\sim=$ & ungleich\\
|
||||
\hline
|
||||
@ -697,10 +696,13 @@ werden von \matlab{} alle Werte, die nicht 0 sind als wahr
|
||||
eingesch\"atzt. Listing \ref{booleanexpressions} zeigt einige
|
||||
Beispiele. \matlab{} kennt die Schl\"usselworte \code{true} und
|
||||
\code{false}. Diese sind jedoch nur Synonyme f\"ur die
|
||||
\code{logical} Werte 1 und 0. Man beachte, dass der
|
||||
Zuweisungsoperator \code{=} und der logische Operator \code{==} zwei
|
||||
grundverschiedene Dinge sind. Da sie umgangsprachlich gleich sind kann
|
||||
man sie leider leicht verwechseln.
|
||||
\code{logical} Werte 1 und 0.
|
||||
|
||||
\begin{important}
|
||||
Man beachte, dass der Zuweisungsoperator \code{=} und der logische
|
||||
Operator \code{==} zwei grundverschiedene Dinge sind. Da sie
|
||||
umgangsprachlich gleich sind kann man sie leider leicht verwechseln.
|
||||
\end{important}
|
||||
|
||||
\begin{lstlisting}[caption={Boolesche Ausdr\"ucke.}, label=booleanexpressions]
|
||||
>> true
|
||||
@ -744,7 +746,7 @@ man sie leider leicht verwechseln.
|
||||
|
||||
\section{Logisches Indizieren}\label{logicalindexingsec}
|
||||
|
||||
Einer der wichtigsten Einsatzorte f\"ur Bollesche Ausdr\"ucke ist das
|
||||
Einer der wichtigsten Einsatzorte f\"ur Boolesche Ausdr\"ucke ist das
|
||||
logische Indizieren. Das logische Indizieren ist eines der
|
||||
Schl\"usselkonzepte in \matlab{}. Nur mit diesem k\"onnen
|
||||
Filteroperationen auf Vektoren und Matrizen effizient durchgef\"uhrt
|
||||
@ -753,9 +755,9 @@ sehr intuitiv zu benuzten.
|
||||
|
||||
Das Grundkonzept hinter der logischen Indizierung ist, dass man durch
|
||||
die Verwendung eines Booleschen Ausdrucks auf z.B. einen Vektor einen
|
||||
logischen Vektor gleicher Gr\"o{\ss}e erh\"alt. Dieser wird nun
|
||||
logischen Vektor gleicher Gr\"o{\ss}e erh\"alt. Dieser wird
|
||||
benutzt um auf den urspr\"unglichen Vektor zuzugreifen. \matlab{} gibt
|
||||
nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
|
||||
nur die Werte an den Stellen zur\"uck, an denen der logische Vektor
|
||||
\codeterm{wahr} ist (Listing \ref{logicalindexing1}).
|
||||
|
||||
|
||||
@ -777,7 +779,7 @@ nun die Werte an den Stellen zur\"uck, an denen der logische Vektor
|
||||
\item Gibt alle Elemente aus x zur\"uck, die kleiner als 5 sind.
|
||||
\end{enumerate}
|
||||
|
||||
Die letzte Zeile kann wie folgt gelesen werden: Gib mir die Elemente
|
||||
Zeile 12 in der L\"osung kann wie folgt gelesen werden: Gib mir die Elemente
|
||||
von (\code{x}) an den Stellen, an denen \code{x < 5} wahr ist.
|
||||
\end{exercise}
|
||||
|
||||
@ -800,12 +802,12 @@ bestimmten Zeitraums ausw\"ahlen m\"ochte (Abbildung
|
||||
|
||||
\begin{exercise}{logicalIndexingTime.m}{}
|
||||
Angenommen es werden \"uber einen bestimmten Zeitraum Messwerte
|
||||
genommen. Bei solchen Messungen er\"alt man einen Vektor, der die
|
||||
genommen. Bei solchen Messungen erh\"alt man einen Vektor, der die
|
||||
Zeitpunkte der Messung speichert und einen zweiten mit den
|
||||
jeweiligen Messwerten.
|
||||
|
||||
\begin{itemize}
|
||||
\item Erstelle einen Vektor \code{t= 0:0.001:10;}, der z.B. die Zeit
|
||||
\item Erstelle einen Vektor \code{t = 0:0.001:10;}, der z.B. die Zeit
|
||||
repr\"asentiert.
|
||||
\item Erstelle einen zweiten Vektor \code{x} mit Zufallszahlen der
|
||||
die gleiche L\"ange hat wie \code{t}. Die Werte darin stellen
|
||||
@ -820,8 +822,8 @@ bestimmten Zeitraums ausw\"ahlen m\"ochte (Abbildung
|
||||
|
||||
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
|
||||
werden, dass bestimmte Teile wiederholt oder nur
|
||||
unter bestimmten Bedingungen ausgef\"uhrt werden sollen. Von gro{\ss}er
|
||||
Bedeutung sind hier zwei Strukturen:
|
||||
|
||||
\begin{enumerate}
|
||||
@ -851,7 +853,7 @@ 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
|
||||
Abschnitte ist schlechter Prgrammierstil. Dabei geht es nicht nur um
|
||||
ganzer 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
|
||||
@ -861,12 +863,13 @@ einen \"asthetischen Aspekt sondern vielmehr darum, dass es schwerwiegende Nacht
|
||||
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
|
||||
Fehler in allen Klonen korrigieren (sehr leicht 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.
|
||||
den entscheidenden Teil verpasst. Zum Anderen f\"uhrt
|
||||
Codeduplication zu langen, un\"ubersichtlichen Programmen.
|
||||
\end{enumerate}
|
||||
Alle Programmiersprachen bieten zur L\"osung dieses Problems die
|
||||
Schleifen. Eine Schleife wird immer dann eingesetzt, wenn man
|
||||
@ -896,8 +899,8 @@ 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.
|
||||
Implementiere eine \code{for} Schleife, die die Fakul\"at von einer
|
||||
Zahl \code{n} berechnet.
|
||||
\end{exercise}
|
||||
|
||||
|
||||
@ -908,10 +911,10 @@ 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
|
||||
\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 \code{end} beendet.
|
||||
\code{while} gefolgt von einem 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 \code{end} beendet.
|
||||
|
||||
|
||||
\begin{lstlisting}[caption={Grundstruktur einer \code{while} Schleife.}, label=whileloop]
|
||||
@ -937,7 +940,7 @@ end
|
||||
\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. % XXX Nur wenn die Liste im Kopf nicht leer ist, oder ?
|
||||
betreten (au{\ss}er wenn der Vektor im Schleifenkopf leer ist).
|
||||
\item Der K\"orper einer \code{while} Schleife wird nur dann betreten,
|
||||
wenn die Bedingung im Kopf \code{true} ist. \\$\rightarrow$ auch
|
||||
``Oben-abweisende'' Schleife genannt.
|
||||
@ -959,19 +962,19 @@ bestimmten Bedingungen ausgef\"uhrt wird.
|
||||
\subsubsection{Die \code{if} -- Anweisung}
|
||||
|
||||
Am h\"aufigsten genutzter Vertreter ist die \code{if} -
|
||||
Anweisung. Sie Wird genutzt um Programmcode nur unter bestimmten
|
||||
Anweisung. Sie wird genutzt um Programmcode nur unter bestimmten
|
||||
Bedingungen auszuf\"uhren.
|
||||
|
||||
Der Kopf der if - Anweisung beginnt mit dem Schl\"usselwort \code{if}
|
||||
welches von einem \underline{Booleschen Ausdruck} gefolgt wird. Wenn
|
||||
Der Kopf der \code{if} - Anweisung beginnt mit dem Schl\"usselwort \code{if}
|
||||
welches von einem 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 \code{elseif} folgen. Ebenfalls
|
||||
optional ist die Verwendung eines finalen \code{else} Falls. Dieser
|
||||
optional ist die Verwendung eines finalen \code{else} - Falls. Dieser
|
||||
wird immer dann ausgef\"uhrt wenn alle vorherigen Bedingungen nicht
|
||||
erf\"ullt werden. Die \code{if} Anweisung wird mit \code{end}
|
||||
erf\"ullt wurden. Die \code{if} - Anweisung wird mit \code{end}
|
||||
beendet. Listing \ref{ifelselisting} zeigt den Aufbau einer
|
||||
if-Anweisung.
|
||||
\code{if} - Anweisung.
|
||||
|
||||
|
||||
\begin{lstlisting}[label=ifelselisting, caption={Grundger\"ust einer \code{if} Anweisung.}]
|
||||
@ -980,32 +983,32 @@ if-Anweisung.
|
||||
elseif x > y
|
||||
% etwas anderes soll getan werden
|
||||
else
|
||||
% wenn x == y wieder etwas anderes
|
||||
% wenn x == y, wieder etwas anderes
|
||||
end
|
||||
\end{lstlisting}
|
||||
|
||||
\begin{exercise}{ifelse.m}{}
|
||||
Ziehe eine Zufallszahl und \"uberpr\"ufe mit einer geegnet \code{if} Anweisung, ob sie:
|
||||
Ziehe eine Zufallszahl und \"uberpr\"ufe mit einer geeigneten \code{if} Anweisung, ob sie:
|
||||
\begin{enumerate}
|
||||
\item ... kleiner als 0.5 ist.
|
||||
\item ... kleiner oder gr\"o{\ss}er-gleich 0.5 ist.
|
||||
\item ... kleiner als 0.5, gr\"o{\ss}er oder gleich 0.5 aber kleiner
|
||||
als 0.75 ist oder gr\"o{\ss}er oder gleich 0.75 ist.
|
||||
\item ... 1. kleiner als 0.5, 2. gr\"o{\ss}er oder gleich 0.5 aber kleiner
|
||||
als 0.75 oder 3. gr\"o{\ss}er oder gleich 0.75 ist.
|
||||
\end{enumerate}
|
||||
\end{exercise}
|
||||
|
||||
\subsubsection{Die \code{switch} -- Verzweigung}
|
||||
|
||||
Die \code{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.
|
||||
|
||||
Wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von der
|
||||
\codeterm{switch Anweisung} (Zahl oder String). Jeder Fall auf den die
|
||||
Anweisung \"uberpr\"ft werden soll wird mit dem Schl\"usselwort
|
||||
\code{case} eingeleitet. Diese wird gefolgt von der \codeterm{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
|
||||
Sie wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von der
|
||||
\codeterm{switch Anweisung} (Zahl oder String). Jeder Fall, auf den diese
|
||||
Anweisung \"uberpr\"uft werden soll, wird mit dem Schl\"usselwort
|
||||
\code{case} eingeleitet. Dieses wird gefolgt von der \codeterm{case
|
||||
Anweisung}, die definiert gegen welchen Fall auf
|
||||
Gleichheit getestet wird. F\"ur jeden Fall wird der
|
||||
Programmcode angegeben, der ausgef\"uhrt werden soll. Optional k\"onnen
|
||||
mit dem Schl\"usselwort \code{otherwise} alle nicht explizit genannten
|
||||
F\"alle behandelt werden. Die \code{switch} Anweisung wird mit
|
||||
\code{end} beendet (z.B. in Listing \ref{switchlisting}).
|
||||
@ -1023,14 +1026,14 @@ switch mynumber
|
||||
end
|
||||
\end{lstlisting}
|
||||
|
||||
Wichtig ist hier, dass in jedem \code{case} auf \underline{Gleichheit} der
|
||||
Wichtig ist hier, dass in jedem \code{case} auf Gleichheit der
|
||||
switch-Anweisung und der case-Anweisung getestet wird.
|
||||
|
||||
|
||||
\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.
|
||||
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
|
||||
@ -1047,7 +1050,7 @@ 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 Code-Abschnitten in Schleifen zu \"uberspringen oder abzubrechen.}, label=breakcontinuelisting]
|
||||
\begin{lstlisting}[caption={Einsatz der \code{continue} und \code{break} Schl\"usselworte um die Ausf\"uhrung von Code-Abschnitten in Schleifen zu \"uberspringen oder abzubrechen.}, label=breakcontinuelisting]
|
||||
for x = 1:10
|
||||
if(x > 2 & x < 5)
|
||||
continue;
|
||||
@ -1101,7 +1104,7 @@ end
|
||||
|
||||
Ein Programm ist eine Sammlung von Anweisungen, die in einer Datei auf
|
||||
dem Rechner abgelegt sind. Wenn es durch den Aufruf zum Leben erweckt
|
||||
wird, dann wird es Zeile f\"Ur Zeile von oben nach unten ausgef\"uhrt.
|
||||
wird, dann wird es Zeile f\"ur Zeile von oben nach unten ausgef\"uhrt.
|
||||
|
||||
\matlab{} kennt drei Arten von Programmen:
|
||||
\begin{enumerate}
|
||||
@ -1110,11 +1113,11 @@ wird, dann wird es Zeile f\"Ur Zeile von oben nach unten ausgef\"uhrt.
|
||||
\item Objekte (werden wir ignorieren)
|
||||
\end{enumerate}
|
||||
Alle Programme werden in den sogenannten \codeterm{m-files} gespeichert
|
||||
(z.B. \filename{meinProgramm.m}). Um sie zu benutzen werden sie von der
|
||||
(z.B. \emph{meinProgramm.m}). Um sie zu benutzen werden sie von der
|
||||
Kommandozeile aufgerufen oder in anderen Programmen
|
||||
verwendet. Programme erh\"ohen die Wiederverwertbarkeit von
|
||||
Programmcode. Bislang haben wir ausschlie{\ss}lich Skripte
|
||||
verwendet. Dabei wurde jede Variable, die erzuegt wurde im
|
||||
verwendet. Dabei wurde jede Variable, die erzeugt wurde im
|
||||
\codeterm{Workspace} abgelegt und konnte wiederverwendet werden. Hierin
|
||||
liegt allerdings auch eine Gefahr. In der Regel sind Datenanalysen auf
|
||||
mehrere Skripte verteilt und alle teilen sich den gemeinsamen
|
||||
@ -1166,7 +1169,7 @@ Das Folgende Beispiel (Listing \ref{badsinewavelisting}) zeigt eine
|
||||
Funktion, die eine Reihe von Sinusschwingungen unterschiedlicher
|
||||
Frequenzen berechnet und graphisch darstellt.
|
||||
|
||||
\begin{lstlisting}[caption={Eine Beispielfunktion, die eine Reihe Sinus plottet.},label=badsinewavelisting]
|
||||
\begin{lstlisting}[caption={Eine Beispielfunktion, die eine Reihe Sinusse plottet.},label=badsinewavelisting]
|
||||
function meine_erste_funktion() % Funktionskopf
|
||||
t = (0:0.01:2); % hier faengt der Funktionskoerper an
|
||||
frequenz = 1.0;
|
||||
@ -1185,12 +1188,11 @@ Funktion. Sie hat folgende Probleme:
|
||||
\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 \emph{und}
|
||||
\item Sie tut drei Dinge auf 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.
|
||||
\item Keinerlei Dokumentation. Man muss den Code lesen und rekonstruieren, was sie tut.
|
||||
\end{itemize}
|
||||
|
||||
Bevor wir anfangen die Funktion zu verbessern mu{\ss} definiert werden
|
||||
@ -1217,9 +1219,9 @@ hei{\ss}en soll, (ii) welche Information sie ben\"otigt und (iii)
|
||||
welche Daten sie zur\"uckliefern soll.
|
||||
|
||||
\begin{enumerate}
|
||||
\item \codeterm{Name:} der Name sollte schon beschreiben, was die Funktion
|
||||
\item \codeterm{Name:} der Name sollte beschreiben, was die Funktion
|
||||
tut. In diesem Fall berechnet sie einen Sinus. Ein geeigneter Name
|
||||
w\"are also \code{calculate\_sinwave}.
|
||||
w\"are also \code{calculate\_sinewave}.
|
||||
\item \codeterm{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
|
||||
@ -1249,7 +1251,7 @@ function [time, sine] = calculate_sinewave(frequency, amplitude, t_max, t_step)
|
||||
|
||||
|
||||
\paragraph{II. Plotten einer einzelnen Schwingung}
|
||||
Diese Aufage kann auch von einer Funktion \"ubernommen werden. Diese
|
||||
Diese Aufgabe 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. \code{plot\_sinewave}). Um einen einzelnen Sinus zu plotten
|
||||
@ -1270,15 +1272,15 @@ function plot_sinewave(x_data, y_data, name)
|
||||
|
||||
|
||||
\paragraph{III. Erstellen eines Skriptes zur Koordinierung}
|
||||
Die letzt Aufgabe ist die Koordinierung der Berechung und des Plottens
|
||||
f\"ur mehrere Amplituden. Das ist die klassische Aufgabe f\"ur ein
|
||||
Skript. Auch hier gilt es einen ausdrucksvollen Name zu finden. Da es
|
||||
keine Argumente und R\"uckgabewerte gibt bleibt und nur, die
|
||||
ben\"otigten Information direkt in dem Skript zu defninieren. Dies
|
||||
sind: ein Vektor, f\"ur die Amplituden, je eine Variable f\"ur die
|
||||
gew\"unschte Frequenz, die maximale Zeit auf der x-Achse und die
|
||||
zeitliche Aufl\"osung. Das Skript \"offnet schlie{\ss}lich noch eine
|
||||
neue Abbildung und setzt das \code{hold on} da nur das Skript
|
||||
Die letzte Aufgabe ist die Koordinierung der Berechung und des
|
||||
Plottens f\"ur mehrere Amplituden. Das ist die klassische Aufgabe
|
||||
f\"ur ein Skript. Auch hier gilt es einen ausdrucksvollen Name zu
|
||||
finden. Da es keine Argumente und R\"uckgabewerte gibt, m\"ussen die
|
||||
ben\"otigten Informationen direkt in dem Skript defniniert werden. Es
|
||||
werden ben\"otigt: ein Vektor f\"ur die Amplituden, je eine Variable
|
||||
f\"ur die gew\"unschte Frequenz, die maximale Zeit auf der x-Achse und
|
||||
die zeitliche Aufl\"osung. Das Skript \"offnet schlie{\ss}lich noch
|
||||
eine neue Abbildung und setzt das \code{hold on} da nur das Skript
|
||||
wei{\ss}, das mehr als ein Plot erzeugt werden soll. Das Skript ist in
|
||||
Listing \ref{sinesskriptlisting} dargestellt.
|
||||
|
||||
@ -1307,7 +1309,7 @@ legend('show')
|
||||
|
||||
\subsection{Fazit}
|
||||
|
||||
Funktionen sind kleine Code Fragmente, die
|
||||
Funktionen sind kleine Codefragmente, die
|
||||
\begin{enumerate}
|
||||
\item ... genau eine Aufgabe erledigen.
|
||||
\item ... Argumente entgegennehmen k\"onnen.
|
||||
@ -1318,7 +1320,7 @@ Funktionen sind kleine Code Fragmente, die
|
||||
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
|
||||
Funktionen ein Problem zu l\"osen. W\"ahrend die Funktionen relativ
|
||||
kleine ``verdauliche'' Teilprobleme l\"osen. Sind die Skripte daf\"ur
|
||||
gemacht den Rahmen zu bilden und den Ablauf zu koordinieren (Abbildung
|
||||
\ref{programlayoutfig}).
|
||||
|
||||
Reference in New Issue
Block a user