language and code fixes

programming/code/plotMultipleSinewaves.m

@@ -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',...

programming/lecture/programming.tex

@@ -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
+\ref{logicalindexingsec}). Die Tabellen \ref{logicalandor} zeigen die
-Wahrheitstabellen f\"ur das logische UND (\ref{logicalandor}, links)
+Wahrheitstabellen f\"ur das logische UND (Tabelle \ref{logicalandor}, links)
-aund das logische ODER (\ref{logicalandor}, rechts). Es werden die
+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
+Anders ist das beim logischen ODER. Hier ist der gesamte Ausdruck
-Ausdruck wahr, wenn sich der eine \emph{oder} der andere Ausdruck zu
+wahr, wenn sich der eine \emph{oder} der andere Ausdruck zu wahr
-wahr auswerten l\"a{\ss}t. Tabelle \ref{logicaloperators} zeigt die
+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,
+einem UND verkn\"upft werden und der erste zu falsch ausgewertet wird,
-dann muss der zweite gar nicht mehr gepr\"uft werden. Die Verwendung
+muss der zweite gar nicht mehr gepr\"uft werden. Die Verwendung der
-der ``short-circuit'' Versionen spart Rechenzeit. Das auschliessende
+``short-circuit'' Versionen spart Rechenzeit. Das auschlie{\ss}ende ODER
-ODER (XOR) ist in \matlab{} nur als Funktion \code{xor(A, B)}
+(XOR) ist in \matlab{} nur als Funktion \code{xor(A, B)} verf\"ugbar.
-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 logisches UND\\
-      $\|$ & short-circuit logical ODER\\
+      $\|$ & 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
+\code{logical} Werte 1 und 0. 
-Zuweisungsoperator \code{=} und der logische Operator \code{==} zwei
+
-grundverschiedene Dinge sind. Da sie umgangsprachlich gleich sind kann
+\begin{important}
-man sie leider leicht verwechseln.
+  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,7 +802,7 @@ 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.
   
@@ -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
+werden, dass bestimmte Teile wiederholt oder nur
-unter bestimmten Bedingungen ausgef\"uhrt werden. Von gro{\ss}er
+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
+  Implementiere eine \code{for} Schleife, die die Fakul\"at von einer
-  \code{n} berechnet.
+  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
+\code{while} gefolgt von einem Booleschen Ausdruck. Solange dieser zu
-  Ausdruck}. Solange dieser zu \code{true} ausgewertet werden kann,
+\code{true} ausgewertet werden kann, wird der Code im
-wird der Code im Schleifenk\"orper ausgef\"uhrt.  Die Schleife wird
+Schleifenk\"orper ausgef\"uhrt.  Die Schleife wird mit dem
-mit dem Schl\"usselwort \code{end} beendet.
+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}
+Der Kopf der \code{if} - Anweisung beginnt mit dem Schl\"usselwort \code{if}
-welches von einem \underline{Booleschen Ausdruck} gefolgt wird. Wenn
+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
+  \item ... 1. kleiner als 0.5, 2. gr\"o{\ss}er oder gleich 0.5 aber kleiner
-    als 0.75 ist oder gr\"o{\ss}er oder gleich 0.75 ist.
+    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
+Sie wird mit dem Schl\"usselwort \code{switch} begonnen, gefolgt von der
-\codeterm{switch Anweisung} (Zahl oder String). Jeder Fall auf den die
+\codeterm{switch Anweisung} (Zahl oder String). Jeder Fall, auf den diese
-Anweisung \"uberpr\"ft werden soll wird mit dem Schl\"usselwort
+Anweisung \"uberpr\"uft werden soll, wird mit dem Schl\"usselwort
-\code{case} eingeleitet. Diese wird gefolgt von der \codeterm{case
+\code{case} eingeleitet. Dieses wird gefolgt von der \codeterm{case
-  Anweisung} welche definiert gegen welchen Fall auf
+  Anweisung}, die definiert gegen welchen Fall auf
-\underline{Gleichheit} getestet wird. F\"ur jeden Fall wird der
+Gleichheit getestet wird. F\"ur jeden Fall wird der
-Programmcode angegeben, der ausgef\"uhrt werden soll Optional k\"onnen
+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
+\item Keinerlei Dokumentation. Man muss den Code lesen und rekonstruieren, was sie tut.
-  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
+Die letzte Aufgabe ist die Koordinierung der Berechung und des
-f\"ur mehrere Amplituden. Das ist die klassische Aufgabe f\"ur ein
+Plottens f\"ur mehrere Amplituden. Das ist die klassische Aufgabe
-Skript. Auch hier gilt es einen ausdrucksvollen Name zu finden. Da es
+f\"ur ein Skript. Auch hier gilt es einen ausdrucksvollen Name zu
-keine Argumente und R\"uckgabewerte gibt bleibt und nur, die
+finden. Da es keine Argumente und R\"uckgabewerte gibt, m\"ussen die
-ben\"otigten Information direkt in dem Skript zu defninieren. Dies
+ben\"otigten Informationen direkt in dem Skript defniniert werden. Es
-sind: ein Vektor, f\"ur die Amplituden, je eine Variable f\"ur die
+werden ben\"otigt: ein Vektor f\"ur die Amplituden, je eine Variable
-gew\"unschte Frequenz, die maximale Zeit auf der x-Achse und die
+f\"ur die gew\"unschte Frequenz, die maximale Zeit auf der x-Achse und
-zeitliche Aufl\"osung. Das Skript \"offnet schlie{\ss}lich noch eine
+die zeitliche Aufl\"osung. Das Skript \"offnet schlie{\ss}lich noch
-neue Abbildung und setzt das \code{hold on} da nur das Skript
+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}).