3 Skripte und Plots. 3.1 Skripte in MATLAB. 3.2 Zweidimensionale Plots

Transkript

1 3 Skripte und Plots 3.1 Skripte in MATLAB Skripte sind in MATLAB eine Ansammlung von Befehlen, die man auch so in der Kommandozeile eingeben könnte, in einer Datei. Diese können durch Aufruf eines Befehls so ausgeführt werden. Erstellt man etwa eine Datei test.m im aktuellen Verzeichnis mit folgem Inhalt: % Zeichnet einen Graphen I = 0 : 0.1 : 10; f = cos(i).* I; g = sin(i).* I; plot(f, g) und gibt dann in der Kommandozeile test ein, so wird ein Plot mit einer Spirale erzeugt. (Warum diese Befehle genau diesen Plot erzeugen, schauen wir uns gleich genauer an.) Um die Datei zu erzeugen, klickt man in der Toolbar den Neues-Skript-Button an, der sich ganz links befindet. Dann öffnet sich das Editorfenster, in dem man die obigen Befehle eingeben kann. Dies kann man speichern, etwa unter dem Namen test.m, in dem man in der Toolbar des Editor-Fenster auf das Disketten-Symbol klickt, oder im Menü File den Befehl Save auswählt. Das Editorfenster mit dem von diesen Zeilen erzeugtem Graph sieht so aus: Der Screenshot zeigt auch, wie man Kommentare schreibt: alles nach einem Prozentzeichen % wird ignoriert. Falls in der ersten Zeile in einem Skript ein Kommentar anfängt, wird dieser in der Schnellansicht unten links im MATLAB-Fenster angezeigt, wenn die.m-datei vom Skript in der Dateiauswahl ausgewählt ist. Er wird ebenfalls angezeigt, wenn man in der Kommandozeile help Skriptname eingibt. Man kann das Skript auch direkt aus dem Editor ausführen, indem man im Editorfenster in der Toolbar auf das Symbol klickt. Mit dem, was wir bisher gemacht haben, benötigt man Skripte noch nicht so wirklich. Jedoch schon bei komplexeren Plots ist es hilfreich, die Befehle in einem Skript zu sammeln. Im nächsten Kapitel werden wir Kontrollstrukturen kennenlernen; diese machen in Skripten mehr Sinn, als wenn man sie direkt an der Kommandozeile eingibt. Aufgabe 3.1: Erzeuge das Skript test mit dem oben angegebenen Code. Speicher es und führe es aus, einmal aus dem Editor und einmal über die Kommandozeile. 3.2 Zweidimensionale Plots Der grundlege Befehl zum Zeichen von Plots ist der Befehl plot. Hat man etwa einen Vektor mit Funktionswerten, sagen wir v = [ ], so zeichnet plot(v) folges: 19

2 Die durchgezogene Linie befindet sich bei x = 1 bei v(1), bei x = 2 bei v(2), etc. Wenn man die x- Werte anders setzen will, muss man diese ebenfalls als Vektor angeben: ist w = [ ], oder kürzer w = 0 : 0.5 : 2, so ergibt plot(w, v) folges Ergebnis: Damit lassen sich schon viele Dinge machen. Möchte man etwa den Graphen der Sinus-Funktion von 0 bis 2π plotten, wobei man Zwischenschritte von 0.1 machen möchte, so schreibt man etwa: >> v = 0 : 0.1 : 2* pi; >> w = sin(v); >> plot(v, w) Hierbei macht man sich zunutze, dass die Funktion sin angewet auf eine Matrix komponentenweise ausgeführt wird. Das Ergebnis ist dann: Mit dem Plot-Befehl lassen sich auch ganz andere Dinge zeichnen, etwa eine parametrisierte Kurve v(t) = (f(t), g(t)), t I. Ist zum Beispiel f(t) = sin t, g(t) = cos t und I = [0, 2π], so kann man sich die Kurve mit 20

3 >> I = 0 : 0.1 : 2* pi; >> f = sin(i); g = cos(i); >> plot(f, g) anzeigen lassen. Das Ergebnis ist unten links dargestellt. Wenn man die Schrittweite gröber wählt, erkennt man, dass es sich um einen Streckenzug handelt. So liefert I = 0 : 0.5 : 2*pi mit ansonsten den gleichen Befehlen die rechte hier dargestellte Grafik: Wenn man genau hinschaut, so sieht man, dass der letzte Streckenzug fehlt. Das Problem ist hier, dass der letzte gezeichnete Punkt bei t = 6 liegt und nicht bei t = 2π Dies kann man verhindern, indem man die Schrittweite als Differenz von End- und Startpunkt geteilt durch eine ganze Zahl wählt, etwa wenn man I per I = 0 : 2*pi/100 : 2*pi erzeugt. Noch einfacherer ist es jedoch, anstelle des Doppelpunkt-Operators die MATLAB-Funktion linspace zu verwen. Schreibt man etwa linspace(0, 2*pi, 100), so erzeugt dies einen Zeilenvektor mit 100 Einträgen, der erste davon 0 und der letzte 2π, und die restlichen gleichmässig dazwischen verteilt. Aufgabe 3.2: Plotte die folgen Funktionen und parametrisierten Kurven: 1. f(x) = x 2 1; 2. f(x) = tan sin x; 3. γ(t) = (sin t cos t, cos t sin t) für t [0, 2π]; 4. γ(t) = (t 2, t 3 ) für t R. Eine weitere Möglichkeit, zweidimensionale Plots zu zeichnen, besteht in der Verwung eindimensionaler Vektoren mit komplexen Zahlen. Ruft man plot(v) auf und enthält v mindestens eine echt komplexe Zahl, so bewirkt plot(v) das gleiche wie plot(real(v), imag(v)). Damit lässt sich zum Beispiel die Spirale f : [0, ) C, t exp((i 1)t) per zeichnen: plot(exp((i-1)*(0 : : 100))) 21

4 Sobald ein Plot erzeugt wurde, lassen sich Titel und Beschriftung der Achsen festlegen: >> xlabel ( reelle Achse ) >> ylabel ( imaginaere Achse ) >> title ( Eine tolle Spirale, FontSize, 12) Dies ergibt dann: Aufgabe 3.3: Gebe help plot ein, um den Hilfetext des plot-befehls zu erhalten. Erzeuge damit die folgen Plots: 1. die Funktion f : [ 1, 1] R, x x mit roter gestrichelter Linie; 2. die Funktion f s : [ 1, 1] R, x (x/s) 2 für die Werte s { 1, 0.5, 0.5, 1} in verschiedenen Farben im gleichen Plot; 3. die Funktion f : [0, 1] R, x sin(2πx), wobei keine Linie dargestellt werden soll, sondern die Funktionswerte als kleine Kreise an den Stellen x = n 10, n = 0, 1,..., das gleiche wie bei 2., mit dem Unterschied dass eine Lege vorhanden ist, die den verschiedenen Farben die Werte von s zuordnen. Benutze dafür den Befehl leg (informiere dich erst in der Hilfe, wie dieser funktioniert). Ein praktischer Befehl ist noch der hold-befehl: er erlaubt das Erweitern eines bereits erzeugten Plots um weitere Plots. Dies kann etwa so genutzt werden: >> plot( sin (0 : 0.1 : 10)) >> hold on >> plot( cos (0 : 0.1 : 10)) >> plot( sin (0 : 0.1 : 10) + cos (0 : 0.1 : 10)) >> hold off Dies zeichnet die drei Funktionen sin(x), cos(x) und sin(x) + cos(x) in einen Graphen ein. Ein weiterer Befehl ist der axis-befehl. Er erlaubt, die Grenzen der Achsen selbst festzulegen. Details hierzu finden sich in der Online-Hilfe. Aufgabe 3.4: Stelle die ersten fünf Newton-Iteration der Funktion f(x) = x 5 4x 2 + 3x 2 mit dem Startwert x 0 = 3 graphisch da, indem du zu jedem Paar (x n, f(x n )), n = 0,..., 5 einen Punkt in den Plot der Funktion einzeichnest zusammen mit einer Tangente an f in diesem Punkt. Verwe Achsenbeschriftungen, den hold-befehl und eine Lege, um die Ausgabe ansprech und verständlich zu gestalten. 3.3 Dreidimensionale Plots Es gibt mehrere Wege, zweidimensionale Funktionen R 2 R (bzw. dreidimensionale Daten) darzustellen. Eine Möglichkeit ist, diese als Konturen- oder Farbplot darzustellen. Es gibt zum Beispiel 22

5 in MATLAB die Funktion peaks, welche durch (x, y) 3(1 x) 2 exp( x 2 (y + 1) 2 ) 10( 1 5 x x3 y 5 ) exp( x 2 y 2 ) 1 3 exp( (x + 1)2 y 2 ) definiert ist. Die Befehle contour(peaks) und pcolor(peaks) liefern folge Grafiken: Eine zweite Möglichkeit, zweidimensionale Funktionen darzustellen, sind 3D-Drahtgitterplots und Flächenplots. Die Befehle mesh(peaks) und surf(peaks) liefern folge Grafiken: Man kann auch genauso wie bei zweidimensionalen Plots rohe Daten dreidimensional darstellen. Hat man etwa eine Matrix wie A = randn(20, 20) * 0.5, so erzeugen mesh(a) und surf(a) folge Grafiken: Um Graphen von Funktionen erstellen zu können, ist der meshgrid-befehl praktisch. Hat man einen Vektor x der x-koordinaten (der Länge n) und einen Vektor y der y-koordinaten (der Länge 23

6 m), so erzeugt [X,Y] = meshgrid(x, y) zwei Matrizen X und Y vom Format n m, so dass jede Zeile von X den Zeilenvektor x, und jede Spalte von Y den Spaltenvektor y enthält. Zum Beispiel liefert [X,Y] = meshgrid(0 : 1 : 2, 5 : 1 : 6) die Matrizen X = ( 0 1 ) und Y = ( 5 5 ) zurück. Gibt man nur einen Vektor an, etwa bei meshgrid(v), so bewirkt dies das gleiche wie meshgrid(v, v). Wenn man nun die Funktion (x, y) sin x + cos xy plotten möchte im Bereich [ 2, 2] [ 2, 2], kann man zuerst X und Y durch [X,Y] = meshgrid(-2 : 0.1 : 2) erzeugen, dann die Funktionswerte-Matrix Z durch Z = sin(x) + cos(x.* Y), und schliesslich das ganze mittels dem Befehl mesh(x, Y, Z) plotten. Das ergibt dann Aufgabe 3.5: dar: Stelle folge Funktionen f : R 2 R auf verschiedene Art und Weisen graphisch 1. f(x, y) = x 2 y 2 2. f(x, y) = sin x 2 +y 2 ; x 2 +y 2 3. f(x, y) = 1 x 2 +y 2 ; die letzten beiden Funktionen haben in (x, y) = (0, 0) einen Pol. Wie kann man Probleme beim Erzeugen des Wertefeldes und dem Plotten umgehen? Bisherige Lernziele Wissen wie man Skripte in MATLAB schreibt, ausführt und mit Kommentaren versieht Verstehen, wie Plots von eindimensionalen Funktionen und parametrisierten Kurven im R 2 geplottet werden können Verstehen, wie dreidimensionale Plots funktionieren und wie Wertetabellen dafür mit meshgrid erstellt werden können 24

7 4 Kontrollkonstrukte und Schleifen Bisher haben wir einfache Befehle kennengelernt: Ausdrücke, Zuweisungen, und Skripte, die Plots erzeugen. Damit war es bisher nicht möglich, sonderlich viel zu machen. In einigen Aufgaben haben wir gesehen, dass Schleifen oder Abfragen zwar teilweise durch Matrixoperationen oder geschickte Ausdrücke ersetzt werden können, jedoch waren wir oft gezwungen, Befehle zu replizieren oder je nach Iteration von Hand auszuwählen, welche Befehle ausgeführt werden oder nicht. Kontrollkonstrukte erlauben, nach bestimmten Bedingungen gewisse Befehle auszuführen oder nicht auszuführen. 4.1 Kontrollkonstrukte Das grundlegenste Kontrollkonstrukt ist die if-anweisung. Das folge Beispiel verdeutlicht, wie sie funktioniert: if < Ausdruck 1> < Befehle 1> elseif < Ausdruck 2 > < Befehle 2> else < Befehle 3> Zuerst wird hier der Ausdruck <Ausdruck 1> ausgewertet. Ergibt er 1 (logical, also irgetwas 0), werden <Befehle 1> ausgeführt. Falls er 0 (logical) ergibt, wird <Ausdruck 2> ausgewertet. Ergibt dieser 1 (logical, also 0), so werden <Befehle 2> ausgewertet. Andernfalls werden <Befehle 3> ausgeführt. Die if-anweisung ist modular: es können beliebig viele elseif-zweige elseif < Ausdruck > eingefügt werden, es kann auch kein einziger solcher Zweig verwet werden. Der else-zweig else kann ebenfalls weggelassen werden. Falls er vorkommt, muss er immer zum Schluss kommen (als letzter Block vor dem ) und er darf nicht mehrmals vorkommen. Falsch: if < Ausdruck > else else Falsch: if < Ausdruck > else elseif < Ausdruck > Richtig: if < Ausdruck > if < Ausdruck > else Aufgabe 4.1: Schreibe ein Skript, welches davon ausgeht, dass eine Variable x eine double-zahl ist. Das Skript soll folges ausgeben: 1. ob die Zahl negativ, gleich 0 oder positiv ist; 2. ob die Zahl im Intervall [0, 1] liegt oder nicht; 3. ob die Zahl gleich -10 ist oder nicht. Spezialfälle wie ±Inf und NaN können ignoriert werden. 25

8 Aufgabe 4.2: Schreibe eine if-abfrage für das Bisektionsverfahren aus Aufgabe 2.7. Diese soll davon ausgehen, dass x1 und x2 gegeben sind mit x1 < x2 und cos(x1) * cos(x2) < 0 (es ist also wieder f(x) = cos x). Diese soll x3 wie in Aufgabe 2.7 wählen und entweder x1 oder x2 durch den Wert von x3 ersetzen. Schreibe diese if-abfrage in ein Skript namens bisect, setze x1 = 1 und x2 = 2, und führe das Skript zehnmal aus. Dann gilt abs(x2 - x1) = 2^(-10), d.h. die Nullstelle von cos x in [1, 2] (es gibt genau eine) ist dadurch bis auf eine Genauigkeit von 2 10 < 10 3 bestimmt. Eine weitere Kontrollkonstruktion ist die switch-anweisung. Diese funktioniert so: switch < Ausdruck > case <Wert 1> < Befehle 1> case <Wert 2> < Befehle 2> case <Wert 3> < Befehle 3> otherwise < Befehle 4> Dies bewirkt, dass der Ausdruck <Ausdruck> ausgewertet wird. Ist der Ausdruck gleich <Wert 1>, so werden <Befehle 1> ausgeführt. Ist der Ausdruck gleich <Wert 2>, so werden <Befehle 2> ausgeführt. Ist der Ausdruck gleich <Wert 3>, so werden <Befehle 3> ausgeführt. Ansonsten, falls der Ausdruck keinem der drei Werte entspricht, werden <Befehle 4> ausgeführt. Es können beliebig viele case-zweige benutzt werden, und der otherwise-zweig kann weggelassen werden. (In dem Fall passiert nichts, wenn der Ausdruck ungleich allen spezifizierten Werten ist.) Es ist auch möglich, einfach nur switch < Ausdruck > zu schreiben. In diesem Fall wird der Ausdruck ausgewertet (und etwa Funktionen, die im Ausdruck vorkommen, aufgerufen) und dann nichts gemacht. Dies ändert den Wert der Variablen ans nicht. Die switch-anweisung macht dann Sinn, wenn ein Ausdruck einmal ausgewertet und mit einer festen Anzahl von Werten verglichen werden soll. Sollen dagegen Ungleichungen geprüft werden, muss man auf if-anweisungen zurückgreifen. Aufgabe 4.3: Die Funktion rem(n, m) liefert den (nichtnegativen) Rest von n bei Division durch m. Der Rest hat das selbe Vorzeichen wie n, und hierbei müssen weder n noch m ganze Zahlen sein. Weiterhin kann mit dem disp-befehl der Wert einer Variablen oder Zeichenkette ausgegeben werden. Schreibe damit ein Skript, welches testet, ob die Variable x eine ganze Zahl ist, und wenn ja, den Rest bei Division modulo 3 ausgibt. Dies soll über eine switch-anweisung erfolgen. Bei einer Eingabe von 5 soll etwa 2 ausgegeben werden (da 5 = x für ein passes x Z), und bei einer Eingabe von soll Keine ganze Zahl ausgegeben werden. 4.2 Schleifen Schleifen erlauben die wiederholte Ausführung von Befehlen. In MATLAB gibt es zwei Arten von Schleifen: for-schleifen und while-schleifen. Währ for-schleifen eine vorher festgelegte Anzahl durchlaufen werden, sind while-schleifen in dieser Hinsicht dynamisch, da sie solange ausgeführt werden, bis eine beliebige, vorher festgelegte Bedingung nicht mehr gilt. Eine for-schleife funktioniert wie folgt: for < Variable > = < Vektor > Die Variable <Variable> nimmt alle Werte der Reihe nach an, die im Vektor <Vektor> stehen, und führt für jeden Wert <Befehle> aus. Etwa ergibt 26

9 for n = [1 4 1] n die Ausgabe n = 1 n = 4 n = 1 Es bietet sich an, für die Erzeugung des Vektors den :-Operator zu nutzen. Um etwa mit n die Zahlen 2, 3, 4, 5, 6 zu durchlaufen, schreibt man for n = 2 : 6 Um die Zahlen 2, 2.5, 3, 3.5,..., 6 zu durchlaufen, schreibt man stattdessen for n = 2 : 0.5 : 6 In den meisten MATLAB-Programmen wird der :-Operator bei for-schleifen benutzt; dies ist jedoch, wie oben demonstriert, nicht notwig. Aufgabe 4.4: Erweitere das Skript bisekt von oben (Aufgabe 4.2), um die Nullstelle von cos x in [1, 2] mit einer Genauigkeit von 2 50 zu bestimmen. Der bisherige Inhalt vom Skript bisekt soll dabei erhalten bleiben, es muss davor und danach etwas eingefügt werden. In jedem Iterationsschritt sollen x1, x2 und x2 - x1 ausgegeben werden. Hinweis: verwe zur Ausgabe den fprintf-befehl: fprintf ( %0.20d, %0.20d, %0.20 d\n, x1, x2, x2 - x1) Aufgabe 4.5: In dieser Aufgabe soll π mit Hilfe einer Monte-Carlo-Methode approximiert werden. Dazu wählt man erst eine Anzahl Iterationen, sagen wir n, und setzt einen Zähler T auf 0. Dann wird n-mal zufällig (gleichverteilt) ein Punkt (x, y) [ 1, 1] 2 gewählt und die euklidische Norm von (x, y) bestimmt (also x 2 + y 2 ). Ist diese 1, so wird der Zähler T erhöht. Wenn n gross genug ist, nimmt der Kreis mit Radius 1 im Quadrat [ 1, 1] [ 1, 1] in etwa T n der Fläche ein, womit π 4 T n ist. Schreibe ein Skript montecarlopi, welches voraussetzt, dass n vorher gesetzt wurde, und π mit n Monte-Carlo-Iterationsschritten approximiert. Führe das Skript mehrmals für n = 1000, n = und n = aus. Was kannst du über die Genauigkeit sagen? Allgemein kann in MATLAB mit format long die Ausgabe von Zahlen in der Kommandozeile auf ein längeres Format mit mehr Dezimalziffern eingestellt werden. In der Aufgabe wird die Genauigkeit der Ausgabe im fprintf-befehl auf 20 Nachkommastellen für jede Zahl eingestellt. Die zweite Möglichkeit, Schleifen in MATLAB zu schreiben, funktioniert mit der while-anweisung. Diese funktioniert so: while < Ausdruck > Solange der Ausdruck <Ausdruck> wahr ist (also 0), werden <Befehle> ausgeführt. Folge zwei Programme geben jeweils die Zahlen von 1 bis 10 aus: 27

10 for k = 1 : 10 disp(k) k = 1 while k <= 10 disp(k) k = k + 1 Wie man sieht, ist eine for-schleife hierfür besser geeignet. Es gibt jedoch auch Fälle, in denen die Anzahl der Iterationen vor der Schleife noch nicht feststehen. Ein Beispiel dafür ist diese Aufgabe: Aufgabe 4.6: Schreibe ein Skript, welches mit dem Newton-Verfahren (vergleiche Aufgabe 2.6) eine Nullstelle von f(x) = x 10 5x 6 + 2x 3 x 15 approximiert. Die Iteration soll solange durchgeführt werden, bis f(x n ) gilt. Der Startwert sei x 0 = 0. Aufgabe 4.7: Schreibe ein Programm, welches einen Parameter fehler (positiver Wert) annimmt und untersucht, wie gross man n mindestens wählen muss, damit n 1 k 2 π2 6 fehler k=1 ist. Damit keine Probleme mit der Maschinengenauigkeit auftreten, gehe wie folgt vor: setze eine Variable A auf π2 6. Dann ziehe 1 1 ab und schaue ob A <= fehler ist. Wenn nicht, ziehe ab und 2 schaue wieder, ob A <= fehler ist. Wenn nicht, ziehe 1 3 ab, usw. 2 Untersuche, wie gross du n mindestens wählen muss, damit der Fehler kleiner 10 1, 10 2 und 10 3 ist. Im Zusammenhang mit Schleifen gibt es noch zwei Kontrollanweisungen: continue und break. Wird continue in einer Schleife aufgerufen, so wird sofort die nächste Iteration der Schleife eingeleitet (soweit möglich) und die aktuelle Iteration abgebrochen. Wird break aufgerufen, so wird die vollständige Schleife abgebrochen. Der break-befehl ist etwa beim Bisektionsverfahren praktisch: falls f(x3) == 0 ist, soll die Ausführung der Schleife sofort abgebrochen werden und x3 als Nullstelle ausgegeben werden. Der continue-befehl kann etwa benutzt werden, um zufällig Punkte zu erzeugen, die in dem Einheitskreis in der Ebene liegen. Das folge Skript erzeugt 10 solche Punkte: n = 10; while n > 0 x = rand; y = rand; if x^2 + y^2 > 1 continue fprintf ( (%0.20 d, %0.20 d)\n, x, y) n = n - 1; Alternativ hätte man auch ohne die continue-anweisung schreiben können: n = 10; while n > 0 x = rand; y = rand; if x^2 + y^2 <= 1 fprintf ( (%0.20 d, %0.20 d)\n, x, y) n = n - 1; In diesem Fall sind beide Varianten gleich lang, je nach Schleife kann jedoch die Variante mit oder ohne continue besser lesbar und/oder kürzer sein. 28

11 4.3 Benutzen des Debuggers Beim Programmieren treten leicht Fehler auf. Sobald man einen Fehler bemerkt hat, ist es oft nicht einfach, dessen Ursache zu identifizieren oder sie sogar zu beheben. Ein wichtiges Hilfsmittel bei der Fehleridentifikation ist der Debugger. Er erlaubt, die Ausführung eines Programms mitzuverfolgen, bei Bedarf zu unterbrechen, Variablen zu inspizieren und sogar zu verändern. Wir wollen dies an mehreren Beispielen betrachten. Zuerst folges, einfaches Skript: n = 10; % Erzeuge n Zufallszahlen in [0, 1] und sortiere diese aufsteig A = rand(n, 1); for k = 1 : n % finde das kleinste Element in den hinteren n- k +1 Elementen kli = k; kl = A(k); for l = k + 1 : n if A(l) < kl kli = l; kl = A(l); % verschiebe das kleinste Element an die k- te Stelle for l = k : kli A(l + 1) = A(l); A(k) = kl; Wenn man es ausführt und A ausgeben lässt, erhält man eine Ausgabe wie (Die Ausgabe erfolgt nur deshalb nicht in einer, sondern in drei Spalten, damit etwas weniger Platz verbraucht wird.) Dies ist tatsächlich aufsteig. Allerdings ist es sehr, sehr unwahrscheinlich, dass von zehn zufällig in [0, 1] erzeugten Zahlen neun gleich sind. Irgetwas stimmt also nicht. Um den Fehler zu finden, wollen wir den Debugger verwen. Zuerst setzen wir einen Breakpoint in Zeile 3, in der die Zufallszahlen erzeugt werden. Dazu klicken wir im Editor am linken Rand in die Spalte rechts neben der Spalte mit den Zeilennummern. Dort befindet sich vorher ein Strich - ; dieser besagt, dass sich in dieser Zeile ein Befehl befindet. An der Stelle des Strichs erscheint nun ein roter Punkt. Wenn man das Skript nun ausführt (auf in der Toolbar klicken), wird die Ausführung an dieser Stelle unterbrochen. Im Editor erscheint neben dem roten Punkt ein grüner Pfeil, der anzeigt, dass als nächstes diese Zeile ausgeführt wird. Das sieht in etwa so aus: 29

12 Im Workspace Browser kann man bisher nur die Variable n sehen, die den Wert 10 hat. Nun kann man diese eine Zeile ausführen, indem man auf den Step-Button in der Toolbar klickt (drei Buttons neben dem Ausführen-Button), oder indem man F10 drückt. Nun erscheint im Workspace Browser auch die Variable A, und wenn man diese im Variable Editor inspiziert, sieht man, dass diese nicht aufsteig sortiert sind. Drückt man drei weitere Male F10, so befindet man sich in Zeile 8, am Anfang der inneren Schleife. Die Variable k hat den Wert 1, kl (bisher kleinster Wert) den Wert A(1) und kli (Index des bisher kleinsten Wertes) ist ebenfalls 1. Man kann nun so lange F10 drücken, bis man das Ende der inneren Schleife erreicht hat, oder alternativ einen weiteren Breakpoint setzen (in Zeile 15) und das Programm mit F5 (oder dem Continue-Button, drei Buttons rechts vom Step-Button in der Toolbar) bis zum Breakpoint laufen lassen. Das kann dann etwa so aussehen: Der Cursor befindet sich gerade hinter dem kli in Zeile 15; deswegen wird jedes Vorkommen der Variable kli im Editor markiert. Weiterhin kann an sich den Wert einer Variable auch anzeigen lassen, wenn man die Maus über die Variable schiebt und dort kurz ruhen lässt. Dann wird Typ, Format und Wert der Variable in einem kleinen Fenster (Tooltip) angezeigt. Hier wurde nun ermittelt, dass der kleinste Wert an der sechsten Stelle steht (da kli == 6 ist). Die nächste Schleife sowie die nachfolge Zuweisung soll diesen Wert nun an die erste Stelle schieben. Wenn man nun mit F10 ein paar Iterationen der Schleife durchlaufen lässt, sieht man im Variable Editor gleich das Problem: der erste Wert im Array überschreibt alle anderen: Dies liegt offenbar daran, dass die Schleife in der falschen Reihenfolge durchlaufen wird! Damit dies richtig funktioniert, muss mit dem grössten Index angefangen werden und mit dem kleinsten aufgehört werden. Statt for l = k : kli sollte man also for l = kli : -1 : k schreiben. Man kann dies nun im Editor ändern und alle Breakpoints löschen, indem man sie entweder nochmal anklickt oder indem man in der Toolbar auf den Clear-Breakpoints-Button klickt (der Button links vom Step-Button). Schliesslich muss man den Debug-Mode been, indem man etwa auf den Exit-Debug-Mode-Button klickt (rechts vom Continue-Button; oder Shift+F5 drücken). Nun kann man die Änderung auch speichern und das Skript nochmal ausführen. Das Ergebnis ist jedoch immer noch nicht befriedig. Man kann zum Beispiel für A folges erhalten: 30

13 Aufgabe 4.8: Finde mit Hilfe des Debuggers heraus, was schiefgeht! Das Programm kann auf der Vorlesungshomepage als Text-Datei fehlersuche-1.txt heruntergeladen werden. Bisherige Lernziele Wissen, wie das if- und das switch-konstrukt funktionieren Verstehen von Schleifenkonstrukten mit for und while Wissen, wie damit Iterationen (wie etwa im Newton- oder Bisektionsverfahren) automatisiert werden können Wissen, was der Debugger ist und wie man ihn verwen kann, um den Ablauf eines Programmes mitzuverfolgen 31