Im seltensten Falle kommt beim ersten Start des frisch geschriebenen Programms das gewünschte Ergebnis. Irgendwo haben sich immer Fehler eingeschlichen und nicht immer sind die ausgegebenen Fehlermeldungen ausreichend erklärend. Naive Herangehensweisen „einfach“ den Code durchzuschauen und auf Fehler abzusuchen sind insbesondere bei längeren Problemen kaum praktikabel und auch nicht immer zielführend, da einige Probleme nicht auf den ersten Blick erkennbar sind.

Matlab bietet einige Möglichkeiten, dieser Sache Herr zu werden. Die sogenannten Breakpoints sind eine einfache und mächtige Option. Mit einem Klick auf die kleinen Striche rechts neben den Code-Zeilennummern lassen sich die kleinen roten Punkte setzen und wieder entfernen. Wird das Programm bei gesetztem Breakpoint gestartet, so startet es im Debug-Modus und läuft genau bis zu dieser Stelle und hält an.

Praktisch ist nun, dass der gesamte Inhalt des Programms „eingefroren“ ist. Insbesondere gilt dies für alle (temporären) Variablen, Arrays und Matrizen. Über das Variablen-Fenster oder durch die Eingabe im Konsolen-Fenster kann auf diesen gearbeitet werden, also auch der aktuelle Inhalt abgefragt werden. Im Konsolen-Fenster ist der Modus durch ein K vor dem >> zu erkennen. Wichtig: alle Berechnungen während des Debuggings werden nur temporär gespeichert und sind danach nicht mehr vorhanden.

Über spezielle Steuerungstasten kann man das Programm weiter kontrolliert ablaufen lassen. In der Debug-Befehlsgruppe, die erscheint, sobald ein Programm im Debug-Modus ist, sind diese gesammelt. Mit der „Continue“-Taste läuft das Programm bis zum nächsten Breakpoint weiter. Möchte man in kleineren Schritten voranschreiten, so helfen die „Step“-Tasten. Die einfache Step-Taste geht genau einen Zeile im Programmcode weiter. Über die Tasten „Step In“ und „Step Out“ wird es ermöglicht, in die in der aktuellen Zeile aufgerufenen Programme rein beziehungsweise raus zu springen und auch innerhalb dieser schrittweise die Berechnungen durchzugehen. Zuletzt ist mit der „Quit Debugging“-Taste die Möglichkeit gegeben, den Debug-Modus abzubrechen und das laufende Programm damit zu unterbrechen.

Mithilfe des schrittweisen Debuggings ist es möglich, sich genau an das Problem heranzutasten. Durch Setzen eines Breakpoints innerhalb einer for-Schleife kann man jeden einzelnen Schleifendurchlauf überprüfen – und im Idealfall erkennen, warum gerade in diesem einen Durchlauf das Programm abbricht. Häufige Fehler wie falsche Indizes oder unabsichtlich entstandene Nullen können damit schnell erkannt werden.

Diese Antwort hat man schon seit langem befürchtet.

Vier gewinnt – deshalb geht es dieses Mal schon in Runde vier unserer Reihe zu dem Programm Matlab. In der letzten Ausgabe haben wir euch einen Einblick gegeben, worauf ihr beim Visualisieren von Daten in einem Plot achten solltet und was für Informationen wie hinzugefügt werden können.
Nicht nur Griechenland ist zum Sparen angehalten, auch bei der Programmierung ist es wichtig, sowohl Speicherplatz als auch Zeit zu sparen, denn beides ist bekanntlich Geld und macht die Effizienz eines Programmes aus. Matlab bietet für sogenannte spärlich besetzte Matrizen, das sind Matrizen mit einem hohen Anteil an Nulleinträgen, einen besonderen Datentyp, der sowohl speichertechnisch als auch zeitlich für eine starke Effizienzsteigerung sorgen kann.
Der Datentyp sparse ist speziell für diese Matrizen angelegt. Die normale Speicherweise von Matlab speichert Nulleinträge einer Matrix A genauso wie andere Werte, sodass die vollen m × n Einträge der Matrix gespeichert werden. Sparse-Matrizen merken sich nur noch die Indizes und Werte der Einträge, die nicht null sind. Somit hängt deren Speicherplatzbedarf nur noch von der Anzahl nnz(A) der Nichtnulleinträge ab. Das Verhältnis von Nichtnulleinträgen zu Gesamtanzahl an Einträgen wird auch als Dichte der Matrix bezeichnet. Das Gegenteil, also eine voll besetzte Matrix, wird logischerweise full genannt. Matrizen lassen sich mit den Befehlen sparse(A) bzw. full(A) von dem einen in den anderen Datentyp umwandeln.
Spezielle spärlich besetzte Matrizen lassen sich direkt erstellen. Der Begriff speye(n) erstellt eine Sparse-Einheitsmatrix, mithilfe von spdiags lassen sich Diagonalmatrizen erstellen. Die Syntax für diesen Befehl ist A=spdiags(B,d,m,n). Dabei ist B eine Matrix, welche als Spalten die gewünschten Diagonalenelemente enthält. d beschreibt die Positionen der Diagonalen – die Hauptdiagonale hat den Index 0, die oberen Nebendiagonalen positive, die unteren Nebendiagonalen negative Indexeinträge. Die Zahlen m und n beschreiben zuletzt die Dimension der Matrix. Das Ergebnis für die Eingabe A=spdiags(ones(3,1)*(1:4),[-2,-1,0,2],3,3) sieht wie folgt aus:

Für Statistiker gibt es außerdem mit A=sprand(m,n,Dichte) die Möglichkeit eine Sparse-Matrix mit zufällig gleichverteilten Werten zu generieren, welche die vorgegebene Dichte zwischen 0 und 1 besitzt.
Ein zusätzlicher Effizienzschub wird generell durch Präallokation erreicht. Ist die Größe einer Matrix bekannt und nicht von dynamischer Größe, so kann durch das vorherige Festlegen der Matrix (die Präallokation) das Programm noch besser laufen. Bei üblichen Matrizen ist das durch vorherige Definition als Nullmatrix möglich, für Sparse-Matrizen gibt es den spalloc-Befehl: Mit S=spalloc(m,n,nzmax) wird eine m × n Sparse-Matrix S erstellt, welche bis zu nzmax Nichtnulleinträge haben kann. Diese Zahl kann zwar überschritten werden, doch dann muss Matlab wieder dynamisch Speicher hinzufügen und der Effizienzgewinn ist verloren.
Es existieren noch einige weitere Befehle mit denen man Eigenschaften der Sparse-Matrizen abfragen kann. Der Befehl issparse(A) gibt einen boolean-Wert aus, der beschreibt, ob die Matrix im Sparse-Format vorliegt. nzmax(A) gibt den allokierten Speicherplatz, nnz(A) die Anzahl an Nichtnulleinträgen an. Nicht zu verwechseln ist dieser mit dem nonzeros-Befehl, welcher sämtliche Nichtnulleinträge ausgibt.
Die Befehle sind nun klar – doch worin ist nun der tatsächliche Nutzen zu sehen? Der Vergleich zwischen einer zufälligen Sparse-Matrix A=sprand(1000,1000,0.3) und ihrer Darstellung B=full(A) ergibt beim Speicherplatzvergleich 4.1 MB für Matrix A und 8 MB für Matrix B. Auch die Multiplikation ist um einiges schneller: Mit den Vektoren x=sprand(1000,1,0.3) bzw. y=full(x) ergibt sich für die Berechnung A*x eine benötigte Zeit von 0.05 Sekunden, im Vergleich dazu braucht die Berechnung B*y 0.63 Sekunden.
Insbesondere bei der Diskretisierung, beispielsweise von Gradienten oder von partiellen Differentialgleichungen treten solche spärlich besetzten Matrizen, häufig als Band- oder Blockmatrizen auf. Bei diesen Problemen sind damit viel größere Probleme vom Rechner beherrschbar – das Verwenden dieses Datentyps ist daher lohnend. In der nächsten Ausgabe gibt es weitere Tipps und Tricks rund um das Programm Matlab.

Dieses Mal soll es um etwas gehen, was in keinem Film und keiner wissenschaftlichen Arbeit fehlen darf: ein guter Plot! Als grafische Darstellung von Daten, Sachverhalten oder Funktionen können Plots Thesen untermauern und Zusammenhänge erklären sowie visualisieren. Dass man dabei auch genug verkehrt machen kann, kann man sich denken. Eine schlechte Visualisierung der Daten kann das Gegenteil vom gewünschten Effekt bewirken. Deshalb an dieser Stelle einige Tipps was überhaupt in Matlab alles möglich ist.

Der wohl am häufigsten verwendete Darstellungstyp ist der Kurvenplot. Mithilfe des Befehls plot(X,Y); lassen sich die Daten X und Y gegeneinander auftragen. Standardmäßig wird er in einer neuen Figur (englisch: Figure) dargestellt. Dabei ist es durch
plot(X1,Y1,X2,Y2,…);
möglich, mehrere Kurven in einen Plot einzuzeichnen. Alternativ kann insbesondere bei vielen Kurven in einem Plot der hold-Befehl übersichtlicher sein. Alles, was zwischen hold on; und hold off; geplottet werden soll, landet in derselben Figure.

Doch eine Kurve alleine sagt wenig aus. Die wohl wichtigsten Informationen, die gerne vergessen werden, sind die Achsenbeschriftungen. Schon zu Schulzeiten gab es für das Weglassen selbiger im Mathematik-Unterricht Punktabzüge. Deshalb sollten sie bei der Abgabe von Übungszetteln und in wissenschaftlichen Arbeiten auf jeden Fall dabei sein. Möglich wird das in Matlab mit den Befehlen xlabel bzw. ylabel. Die Syntax lautet dafür
xlabel('Achsenbezeichnung');.
Neben den Achsen sollte auch noch der gesamte Plot betitelt werden – falls eine zusätzliche Beschreibung des Textes nicht bereits vorgesehen ist. Realisiert wird das durch den title-Befehl, der sich in der Syntax von den vorherigen nicht unterscheidet. Die Bezeichnung ist dabei ein String, also eine Zeichenkette. Neben normalen Buchstaben und Zeichen lässt sich noch einiges mehr verwenden. So ist es möglich, die Zahlwerte von Variablen einzubinden. Dazu muss die Variable vom Zahlenformat durch den num2str-Befehl in das Stringformat umgewandelt werden. Um das Ganze mit Textbausteinen zu kombinieren, können komplexere Strings durch Arrays von Teilstrings realisiert werden. Hat z.B. die Variable x den Wert 2, so ergibt die Eingabe
[ 'Abbildung' ,num2str(x),': Beispielplot' ]
den String
'Abbildung 2: Beispielplot'.
Weiter ist die Verwendung von LaTeX-Code innerhalb von Achsen-Labels und weiteren Beschriftungen möglich. Dazu müssen, wie aus LaTeX bekannt, um die mathematische Formel $-Zeichen gesetzt werden. Zusätzlich muss Matlab gesagt werden, dass es das geschriebene als LaTeX-Code zu interpretieren hat, indem als weitere Argumente an den Befehl folgendes angefügt wird:

xlabel(‘$\mathcal{A}$’,’Interpreter’,’latex’);

Doch die Erwartungen sollten nicht zu hoch sein. Dadurch, dass ohne weiteres keine zusätzlichen LaTeX-Pakete eingebunden werden können, ist die Auswahl an möglichen Formeln beschränkt. Brüche aus Zahlen, griechische Buchstaben und ein paar Formatierungen sind jedoch möglich.

Bei mehreren Plots in einer Figure ist auch die Form und Farbe der Plots wichtig, um die verschiedenen Graphen zu unterscheiden. Matlab bietet eine Vielzahl an Möglichkeiten, das zu gewährleisten. Die Beschreibungsparameter werden dem Plot-Befehl beigefügt:

plot(X,Y,'StyleParameter','Parameterstring');

Davon können beliebig viele nacheinander geschrieben werden. Hier eine Übersicht über die wichtigsten Parameter. Natürlich gibt es noch einige mehr, sie können in der Matlab-Dokumentation nachgeschlagen werden.

• 'LineStyle' – Linienart: Die Kurven können zum Beispiel durchgehend ('.'), gestrichelt ('--'), gepunktet (':') werden – oder ganz weggelassen werden ('none').
• 'LineWidth' – Linienbreite: Die Linienbreite lässt sich mithilfe dieses Parameters steuern, der Wert wird in Punktbreite als Zahl angegeben.
• 'Color' – Farbe: Die Farbe kann auf zweierlei Weise beschrieben werden: Durch ein RGB-Tripel [R G B], wobei die Werte zwischen 0 und 1 angenommen werden. Für einige standardmäßige Farben ist es auch möglich, einen String anzugeben, z.B. 'yellow' oder 'red'.

Zuletzt sollte dem Leser auch beschrieben werden, welcher Plot zu welchem Datenset gehört: Stichwort dafür ist die Legende. Der zugehörige Matlab-Befehl ist legend mit der Syntax

legend('Name1', 'Name2',..., 'NameN','Location','Wert','Orientation','Wert');

Die Reihenfolge der Namen ist dabei diejenige, in der die Graphen geplottet wurden. Der Parameter Location beschreibt die Position der Legende im Plot und wird durch die Himmelsrichtungen beschrieben, z.B. 'west' oder 'northeast'. Der Parameter 'Orientation' beschreibt, ob die Lengendeneinträge 'vertical' oder 'horizontal' angeordnet werden. Der Standardwert ist dabei vertikal.

Es gibt in Matlab noch viele weitere Möglichkeiten, die ermittelten beziehungsweise verwendeten Daten sinnvoll und gut ansehnlich darzustellen. Die äußere Darstellung sollte nicht unterschätzt werden – sie trägt maßgeblich zum Eindruck bei. In der nächsten Ausgabe gibt es weitere Tipps und Tricks rund um das Programm Matlab.

Mit ein paar kleinen Tricks sieht Matlab das “Busy”-Feld nicht mehr ganz so lange.[media-credit id=51 align="aligncenter" width="640"]

Doch in Matlab hat sie viel Nutzen. Ebenso wie Zahlen können auch Booleans in Form von Matrizen und Vektoren strukturiert werden. Weiter können sie mit Zahlen direkt verrechnet werden. In diesem Falle werden sie wie die „normalen“ Zahlen 0 und 1 behandelt.

Zunächst sollen hier einmal kurz die grundlegenden Operatoren vorgestellt werden, die mit Booleans arbeiten. Dabei unterscheidet man zwischen relationalen und logischen Operatoren.

Relationale Operatoren sind, wie der Name verrät, vergleichende Operatoren: <, <=, >, >=, ==, und ~=. Sie vergleichen zwei Objekte (im Normalfall Zahlen oder Matrizen) und geben das Ergebnis als Boolean aus. So ergibt 3==2 den Wert 0 und [1 2 3]<=2 den Boolean-Vektor [1 1 0]. Wieder können diese elementweise verwendet werden: [1 2 3]>=[3 2 1] ergibt [0 1 1].

Logische Operatoren akzeptieren üblicherweise Booleans als Eingabe und geben wiederum Booleans aus. Sie akzeptieren in Matlab auch gewöhnliche Zahlen, hierbei wird jedoch jeder Eintrag, welcher nicht 0 ist, wie 1 behandelt. Die logischen Operatoren, die Matlab kennt sind UND (&, &&), ODER (|,||), NICHT (~) und XOR (xor(A,B)) und folgen den bekannten Wertetabellen. Sie sind wieder elementweise einsetzbar. Die „doppelten“ Operatoren && und || sind besondere Varianten: Sie sind sogenannte „Short-circuit“-Operatoren und werten bei Eingabe A&&B bzw. A||B die Werte von B gar nicht mehr aus, wenn durch A das Ergebnis bereits feststeht. So ist, wenn A falsch ist auch immer A UND B falsch, ist A wahr, ist auch immer A ODER B wahr. Sie bieten damit eine Steigerung der Effizienz.

Eine praktische Anwendung für Booleans, relationale und logische Operatoren liegt in der Adressierung von Elementen einer Matrix. Matlab akzeptiert nicht nur die bekannte Angabe einzelner oder mehrerer Zeilen und Spalten zur Adressierung von Elementen, sondern auch Booleans: Dabei muss die Boolean Matrix dieselbe Anzahl Elemente wie die abzufragende Matrix haben. Matlab listet dann sämtliche Elemente in einem Spaltenvektor auf, an deren Position die Boolean-Matrix wahr ist.

Ist beispielsweise A=[1 2 3;4 5 6] und B die Boolean-Matrix [0 1 0; 1 1 1] ergibt die Anfrage C=A(B) die Matrix C=[4;2;5;6]. Die Reihenfolge ergibt sich daraus, dass Matlab B intern vektorisiert, also alle Spalten von B untereinander als Spaltenvektor schreibt. Dadurch, dass die Booleans auch als Zahlen funktionieren, funktioniert dieser Trick: D=A.*B. Das ergibt die einfache Möglichkeit, eine Matrix D zu konstruieren, die dieselbe Größe wie A behält und an allen „wahren“ Stellen von B die ursprünglichen Werte, aber an all den Stellen, in denen B „falsch“ ist nur noch eine 0 steht. Statt direkt Boolean-Matrizen zu verwenden, ist es oft praktisch gleich logische Abfragen zu verwenden. A(A>0) liefert zum Beispiel direkt alle positiven Einträge der Matrix A, B(B>=0 & B<=1) liefert alle Elemente von B, die zwischen null und eins liegen.

Durch die Verwendung solcher Konstrukte lassen sich einige relativ ineffiziente if-Abfragen einfach ersetzen. Insbesondere in dem folgenden, häufig auftretenden Fall lässt sich viel Rechenzeit sparen: Wir haben eine Matrix voller Werte. Abhängig von diesen Werten sollen irgendwelche Rechnungen mit selbigen angestellt werden. Als Beispiel wollen wir Werte gewichten. Ist der Wert negativ, so soll er verdoppelt werden, ist er positiv halbiert. Ein einfacher Ansatz wäre:

for i=1:size(A(:))

if A(i)<0

A(i)=2*A(i);

elseif A(i)>0

A(i)=0.5*A(i);

end;

end;

Ein Testlauf mit einer Zufallsmatrix A mit 10000 Werten ergab eine Rechenzeit von 165.35 Sekunden – knapp 2.5 Minuten für eine per se simple Aufgabe. Versuchen wir jetzt, das Ganze mithilfe von Booleans darzustellen. Die einzelnen if-Abfragen lassen sich über A<0 bzw. A>0 matrixwertig realisieren. Alle negativen Einträge lassen sich durch A.*(A<0) bestimmen, alle positiven durch A.*(A>0). Zusammen mit den Multiplikationen ergibt sich folgender Einzeiler:

A=2*A.*(A<0)+0.5*A.*(A>0);

Oder noch kürzer:

A=(2*(A<0)+0.5*(A>0)).*A;

Die Rechenzeit liegt bei 2.8 bzw. 2.38 Sekunden. Das sind nur 1.69 beziehungsweise 1.44 Prozent der Rechenzeit des ersten Versuches – also ein erheblicher Zeitgewinn. So lässt sich durch eine kleine Veränderung des Programmes die Effizienz massiv verbessern. Das hilft nicht nur bei fortgeschrittenen Programmen, sondern sorgt auch so manches Mal bei euren Korrekteuren für großzügigere Bepunktung, wenn die Programme schneller laufen.

In der nächsten Ausgabe gibt es weitere Tipps um eure Matlab-Programme zu verbessern. Teil 1 findet ihr hier.

Selbst die Frage nach dem Warum kann Matlab treffend beantworten.[media-credit id=51 align="aligncenter" width="640"]

Ein kleines einfaches Beispiel: X ist ein Vektor mit 10.000 Einträgen (hier gefüllt mit Zufallszahlen zwischen 0 und 1). In solchen und viel höheren Dimensionen wird in der Realität häufig gearbeitet. Wir entscheiden uns, dass wir lieber Zufallszahlen zwischen -0.5 und 0.5 haben wollen. Eine Möglichkeit, dies zu realisieren ist, jeder Zufallszahl den Wert 0.5 abzuziehen. Mit einer simplen for-Schleife sieht das Ganze so aus:

for i=1:10000

X(i)=X(i)-0.5;

end;

Matlab kann das Ganze aber effizienter berechnen. Addiert oder subtrahiert man nämlich eine Zahl zu einem Vektor oder einer Matrix hinzu, so tut Matlab dies elementweise, also addiert bzw. subtrahiert diese Zahl an jedes einzelne Element der Matrix. Als Code ist es folgender Einzeiler:

X=X-0.5;

Man beachte die fehlende Angabe eines Index i. Das ist gewollt, da so mit ganz X und nicht mit einem Element von X gearbeitet wird. Die Zeitauswertung der beiden Versuche liefert eine Rechendauer im Rahmen <math>10^{-4}</math> für die erste und <math>10^{-5}</math> für die zweite Version. Es mögen beide sehr gering sein; sie unterscheiden sich aber schon bei einer Größe von <math>10^{5}</math> Werten in X um den Faktor 10. Erhöht man die Größe von X auf 10 Millionen Werte, benötigen wir ca. 10 Sekunden für die Version mit for-Schleife und ca. 0.01 Sekunden für den Vektorbefehl. Ein Unterschied um den Faktor 1000.

Eine Rechendauer von 10 Sekunden ist für eine reine Subtraktion offensichtlich unsinnig viel. Dieses leichte Beispiel zeigt, welchen gewaltigen Unterschied es machen kann, mit den Matlab-gedachten Methoden anstatt mit den altbekannten zu arbeiten. Deshalb ist es schon am Anfang lohnend, sich mit der vektoriellen Methodik Matlabs auseinanderzusetzen. Auch wenn es für die Übungszettel im dritten oder vierten Semester kaum einen Unterschied macht, nützt einem das Wissen bei größeren Projekten umso mehr.

Neben der einfachen Addition kennt Matlab einige andere grundlegende Rechenbefehle, die elementweise durchgeführt werden. Sämtliche skalaren Werte können addiert, subtrahiert, multipliziert und dividiert werden. Sogar das Potenzieren ist elementweise machbar. Da der übliche “^“-Befehl jedoch bereits für die Matrixpotenz reserviert ist, muss ein Punkt hinzugefügt werden. Will man zum Beispiel alle Quadrate der Zahlen 1 bis 5 verwenden, so lautet der einfache Befehl

Y=(1:5).^2

und gibt die korrekte Ausgabe

Y = 1 4 9 16 25

Bei der Multiplikation dürfen die normalen Operatoren * bzw. / nicht mit den Operatoren .* beziehungsweise ./ verwechselt werden! Erstere sind nämlich für die Matrizenmultiplikation bzw. die Multiplikation mit der Inversen der Matrix reserviert. Letztere Befehle gibt es ebenfalls. Sie haben aber eine andere, wenn auch nicht weniger praktische Bedeutung. Mit ihnen kann man zwei gleich große Matrizen A und B elementweise multiplizieren oder dividieren – etwas das häufig notwendig ist und gerne auch mit for-Schleifen realisiert wird. Die elementweise Addition zweier Matrizen funktioniert über den einfachen Operator “+“.

Eine Übersicht über die Matlab-Operatoren.[media-credit id=51 align="aligncenter" width="640"]

Die richtige Wahl des Operators ist dabei wichtig und beeinflusst nicht nur die Korrektheit der Berechnung, auch kann man mit dem richtigen Operator ineffiziente for-Schleifen umgehen, falls diese nur für elementweise Berechnungen genutzt werden. Es gibt natürlich viele andere Situationen, in denen for-Schleifen nicht vermieden werden können. Wo es aber machbar ist und nicht zu sehr zu Lasten der Lesbarkeit fällt, sollten sie so wenig wie möglich verwendet werden.

In der nächsten Ausgabe unserer Zeitung gibt es ein paar Tipps zum Datentyp Boolean und wie man mit diesem if-Abfragen als Matrix-Vektor-Operationen effizienter programmieren kann.