MATLAB - Eine Einführung - TUM

MATLAB - Eine Einführung
Christian Kufner Harald Schmid Konstantin Schorp Bettina Tögel
Matthias Vestner Konstantin Pieper Lorenz Pfeifroth Stefan Jerg
Boris von Loesch
16. April 2009

Vorwort
Das vorliegende Skript gibt dem Leser eine Einführung in den Umgang mit MATLAB. Die Bedienung
von MATLAB und die Themen Visualisierung und lineare Algebra mit MATLAB werden erklärt. Auf
weiterführende Funktionen MATLAB wie Toolboxen und das Einbinden von Java- und C-Programmen
wird eingegangen.
Dieses Handbuch ist besonders für Studenten der Mathematik geeignet, die im Studium MATLAB
benötigen. Grundkenntnisse der linearen Algebra werden vorausgesetzt, jedoch sind keine Programmierkenntnisse
notwendig. Dieses Skript ist im Internet unter
http://www.fs.tum.de/fsmpi/kurse/matlab/matlabeinfuehrung.pdf
verfügbar. Sie erreichen den verantwortlichen Mitarbeiter der TU München unter der Email-Adresse
brandenb@ma.tum.de.
Zweite Auflage Dieses Skript wurde für den Ferienkurs „MATLAB Grundlagen“ im Wintersemester
07/08 überarbeitet und um die Abschnitte „Eigenwerte“ 5.5, „Ein- und Ausgabe“ 7 und „Troubleshooting“
erweitert. Die Webadresse des Kurses ist
http://ferienkurse.ma.tum.de/twiki/bin/view/Allgemein/WS0708/Matlab.
Dritte Auflage Dieses Skript wurde für den Ferienkurs „MATLAB Grundlagen“ im Sommersemester
08 überarbeitet. Die Webadresses des Kurses ist
http://ferienkurse.ma.tum.de/twiki/bin/view/Ferienkurse/SS08/MatLabG
Vierte Auflage Für die vierte Auflage wurden weite Teile des Skriptes stark verändert. Ein Einstiegsbeispiel
(Kapitel 1) soll den Leser mit den besonderen Fähigkeiten von MATLAB vertraut machen.
Kapitel 2 ist komplett umgearbeitet worden, zusätzlich wurde das Skript um einen Index ergänzt. Diese
Einführung wurde für die Ferienkurse MATLAB im SS09 verwendet.
http://www.ma.tum.de/Ferienkurse/WiSe0809/MatLabC
1

Inhaltsverzeichnis
0.1 Bezug von MATLAB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
0.2 Alternativen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
0.3 Hinweise zur Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
0.3.1 Komplexe Zahlen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1 Motivation 7
1.1 Interpolation durch kubischen Splines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2 Implementierung in MATLAB . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
1.3 Visualisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.4 Erweiterung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
1.5 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
2 Vektoren und Matrizen 11
2.1 Matrizen erzeugen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
2.1.1 Spezielle Matrizen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2.1.2 Doppelpunkt Operator . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Indizierung und Doppelpunktnotation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.3 Operatoren und Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
2.3.1 Rechenoperatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.2 Basisfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3.3 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.4 Matrizen manipulieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
3 Operatoren und Flusskontrolle 23
3.1 Relationale Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2 Logische Operatoren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
3.2.1 Indizierung mit logischen Feldern . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.3 Flusskontrolle . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4 M-Dateien 30
4.1 Skriptdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30
4.2 Funktionsdateien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.3 M-Dateien bearbeiten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
4.4 Mit M-Dateien und der Pfadvariable von MATLAB arbeiten . . . . . . . . . . . . . . . . 32
4.5 Dualität von Befehl und Funktion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
5 Lineare Algebra mit MATLAB 34
5.1 Norm und Kondition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
5.2 Lineare Gleichungssysteme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.1 A n × n Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.2 A m × n Matrix mit m > n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.2.3 A m × n Matrix mit m < n . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.3 Inverse, Pseudoinverse und Determinante . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
5.4 Zerlegungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.4.1 LR-Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.4.2 Cholesky-Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.4.3 QR-Zerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.4.4 Singulärwertzerlegung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
2

5.5 Eigenwertpropleme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.5.1 Eigenwerte . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
5.6 Matrixfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
6 Eigene Funktionen 39
6.1 Referenzen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
6.2 Subfunktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
6.3 Globale Variablen und Rekursion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
7 Ein- und Ausgabe 42
7.1 Direkte Eingabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
7.2 Bildschirmausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.3 Speichern und Laden . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
7.4 Indirekte Eingabe und Ausgabe . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 44
8 Optimierung von M-Files 46
8.1 Vektorisierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
8.2 Preallokierung von Speicher . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
9 Tipps und Tricks 48
9.1 Leere Arrays . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
9.2 ∞ und −∞ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
10 Grafiken mit MATLAB erstellen 50
10.1 Grafiken . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
10.2 2-dimensionale Plots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
10.3 Mehrere Plots in einem Fenster . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
10.4 3-dimensionale Plots . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
10.4.1 Animationen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
10.5 Diagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
10.5.1 Balkendiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
10.5.2 Tortendiagramme . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
11 Troubleshooting 61
11.1 Errors und Warnings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
11.2 Debugging . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
12 Weiterführende MATLAB-Funktionen 62
12.1 Toolkits . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
12.1.1 Symbolic Math Toolbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
12.1.2 Image Processing Toolbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.2 Der MATLAB C-Compiler . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63
12.3 Andere Programmiersprachen mit MATLAB verwenden . . . . . . . . . . . . . . . . . . . 64
12.3.1 Fortran und C . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 64
12.3.2 Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12.4 GUIs programmieren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12.4.1 GUI Kommandos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 65
12.4.2 GUIDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
3

Einleitung
MATLAB ist eine mächtige Anwendung für Mathematiker und Ingenieure, die von der Firma The Mathworks
entwickelt und vertrieben wird. Vielfältigste Funktionen zur Lösung numerischer Probleme, der
Visualisierung von Daten und die Erweiterbarkeit des Basispakets über Toolboxen machen MATLAB zu
einem guten Werkzeug für Studenten der Mathematik, die sich im Rahmen ihres Studiums auch mit dem
Lösen numerischer Probleme beschäftigen.
MATLAB enthält eine komfortable IDE (integrated development environment) die den Programmierer
bei seiner Arbeit unterstützt. In ihr sind sind unter anderem enthalten
• eine interaktive Codeeingabe,
• eine ausführliche Hilfe,
• ein Quellcode Editor mit Syntax Highlighting,
• ein Debugger um Programme schrittweise durchlaufen zu lassen,
• ein Profiler zum Erkennen von Geschwindigkeitsengpässsen.
Im Gegensatz zu anderen Programmiersprachen wie C, Fortran oder Java muss MATLAB Code vor der
Ausführung nicht kompiliert werden, sondern wird direkt interpretiert 1 . Auch müssen Variablen vor ihrer
ersten Verwendung nicht deklariert werden. Deshalb ist MATLAB in die Kategorie der Skriptsprachen,
wie z.B. Python, Tcl oder Perl, einzuordnen.
Das Besondere an MATLAB ist die Verwendung von mehrdimensionalen Feldern (auch mit komplexen
Zahlen) wie Vektoren und Matrizen als Standardtypen und eine umfangreiche mathematische Bibliothek.
Damit ist es möglich, Algorithmen in einer mathematischen Syntax unter Verwendung von Standardkomponenten
wie z.B. einer LR-Zerlegung schnell zu implementieren (Prototyping). Der Vorwurf, dass
Programme in MATLAB im Vergleich zu Fortran oder C viel langsamer sind, ist im Allgemeinen nicht
berechtigt, wenn man bei der Programmierung gewisse Prinzipien befolgt. Dies liegt daran, dass MAT-
LAB intern sehr schnelle Routinen z.B. für das Matrix-Vektor-Produkt oder die Fouriertransformation
verwendet; wie andere Numerikpakete verwendet MATLAB für die Lineare Algebra die BLAS und LA-
PACK Bibliotheken.
Diese Einführung soll einen Einblick in den Aufbau und die grundlegenden Funktionen von MATLAB
geben. Weiterführende Informationen findet man in der umfangreichen eingebauten Hilfe, in den vielen
MATLAB Bücher und natürlich auch im Internet.
0.1 Bezug von MATLAB
Als Student gibt es die Möglichkeit kostengünstig eine Studentenversion zu erwerben, die allerdings nur
während und für das Studium verwendet werden darf. Weiterhin ist auf allen Computer der Rechnerhalle
MATLAB verfügbar.
0.2 Alternativen
Neben MATLAB gibt es eine Reihe Programmpakete, die -zumindest was die grundlegenden Funktionen
angeht- sehr ähnlich sind. Eine nicht repräsentative Liste frei verfügbarer Pakete:
1 Seit MATLAB R6.5 wird der Code während der Ausführung durch einen Just-In-Time Kompilierer übersetzt um eine
höhere Performance im Vergleich zur direkten Ausführung zu erhalten
4

Octave ist ein Open-Source Clone von MATLAB der für viele Betriebssysteme verfügbar ist. Alle Beispiele
aus diesem Skript (bis auf das Kapitel Grafik) sollten ohne Änderung auch in Octave funktionieren.
http://www.gnu.org/software/octave/
SciLab Eine freie MATLAB Alternative die am INRIA 2 entwickelt wurde. Der Syntax ist nicht kompatibel
zu MATLAB, allerdings recht ähnlich; im Paket enthalten ist ein MATLAB zu SciLab
Konverter.
http://www.scilab.org/
Python+NumPy+SciPy NumPy und SciPy erweitern die Skriptsprache Python um einen flexiblen
Array-Typ und eine umfangreiche mathematische Bibliothek. Die Syntax ist verschieden zu MAT-
LAB. Diese Kombination erfreut sich in letzter Zeit größerer Beliebtheit. Ein besonderer Vorteil
dieses Paketes ist die Möglichkeit, sehr einfach andere Numerikcodes wie z.B. PETSc oder Trilinos
direkt in Python zu verwenden.
http://www.scipy.org
0.3 Hinweise zur Eingabe
Wie C oder Java unterscheidet MATLAB zwischen Groß- und Kleinschreibung. So kann der Befehl
sin(pi/2) richtig interpretiert werden, die Eingabe von Sin(pi/2) gibt jedoch eine Fehlermeldung zurück:
??? Undefined function or method ’Sin’ for input arguments of type ’double’.
Methodennamen werden in MATLAB grundsätzlich klein geschrieben und als Programmierer sollte
man sich an diese Konvention halten.
In den ersten Kapiteln werden wir die Beispiele direkt in die interaktive Codeeingabe eintippen.
Das Ergebnis eines Befehls wird standardmäßig direkt ausgegeben. Dies kann unterdrückt werden durch
Abschließen des Befehls mit einem Semikolon. Wird das Ergebnis eines Befehls nicht in einer Variable
gespeichert, wird es automatisch in die Variable ans geschrieben.
>> sin(pi/2)
ans =
1
>> sin(pi/4);
>> ans
ans =
0.7071
Mehrere Befehle können durch Komma (mit Ausgabe des Ergebnisses) oder Semikolon (ohne Ausgabe
des Ergebnisses) getrennt in eine Zeile geschrieben werden. Hierbei wird nur das letzte Resultat in ans
gespeichert.
>> cos(0); cos(pi/4), cos(pi/2)
ans =
0.7071
ans =
6.1232e-17
0.3.1 Komplexe Zahlen
MATLAB interpretiert eine Zahl standardmäßig als Gleitpunktzahl mit doppelter Genauigkeit 3 . Komplexe
Zahlen werden durch
2 Institut national de recherche en informatique et en automatique
3 Im Gegensatz zu vielen anderen Programmiersprachen ist 1/2 also wirklich 0.5.
5

+i
eingegeben, z.B. 2+0.5i. Aus diesem Grund sollte die imaginäre Einheit i nicht durch eine Variable
überschrieben werden, da es sonst Probleme mit komplexen Zahlen geben kann.
MATLAB verwendet automatisch komplexe Zahlen wenn dies nötig ist. So wird z.B. √ −1 richtig als
komplexe Zahl interpretiert. In vielen anderen Programmiersprachen würde dieser Aufruf eine Fehlermeldung
erzeugen.
6

Kapitel 1
Motivation
Bevor wir uns die Funktionen von MATLAB im Detail anschauen, wollen wir an einem kurzen Beispiel
die schnelle und effiziente Umsetzung eines Algorithmus in MATLAB demonstrieren. Wie werden hier
die Vorzüge gegenüber klassischen Programmiersprachen feststellen.
1.1 Interpolation durch kubischen Splines
Bei der Interpolation ist eine stetige Funktion S : R → R gesucht, die eine gegebene Menge von Knotenpunkten
(xi, yi) ∈ R×R, i = 0, . . . , n mit xi < xj, i < j interpoliert, d.h. S(xi) = yi für i = 0, . . . , n. Häufig
benötigt man, dass die Funktion S mindestens zweimal stetig differenzierbar ist, dann bieten sich kubische
Splines zur Interpolation an. Ein kubischer Spline ist eine C 2 ([x0, xn]) Funktion, die eingeschränkt
auf ein Intervall [xi, xi+1], i = 0, . . . , n − 1 ein Polynom 3. Grades ist. Diese Aufgabe ist nur dann eindeutig
lösbar, wenn man noch zusätzliche Informationen am Rand vorgibt. Dafür gibt es mehrere Varianten,
eine davon ist, dass die zweiten Ableitungen in den Randpunkten verschwinden (S ′′ (x0) = 0 = S ′′ (xn)).
In diesem Fall nennt man den Spline natürlichen Spline.
Eine Möglichkeit einen natürlichen Spline zu berechnen, ist die Momentenmethode. Wir wollen in diesem
Rahmen nicht auf deren Herleitung eingehen sondern verweisen auf [1]. Als Momente Mi bezeichnet
man die zweiten Ableitungen an den Stützstellen xi, also Mi = S ′′ (xi). Hat man sie berechnet, kann man
die Koeffizienten des Polynoms
Pi(x) = αi + βi(x − xi) + γi(x − xi) 2 + δi(x − xi) 3
auf dem Intervall [xi, xi+1] direkt angeben (hi+1 = xi+1 − xi):
αi = yi
βi = yi+1 − yi
hi+1
γi = Mi
2
δi = Mi+1 − Mi
6hi+1
− 2Mi + Mi+1
hi+1
6
Die Momente sind Lösung des linearen Gleichungssystems
⎛
2
⎜µ1
⎜
⎝
λ0
2
µ2
λ1
2
. ..
λ2
. ..
µn−1
. ..
2
⎞
⎛
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎝
λn−1⎠
2
µn
7
M0
M1
.
Mn−1
Mn
⎞
⎛
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ = ⎜
⎟ ⎜
⎠ ⎝
d0
d1
.
dn−1
dn
⎞
⎟
⎠
(1.1)

mit (j = 1, . . . , n − 1)
hj
λj =
hj + hj−1
µj = 1 − λj
6
dj =
hj + hj−1
Für den natürlichen Spline setzt man noch
yj+1 − yj
hj
λ0 = d0 = dn = µn = 0. 1
1.2 Implementierung in MATLAB
− yj
− yj−1
.
hj−1
In diesem Abschnitt werden uns ein kurzes MATLAB Skript ansehen, welches die Koeffizienten der
Polynome die den kubischen Spline beschreiben ausrechnet. Da dies nur eine kurze Motivation für die
Verwendung von MATLAB sein soll, werden wir die Implementierung nicht in voller Ausführlichkeit
besprechen. Die genaue Funktionsweise sollte mit Hilfe der späteren Ausführungen verständlich werden.
Die Funktion kspline bekommt als Eingabeparameter ein Vektor x mit den Stützstellen und ein
Vektor y mit den zu interpolierenden Werten. Zurückgegeben wird eine (n − 1) × 4-Matrix, in deren i-ter
Zeile die Koeffizienten des kubischen Polynoms des Intervalls [xi, xi+1] stehen.
1 function [ P ] = k s p l i n e ( x , y )
2 n = length ( x ) ;
3 j j = 1 : n−1; j = 2 : n−1;
4 h = [ x ( j j +1)−x ( j j ) ] ;
5 lambda = [ 0 , h ( j +1)./( h ( j )+h ( j + 1 ) ) ] ;
6 mu = [1−lambda ( j ) , 0 ] ;
7 d = [ 0 , ( 6 . / ( h ( j )+h ( j + 1 ) ) ) . ∗ ( ( y ( j +1)−y ( j ) ) . / h ( j +1) . . .
8 − ( y ( j )−y ( j −1))./ h ( j ) ) , 0 ] ;
9 A = 2∗eye ( n ) + diag ( lambda , 1) + diag (mu, −1);
10 M = (A \ d ’ ) ’ ;
11 alpha = y ( j j ) ; gamma = M( j j ) / 2 ;
12 beta = ( y ( j j +1)−y ( j j ) ) . / h ( j j +1) − h ( j j +1).∗(2∗M( j j )+M( j j +1))/6;
13 d e l t a = (M( j j +1)−M( j j ) ) . / ( 6 ∗ h ( j j +1));
14 P = [ alpha ’ , beta ’ , gamma’ , delta ’ ] ;
15 end
In der ersten Zeile des Skripts speichern wir die Anzahl der Punkte in der Variable n und erzeugen
Vektoren jj und j in dem die Zahlen von 1 bzw. 2 bis n − 1 stehen. Dann berechnen wir die Länge
der Intervalle [xi, xi+1] und speichern diese in h. Auf dieselbe Weise berechnen wir die λi, µi und di. Die
Einträge λ0, µn, d0 und dn werden hierbei explizit auf Null gesetzt. Man sieht, wie sich die Formeln aus
dem vorherigen Abschnitt nahezu eins zu eins im MATLAB Code wiederfinden.
In Zeile 9 erzeugen wir die Matrix aus (1.1) indem wir auf eine mit zwei multiplizierte Einheitsmatrix
die Vektoren lambda und mu auf die Nebendiagonalen addieren.
Der Aufruf M = (A \ d’)’; löst nun das Gleichungssystem (1.1). Der hierbei verwendete Backslash-
Operator wählt automatisch das Verfahren welches das Gleichungssystem möglichst effizient löst, z.B.
eine Cholesky-Zerlegung bei einer symmetrisch positiv definiten Matrix. Da Vektoren in MATLAB standardmäßig
Zeilenvektoren sind, müssen wir die rechte Seite d mit ’ transponieren und die Lösung auf die
selbe Weise zurück in einen Zeilenvektor transformieren. Alternativ hätten wir auch den Slash-Operator
verwenden können, um das zweimalige Transponieren zu vermeiden: M = d / A;.
Nachdem die Momente bestimmt sind, berechnen die letzten Zeilen der Funktion die Koeffizienten
des Polynoms und schreiben sie in die (n − 1) × 4-Matrix P. Damit ist alles berechnet.
An diesem Beispiel kann man gut erkennen, wie effektiv der gegebene Algorithmus implementiert
wurde. Wir sind komplett ohne Kontrollstrukturen wie z.B. Schleifen ausgekommen. Zusätzlich lässt sich
der Programmcode sehr gut lesen und ist gut verständlich.
1 Mit dieser Wahl folgt sofort M0 = S ′′ (x0) = Mn = S ′′ (xn) = 0
8

Das folgende Beispiel demonstriert die Verwendung der Methode um einen kubischen Spline zu berechnen,
der die Wurzelfunktion im Intervall [0, 1] interpoliert:
>> x=0:0.1:1;
>> y=sqrt(x);
>> P=kspline(x,y)
P =
0 3.4008 3.5780 -59.6338
0.3162 2.2081 -14.3121 53.2933
0.4472 0.9445 1.6759 -10.7011
0.5477 0.9587 -1.5345 4.2121
0.6325 0.7781 -0.2708 -0.4530
0.7071 0.7104 -0.4067 0.5202
0.7746 0.6446 -0.2507 0.1069
0.8367 0.5977 -0.2186 0.1827
0.8944 0.5595 -0.1638 -0.0523
0.9487 0.5236 -0.1795 0.7479
Das Intervall wird in äquidistante Stücke der Länge 0.1 unterteilt und dann die Werte der Wurzelfunktion
an den Intervallgrenzen in y gespeichert. Mit diesen Informationen füttern wir unsere Routine kspline,
die uns das gewünschte Ergebnis zurückliefert.
1.3 Visualisierung
Im letzten Abschnitt haben wir die Koeffizienten der Polynome des kubischen Splines berechnet. Eine
weitere Stärke von MATLAB ist die Visualisierung. Deshalb wollen wir uns im folgenden noch eine weitere
Funktion ansehen, die den Spline auf den Bildschirm plottet.
1 function p l o t S p l i n e ( x , P )
2 hold on ;
3 g = 1 0 ;
4 for i =1: length ( x)−1
5 X = ( x ( i ) : ( x ( i +1)−x ( i ) ) / g : x ( i +1))−x ( i ) ;
6 Y = P( i , : ) ∗ [ ones ( 1 , length (X) ) ; X; X. ^ 2 ; X. ^ 3 ] ;
7 plot (X+x ( i ) ,Y) ;
8 end
9 hold o f f ;
10 end
Die Routine zeichnet die Funktion intervallweise, dazu verwenden wir eine for Schleife. Jedes Intervall
verschieben wir in den Ursprung und unterteilen es in g=10 Teile auf denen wir das Polynom auswerten
wollen. Die Koordinaten der Punkte speichern wir in X. Mit dem Befehl
Y= P(i,:)*[ones(1,length(X)); X; X.^2; X.^3];
berechnen wir das Skalarprodukt der i-ten Zeile der Matrix P mit dem Vektor der aus den Faktoren
(x − xi) k , k = 0, . . . , 3 besteht für jede Stelle x aus X.
Das eigentliche Plotten übernimmt der plot Befehl welcher in seiner einfachsten Version Vektoren mit
x− und y−Koordinaten der Punkte erwartet. Diese werden automatische mit Geradenstücken verbunden.
Normalerweise überschreibt MATLAB mit jedem plot Befehl die alte Graphik. Dies kann unterbunden
werden durch die Angabe von hold on;.
Der folgende Aufruf plottet den kubischen Spline und die Funktion sqrt(x) im Intervall [0, 1]:
>> x=0:0.1:1;
>> y=sqrt(x);
>> xx=0:0.01:1;
>> plotSpline(x, kspline(x,y)); hold on; plot(xx, sqrt(xx), ’r’);
Abbildung 1.3 zeigt das Ergebniss.
9

1.4 Erweiterung
Abbildung 1.1: Kubischer Spline der Wurzelfunktion
Eine weitere Qualität von MATLAB ist die einfache Möglichkeit vorhandene Algorithmen zu ersetzen.
Wir wollen dies an der Funktion kspline vorführen.
Bei Beispielen mit wenig Knotenpunkten arbeitet kspline recht schnell, wird die Zahl der Knotenpunkte
jedoch groß, wird die Funktion überproportional langsamer, auch der Speicherbedarf steigt stark
an. Die Erklärung hierfür ist, dass die Zeit für das Lösen des größer werdenden Gleichungssystems (1.1)
n Zeit (1000 Ausführungen) Speicher Zeit (A dünn) Speicher (A dünn)
100 0.79sec 93kB 0.87sec 17kB
200 2.57sec 342kB 1.33sec 34kB
400 32.00sec 1309kB 2.44sec 68kB
800 138.00sec 5118kB 4.85sec 137kB
1600 570.00sec 20237kB 9.64sec 275kB
Tabelle 1.1: Laufzeiten von kspline
nicht proportional mit der Anzahl der Unbekannten wächst. Die Matrix ist jedoch nur dünn besetzt (fast
alle Einträge sind Null) und hat eine sehr einfache Struktur (Tridiagonal). Diese Tatsache wollen wir im
Folgenden ausnutzen.
MATLAB unterstützt dünnbesetzte Matrizen, hierbei werden im wesentlichen nur die Einträge gespeichert,
die von Null verschieden sind. Zusätzlich erkennt der Gleichungssystemlöser die Bandstruktur der
Matrix und verwendet effiziente Algorithmen um das System zu lösen. Das einzige was wir machen müssen
um diese Funktionen zu verwenden ist die Matrix A dünn besetzt zu erzeugen, alles andere übernimmt
MATLAB für uns. Dies können wir machen, in dem wir z.B. die Zeile 9 durch die folgende ersetzen:
A = 2*speye(n) + spdiags([[lambda, 0]’, [mu, 0]’], [1, -1], n, n);
Die neue Version berechnet die Lösung der Interpolationsaufgabe in optimaler Komplexität: Bei Verdoppelung
der Punkte verdoppelt sich auch die Zeit (und Speicherbedarf) zum Berechnen des Splines (s.
Tabelle 1.1).
1.5 Zusammenfassung
Wir haben in diesem Kapitel gesehen wie man einen Algorithmus mit wenigen Zeilen (25) in MATLAB
implementiert und sich das Ergebnis grafisch darstellen lassen kann.
Zusätzlich konnten wir durch Ändern nur einer Zeile einen nicht optimale Methode in eine mit linearer
Laufzeit umwandeln. MATLAB übernimmt die komplette Arbeit und verwendet automatischen einen
optimalen Algorithmus um das Gleichungssystem zu lösen.
10

Kapitel 2
Vektoren und Matrizen
Wie schon in der Einleitung erwähnt, ist der Umgang mit Feldern eine Besonderheit von MATLAB.
Ein Verständnis dieser ist essentiell für die effektive Verwendung von MATLAB. Da aus mathematischer
Sicht insbesondere Vektoren und Matrizen interessant sind, werden wir uns in dieser Einführung auf diese
beschränken. Die Behandlung höherdimensionaler Felder erfolgt in vielen Fällen analog.
2.1 Matrizen erzeugen
Matrizen können auf mehrere Arten erzeugt werden. Viele Typen von Matrizen können direkt über eine
MATLAB Funktion generiert werden. Die Nullmatrix, die Einheitsmatrix und Einsmatrizen können über
die Funktionen zeros, eye und ones erzeugt werden. Alle haben die gleiche Syntax. Zum Beispiel erzeugt
zeros(m,n) oder zeros([m,n]) eine m×n Nullmatrix, während zeros(n) eine n×n Nullmatrix erzeugt.
>> zeros(2)
ans =
0 0
0 0
>> ones(2,3)
ans =
1 1 1
1 1 1
>> eye(3,2)
ans =
1 0
0 1
0 0
Zwei andere Matrizen erzeugende Funktionen sind rand und randn, die Matrizen mit Pseudozufallszahlen
als Einträgen generieren. Die Syntax ist die gleiche wie bei eye. Die Funktion rand erzeugt eine
Matrix mit Zahlen aus der Gleichverteilung über dem Einheitsintervall [0, 1]. 1 randn erzeugt eine Matrix
deren Einträge standardnormalverteilt sind. Ohne Argumente geben beide Funktionen eine einzelne
Zufallszahl zurück.
>> rand
ans =
0.9501
1 Für diese Verteilung ist der Anteil der Zahlen aus einem Intervall [a, b] mit 0 < a < b < 1 stets b − a.
11

and(3)
ans =
0.2311 0.8913 0.0185
0.6068 0.7621 0.8214
0.4860 0.4565 0.2835
Bei Experimenten mit Zufallszahlen ist es oft wichtig, die gleichen Zufallszahlen erneut zu erzeugen.
Die Zahlen, die von rand (bzw. randn) erzeugt werden hängen vom Zählerstand des Generators ab.
Dieser Zähler kann über den Befehl rand(’state’,j) (bzw. randn(’state’,j)) gesetzt werden, mit
einer nicht-negativen ganzen Zahl j. j=0 ist der Anfangszustand des Generators (diesen Zustand hat
der Generator, wenn MATLAB startet). Möchte man nicht bei jedem Start von MATLAB dieselben
Zufallszahlen zu bekommen, sollte der Generator durch den Befehl rand(’state’,sum(100*clock)) auf
einen von der Zeit abhängigen Zustand gesetzt werden. Die Periode von rand und randn, also die Anzahl
Terme die erzeugt werden, bevor sich Teilfolgen wiederholen, übersteigt 2 1492 ≈ 10 449 .
Mit der Funktion diag können Diagonalmatrizen angelegt werden. Für einen Vektor x erzeugt diag(x)
eine Diagonalmatrix mit der Diagonale x.
>> diag([1 2 3])
ans =
1 0 0
0 2 0
0 0 3
Allgemeiner legt diag(x,k) x auf die k-te Diagonale, wobei k > 0 Diagonalen über der Hauptdiagonalen
beschreibt, und k < 0 die darunter (k = 0 bezeichnet die Hauptdiagonale).
>> diag([1 2],1)
ans =
0 1 0
0 0 2
0 0 0
>> diag([3 4],-2)
ans =
0 0 0 0
0 0 0 0
3 0 0 0
0 4 0 0
Matrizen können explizit über die Klammernotation (square bracket notation) erzeugt werden. Zum
Beispiel kann eine 3x3-Matrix mit den ersten neun Primzahlen mit folgendem Befehl erzeugt werden:
>> A = [2 3 5
7 11 13
17 19 23]
A =
2 3 5
7 11 13
17 19 23
Das Ende einer Zeile kann über ein Semikolon anstatt eines Zeilenumbruchs angegeben werden. Ein
kürzere Variante des letzten Beispiels ist also:
>> A = [2 3 5; 7 11 13; 17 19 23]
12

Innerhalb einer Zeile können einzelne Elemente über ein Leerzeichen oder Komma getrennt werden.
In ersterem Fall sollte beachtet werden, dass bei Angabe von Vorzeichen für die einzelnen Einträge
kein Leerzeichen zwischen Vorzeichen und Element gelassen werden darf. MATLAB interpretiert das
Vorzeichen sonst als Plus oder Minus Operator.
>> v = [-1 2 -3 4]
v =
-1 2 -3 4
>> w = [-1,2,-3,4]
w =
-1 2 -3 4
>> x = [-1 2 - 3 4]
x =
-1 -1 4
Häufig sehr praktisch ist das Erzeugen von Matrizen durch Angabe von Blöcken, anstatt der einzelnen
Elemente. Sei z.B. B=[1 2; 3 4]:
>> C = [B zeros(2); ones(2) eye(2)]
C =
1 2 0 0
3 4 0 0
1 1 1 0
1 1 0 1
Blockdiagonalmatrizen können noch einfacher direkt über die Funktion blkdiag erzeugt werden.
>> A = blkdiag(B,ones(2))
A =
1 2 0 0
3 4 0 0
0 0 1 1
0 0 1 1
Für ”getäfelte” Blockmatrizen eignet sich repmat: repmat(A,m,n) erzeugt eine Block-m × n-Matrix, in
der jeder Block eine Kopie von A ist. Wird n weggelassen, wird der Wert standardmäßig auf m gesetzt.
>> B=[1,2;3,4];
>> A = repmat(B,2)
A =
1 2 1 2
3 4 3 4
1 2 1 2
3 4 3 4
2.1.1 Spezielle Matrizen
MATLAB verfügt über Funktionen um ganz spezielle Matrizen zu erzeugen. Ein Beispiel hierfür sind die
Hilbertmatrizen, deren Elemente aij den Wert 1/(i + j − 1) haben. Die Matrix wird durch den Befehl
hilb erzeugt, und ihre Inverse (die nur ganzzahlige Komponenten hat!) über invhilb.
Quadratische n × n Matrizen die nur aus den Zahlen 1, . . . , n 2 bestehen, deren Zeilen- und Spaltensummen
und Summe der Einträge der Diagonalen gleich ist nennt man magische Quadrate. Diese können
mit MATLAB durch die Funktion magic erzeugt werden.
13

magic(3)
ans =
8 1 6
3 5 7
4 9 2
Über fünfzig weitere spezielle und berühmte Matrizen können mit dem Befehl gallery erzeugt werden,
diese sind teilweise dünn besetzt. Mehr über diese speziellen Matrizen erfährt man in der Hilfe.
2.1.2 Doppelpunkt Operator
Der Doppelpunkt Operator ist einer der wichtigsten Operatoren in MATLAB und findet in vielen Fällen
Verwendung. Mit seiner Hilfe können spezielle Zeilenvektoren erzeugt werden, die z.B. bei der Indizierung
in for Schleifen oder beim Plotten verwendet werden. Dabei wird ausgehend von einer Zahl solange eine
Einheit addiert und in dem Vektor gespeichert, bis ein vorgegebenes Ende erreicht oder überschritten
wurde. Die allgemeine Syntax ist
: oder ::.
Ein paar Beispiele sollte die Verwendung deutlich machen:
>> j=1:5
j =
1 2 3 4 5
>> X=1.2:0.2:2
X =
1.2000 1.4000 1.6000 1.8000 2.0000
>> X=1:-0.3:0
X =
1.0000 0.7000 0.4000 0.1000
Dem Doppelpunkt Operator verwandt ist die Funktion linspace, die als Eingabe neben Start und
Ende die Anzahl der zu erzeugenden Punkte verlangt anstatt des Abstandes. linspace(a,b,n) erzeugt
n Punkte gleichen Abstands zwischen a und b. Der Standardwert für n ist 100.
>> linspace(-1,1,9)
ans =
Columns 1 through 6
-1.0000 -0.7500 -0.5000 -0.2500 0 0.2500
Columns 7 through 9
0.5000 0.7500 1.0000
2.2 Indizierung und Doppelpunktnotation
Die Indizierung von Feldern erfolgt in MATLAB durch runde Klammern und startet wie bei Fortran
beim Index 1. Bei Matrizen steht der erste Index für die Zeilen-, der zweite für die Spaltennummer des
Elements.
>> A=rand(2,2)
14

A =
0.6557 0.8491
0.0357 0.9340
>> A(1,1)
ans =
0.6557
>> A(2,1)
ans =
0.0357
Es gibt bei MATLAB keine nicht positiven Indices, der Versuch wird durch eine Fehlermeldung bestraft:
>> A(0,0)
??? Attempted to access A(0,0); index must be a positive integer or logical.
Ein Vorteil von MATLAB gegenüber anderen Programmiersprachen ist, dass nicht nur auf die einzelnen
Elemente eines Feldes zugegriffen werden kann, sondern auf beliebige Teilblöcke. Dafür ersetzt
man einfach beim Indizieren die Zahlen durch Vektoren. Sei A eine n × m-Matrix und r und c Vektoren
mit positiven ganzzahligen Elementen kleiner gleich n (bzw. m). Dann ist B=A(r,c) eine Matrix mit
Einträgen bij =A(r(i),c(j)).
>> A=[1,2,3;4,5,6;7,8,9]
A =
1 2 3
4 5 6
7 8 9
>> A([1,2],3)
ans =
3
6
>> A([2,3],[2,3])
ans =
5 6
8 9
Besonders häufig wird in diesen Fällen der Doppelpunktoperator verwendet. Die Teilmatrix bestehend
aus der Schnittmenge der Zeilen p bis q und den Spalten r bis s wird mit A(p:q,r:s) zurückgegeben. Ein
Sonderfall ist ein einzelner Doppelpunkt, dieser wählt sämtliche Zeilen oder Spalten; A(:,j) bezeichnet
also die j-te Spalte, und A(i,:) die i-te Zeile von A. Das Schlüsselwort end steht für den letzten Index in
der angegebenen Dimension; A(end,:) bezeichnet also die letzte Zeile von A.
>> A(1:3,2:end)
ans =
2 3
5 6
8 9
>> A(1,:)
ans =
15

1 2 3
>> A(:,end)
ans =
3
6
9
MATLAB speichert alle Felder intern als Spaltenvektor, Matrizen spaltenweise von der ersten zur
letzten Spalte. Auf diese Repräsentation kann durch Angabe nur eines Indizes zugegriffen werden, dies
wird häufig lineares Indizieren genannt.
>> A(:)
ans =
1
4
7
2
5
8
3
6
9
>> A(4)
ans =
2
Wird A(:) auf der linken Seite einer Zuweisung benutzt, so wird damit A gefüllt, unter Beibehaltung
der Struktur von A. Mit dieser Notation ergibt sich eine Möglichkeit auf folgende Weise eine 3×3 - Matrix
der ersten 9 Primzahlen zu erzeugen:
>> A = zeros(3); A(:) = primes(23); A = A’
A =
2 3 5
7 11 13
17 19 23
Die Funktion primes erzeugt einen Vektor von Primzahlen, die kleiner oder gleich dem Eingabeargument
sind. Die Transposition A = A’ ist nötig um die Primzahlen entlang der Zeilen anstatt entlang der
Spalten anzuordnen.
Eine weitere Funktion die beim Indizieren hilfreich ist, ist sub2ind. Diese berechnet aus Matrixindizes
lineare Indizes. Hiermit können wir z.B. die Diagonale der obigen Matrix A mit 1 überschreiben.
>> A(sub2ind(size(A), 1:3, 1:3))=1
A =
1 3 5
7 1 13
17 19 1
2.3 Operatoren und Funktionen
Um ein Feld zu transponieren stellt MATLAB die Operatoren ’ und .’ zur Verfügung. Die Operatoren
unterscheiden sich, wenn die Einträge des Feldes komplex sind, ’ erzeugt die adjungierte Matrix A ∗ , .’
die Transponierte A T .
16

A=[1+i , 2-i; 1 , 2]
A =
1.0000 + 1.0000i 2.0000 - 1.0000i
1.0000 2.0000
>> A’
ans =
1.0000 - 1.0000i 1.0000
2.0000 + 1.0000i 2.0000
>> A.’
ans =
1.0000 + 1.0000i 1.0000
2.0000 - 1.0000i 2.0000
2.3.1 Rechenoperatoren
MATLAB unterstützt das Rechnen mit Vektoren und Matrizen. So können zwei Felder gleicher Dimensionen
einfach durch + addiert und mit - subtrahiert werden:
>> x=1:3;
>> y=2:4;
>> x+y
ans =
3 5 7
>> eye(2)-ones(2)
ans =
0 -1
-1 0
MATLAB interpretiert den Multiplikationsoperator * als Matrixprodukt oder als Multiplikation mit
einem Skalar. Bei ersterem muss die Anzahl der Spalten des ersten Arguments gleich der Anzahl der
Zeilen des zweiten Argumentes sein. Daneben gibt es noch den elementweisen Multiplikationsoperator
.*.
>> x=1:3;
>> y=2:4;
>> x*y
??? Error using ==> mtimes
Inner matrix dimensions must agree.
>> x*y’
ans =
20
>> x.*y
ans =
2 6 12
>> A=[1,2,3;4,5,6;7,8,9];
>> A*y
17

ans =
20
47
74
>> 2*A
ans =
2 4 6
8 10 12
14 16 18
Auch das Potenzieren ^ wird im Matrixprodukt Sinn interpretiert, analog zur Multiplikation gibt es auch
die „gepunktete“ Version .^.
Die Division gibt es in zwei Ausführungen: den Slash / und den Backslash \. Beide entsprechem dem
(ggf. approximativen) Lösen eines linearen Gleichungssystems. B/A steht ungefähr für BA −1 , A\B für
A −1 B). Mit diesen Operatoren befassen wir uns ausführlich in Abschnitt 5.2.
>> A=hilb(2);
>> b=[1;2]
b =
1
2
>> A\b
ans =
-8
18
>> invhilb(2)*b
ans =
-8
18
Natürlich gibt es auch wieder das elementweise dividieren ./, dieses muss auch eingesetzt werden, wenn
ein Skalar durch einen Vektor geteilt wird.
>> x=1:3
>> 3/x
??? Error using ==> mrdivide
Matrix dimensions must agree.
>> 3./x
ans =
3.0000 1.5000 1.0000
>> x./x
ans =
1 1 1
2.3.2 Basisfunktionen
Um Eigenschaften wie die Länge oder Dimensionen von Feldern abzufragen gibt es in MATLAB eine
Hand voll Funktionen:
18

length Gibt die Länge eines Vektors zurück, bei einer Matrix wird die größere der beiden Dimensionen
zurückgegeben.
size Gibt die Dimensionen einer Matrix zurück.
numel Gibt die Anzahl der Elemente einer Matrix zurück, numel(A)==prod(size(A))==length(A(:))
>> B=[1,2;2,3;4,5]
B =
1 2
2 3
4 5
>> length(B)
ans =
3
>> size(B)
ans =
3 2
>> numel(B)
ans =
6
2.3.3 Funktionen
MATLAB verfügt über unzählige Funktionen die Vektoren und Matrizen als Eingabe erwarten. Grundsätzlich
verändert eine Funktion in MATLAB kein Eingabeargument. 2 Viele dieser Methoden kann man
einer von drei Gruppen zuordnen:
• Skalare Funktionen
• Vektorfunktionen
• Matrixfunktionen
Skalare Funktionen sind solche, die komponentenweise wirken. Beispiele sind sin, cos, exp und
factorial (Fakultät). Übergibt man diesen Funktionen ein mehrdimensionales Feld, hat die Rückgabe
die gleiche Dimensionen wie das Eingabeargument und die Funktion wurde auf jeden Eintrag des
Feldes angewendet.
>> x=linspace(-pi/2,pi/2,5)
x =
-1.5708 -0.7854 0 0.7854 1.5708
>> sin(x)
ans =
-1.0000 -0.7071 0 0.7071 1.0000
>> A=magic(3);
>> factorial(A)
ans =
2 Eingabeargumente werden als Wert und nicht als Referenz übergeben.
19

40320 1 720
6 120 5040
24 362880 2
Vektorwertige Funktionen operieren auf Vektoren und geben ein Skalar oder einen Vektor zurück.
Beispiele sind max, sum, prod mit skalarem Rückgabewert, diff (Differenz jeweils aufeinander folgender
Elemente), cumsum oder sort geben einen Vektor zurück. Übergibt man diesem Typ von Funktion eine
Matrix, wird die Funktion auf jede Spalte angewendet und die Rückgabe wieder in eine Spalte geschrieben.
>> x=1:4;
>> sum(x)
ans =
10
>> max(x)
ans =
4
>> diff(x)
ans =
1 1 1
>> A=magic(3);
>> sum(A)
ans =
15 15 15
>> cumsum(A)
ans =
8 1 6
11 6 13
15 15 15
Viele vektorwertige Funktionen unterstützen die Übergabe eines zweiten Parameters dim, der die Dimension
(1=Spalten, 2=Zeilen) angibt, über welche die Funktion ausgeführt werden soll. Damit ist es also
z.B. auch einfach möglich die Summe der Zeilen von A zu berechnen:
>> sum(A,2)
ans =
15
15
15
Möchte man diese Funktion nicht auf die Spalten einer Matrix A sondern auf die ganze Matrix -als
Vektor aufgefasst- anwenden, übergibt man A(:) als Eingabeargument (vgl. 2.2).
>> sum(A(:))
ans =
45
Matrixfunktionen erwarten als Eingabe eine Matrix. Beispiele sind norm, chol, triu und tril. Die
letzten beiden Funktionen extrahieren aus einer gegebenen Matrix eine obere, bzw. untere Dreiecksmatritzen.
Allgemein gibt tril(A,k) (bzw. triu(A,k)) die Elemente auf und unter (bzw. ober) der k-ten
Diagonale zurück.
20

A = [2 3 5; 7 11 13; 17 19 23]
A =
2 3 5
7 11 13
17 19 23
>> tril(A)
ans =
2 0 0
7 11 0
17 19 23
>> triu(A,1)
ans =
0 3 5
0 0 13
0 0 0
2.4 Matrizen manipulieren
Es gibt mehrere Befehle für die Manipulation von Matrizen. Die Funktion reshape ändert die Dimensionen
einer Matrix: reshape(A,m,n) erzeugt eine m × n Matrix, deren Elemente spaltenweise aus A
entnommen werden.
>> A = [1 4 9; 16 25 36], B = reshape(A,3,2)
A =
B =
1 4 9
16 25 36
1 25
16 9
4 36
Die Notation [] steht für eine leere 0 × 0-Matrix. Weist man einer Zeile oder Spalte einer Matrix den
Wert [] zu, so wird sie aus der Matrix gelöscht.
>> A=magic(3)
A =
8 1 6
3 5 7
4 9 2
>> A(2,:)=[]
A =
8 1 6
4 9 2
In diesem Beispiel würde der gleiche Effekt durch A = A([1 3],:) erzielt werden. Die leere Matrix
ist auch als Platzhalter in Argumentlisten nützlich.
An einen vorhandenen Vektor können einfach weitere Elemente angehängt werden, indem man einem
Index der größer als die Länge des Vektors ist, einen Wert zuweist. Der Vektor wird daraufhin automatisch
bis zu dem entsprechenden Index verlängert und mit Nullen gefüllt.
21

x=1:3;
>> x(6)=9
x =
1 2 3 0 0 9
Auf dieselbe Weise können neue Zeilen und Spalten an eine Matrix angehängt werden:
>> A=eye(2)
A =
1 0
0 1
>> A(3,:)=[1,1]
A =
1 0
0 1
1 1
>> A(:,3)=2
A =
1 0 2
0 1 2
1 1 2
>> A=eye(2)
A =
1 0
0 1
>> A(3,3)=2
A =
1 0 0
0 1 0
0 0 2
22

Kapitel 3
Operatoren und Flusskontrolle
3.1 Relationale Operatoren
Die relationalen Operatoren von MATLAB sind
== gleich
~= ungleich
< weniger als
> größer als
= größer oder gleich
Tabelle 3.1: Die relationalen Operatoren in MATLAB
Beachten Sie, dass in MATLAB ein einzelnes Gleichheitszeichen = eine Zuweisung angibt und nie auf
Gleichheit testet. Vergleiche zwischen Skalaren erzeugen logisch 1 wenn die Relation wahr und logisch
0 wenn sie falsch ist. MATLAB verwenden hier intern keine doubles sondern einen anderen Datentyp
(logical), dies sollte aber in den wenigsten Fällen zu Problemen führen.
Vergleiche sind auch zwischen Matrizen gleicher Dimension definiert und zwischen Matrizen und Skalaren,
deren Ergebnis in beiden Fällen eine Matrix mit Nullen und Einsen ist. Für Matrix-Matrix Vergleiche
werden die entsprechenden Paare von Elementen verglichen, während für Matrix-Skalar Vergleiche der
Skalar mit jedem Matrixelement verglichen wird.
>> A = [1 2; 3 4]; B = 2*ones(2);
>> A==B
ans =
0 1
0 0
>> A>2
ans =
0 0
1 1
Um zu testen ob zwei Matrizen A und B gleich sind, kann der Ausdruck isequal(A,B) verwendet
werden. Die Funktion isequal is eine der vielen nützlichen logischen Funktionen, deren Namen mit is
beginnt. Für eine Liste aller dieser Funktionen rufen sie in MATLAB doc is auf. Die Funktion isnan
ist besonders wichtig, da der Test x == NaN immer das Ergebnis 0 (falsch) liefert, selbst wenn x = NaN!
(Ein NaN ist gerade so definiert, dass er zu allem ungleich und ungeordnet ist).
3.2 Logische Operatoren
Die logischen Operatoren von MATLAB sind
23

& logisches und
| logisches oder
∼ logisches nicht
xor logisches exklusives oder
all wahr wenn alle Elemente eines Vektors von
Null verschieden sind
any wahr wenn wenigstens ein Element eines Vektors
von Null verschieden ist
Tabelle 3.2: Die logischen Operatoren in MATLAB
Wie die relationalen Operatoren produzieren &,| und ∼ Matrizen von Nullen und Einsen, falls eines
der Argumente eine Matrix ist. Die Funktion all gibt, wenn sie auf einen Vektor angewendet wird, 1
zurück wenn alle Elemente des Vektors verschieden von 0 sind, und 0 sonst. Die any Funktion ist ebenfalls
so definiert, wobei ’irgendeiner’ hier ’alle’ ersetzt. Beispiele:
>> x = [-1 1 1]; y = [1 2 -3];
>> x>0 & y>0
ans =
0 1 0
>> x>0 | y>0
ans =
1 1 1
>> xor(x>0,y>0)
ans =
1 0 1
>> any(x>0)
ans =
1
>> all(x>0)
ans =
0
Beachte, dass xor als Funktion xor(a,b) aufgerufen werden muss. Die Operatoren and, or, not und
die relationalen Operatoren können ebenfalls in funktionaler Form aufgerufen werden, and(a,b) ...(mehr
dazu unter help ops).
Die Funktionen all und any sind Vektorfunktionen (vgl. Abschnitt 2.3.3), deshalb gibt all auf Matrizen
angewandt einen Zeilenvektor zurück der die Ergebnisse von all angewendet auf die Spaltenvektoren
enthält. Mit all(A(:)==B(:)) können die beiden Matrizen A und B auf Gleichheit getestet werden.
3.2.1 Indizierung mit logischen Feldern
Die Rückgabewerte von MATLABs relationalen und logischen Operatoren sind Felder bestehend aus
Nullen und Einsen. Diese sind Beispiele für logische Felder. Sie können auch per Hand erzeugt werden,
indem man den Befehl logical auf ein reelles Feld anwendet. Hierbei werden alle Einträge ungleich 0 zu
logisch 1, alle Einträge gleich 0 zu logisch 0 konvertiert.
>> y=[1 0.2 0 -3 0]
y =
24

1.0000 0.2000 0 -3.0000 0
>> i1 = logical(y)
i1 =
1 1 0 1 0
>> i2 = (y~=0)
i2 =
1 1 0 1 0
Logische Felder können zur Indizierung verwendet werden, hierbei muss das zu indizierende Feld die
gleichen Dimensionen wie das logische Feld haben. Das Ergebnis sind alle Einträge bei denen logisch 1
steht als Spaltenvektor.
>> i3 = [1 1 0 1 0]
i3 =
1 1 0 1 0
>> whos
Name Size Bytes Class
i1 1x5 40 double array (logical)
i2 1x5 40 double array (logical)
i3 1x5 40 double array
y 1x5 40 double array
Grand total is 20 elements using 160 bytes
>> y(i1)
ans =
1.0000 0.2000 -3.0000
>> y(i2)
ans =
1.0000 0.2000 -3.0000
>> isequal(i2,i3)
ans =
1
>> y(i3) ??? Index into matrix is negative or zero. See release
notes on changes to logical indices.
Merke, dass obwohl i2 die gleichen Elemente wie i3 hat (und in MATLAB auch als identisch angesehen
wird), nur i2 zur Indizierung verwendet werden kann.
Logische Indizierung wird meistens in Verbindung mit relationalen Operatoren angewandt, z.B. um
die negativen Einträge einer Matrix auf Null zu setzen:
>> A=rand(3)-0.5*ones(3)
A =
0.4649 0.4572 -0.3581
-0.3424 -0.0146 -0.0782
0.4706 0.3003 0.4157
25

A(A> x = [-3 1 0 -inf 0];
>> f=find(x)
f =
1 2 4
Wenn find auf eine Matrix angewendet wird, bezieht sich der Indexvektor auf A als Vektor seiner
Spaltenvektoren (also A(:)), und dieser Vektor kann wiederum verwendet werden, um Elemente in A
anzusprechen. Im folgenden Beispiel benutzen wir find um alle Elemente von A auf 0 zu setzen, die
kleiner sind als die entsprechenden Elemente von B:
>> A=[4 2 16; 12 4 3], B = [12 3 1; 10 -1 7]
A =
B =
4 2 16
12 4 3
12 3 1
10 -1 7
>> f = find(A> A(f) = 0
A =
0 0 16
12 4 0
>> A=[4 2 16; 12 4 3];
>> A(A

if expression
statements
end
statements werden ausgeführt, wenn die Realteile der Elemente von expression alle verschieden von 0
sind. Der folgende Code ersetzt zum Beispiel x und y wenn x größer ist als y:
if x > y
temp = y;
y = x;
x = temp;
end
Folgen auf einen if-Befehl auf der gleichen Zeile weitere Befehle, so müssen diese durch ein Komma
getrennt werden, um das if-Kommando vom nächsten Befehl zu trennen.
>> if x > 0, sqrt(x);end
Befehle die nur ausgeführt werden sollen, wenn expression falsch ist, können nach else eingefügt
werden.
>> e = exp(1);
>> if 2^e > e^2
disp(’2^e is bigger’)
else
disp(’e^2 is bigger’)
end
Schließlich kann mit elseif ein weiterer Test hinzugefügt werden mit (beachte, dass zwischen else
und if kein Leerzeichen stehen darf):
if isnan(x)
disp(’Not a Number’)
elseif isinf(x)
disp(’Plus or minus infinity’)
else
disp(’A ’’regular’’ floating point number’)
end
Bei einer if-Abfrage der Form if Bedingung 1 & Bedingung 2 wird Bedingung 2 nicht ausgewertet,
wenn Bedingung 1 falsch ist (dies wird ”early return” if Auswertung genannt). Dies ist nützlich, wenn
die Auswertung von Bedingung 2 ansonsten einen Fehler produzieren könnte, zum Beispiel durch einen
Index außerhalb des zulässigen Bereichs oder eine nicht definierte Variable.
Die for-Schleife ist einerseits eine der wichtigsten Strukturen in MATLAB, andererseits vermeiden
viele Programmierer, die kurzen und schnellen Code produzieren wollen, dessen Verwendung. Die Syntax
lautet:
for variable = ausdruck
statements
end
Normalerweise ist ausdruck ein Vektor der Form i:s:j. Die Befehle werden für jedes Element von
ausdruck ausgeführt, wobei variable dem entsprechenden Element von ausdruck zugeordnet ist. Zum
Beispiel wird die Summe der ersten 25 Elemente der harmonischen Folge 1/i erzeugt durch:
>> s = 0;
>> for i=1:25, s=s+1/i;end,s
s =
3.8160
Eine weitere Möglichkeit um ausdruck zu definieren ist, die Klammernotation zu verwenden.
27

for x = [pi/6 pi/4 pi/3], disp([x,sin(x)]), end
0.5236 0.5000
0.7854 0.7071
1.0472 0.8660
Mehrere for-Schleifen können verschachtelt werden. In diesem Fall hilft einrücken, um die Lesbarkeit
des Codes zu erhöhen. Der folgende Code bildet die symmetrische 5x5-Matrix A = (aij) mit aij = i/j
für j >= i:
>> n = 5; A = eye(n);
>> for j=2:n
for i = 1:j-1
A(i,j) = i/j;
A(j,i) = i/j;
end
end
Der ausdruck in der for-Schleife kann eine Matrix sein, in diesem Fall wird variable der Spaltenvektor
zugewiesen, vom Ersten zum Letzten. Zum Beispiel, um x in der Reihenfolge auf jeden Einheitsvektor
zu setzen, kann man for x = eye(n),...,end schreiben.
Die while-Schleife hat die Form
while ausdruck
statements
end
Die Befehle werden ausgeführt, so lange ausdruck wahr ist. Das folgende Beispiel nähert die kleinste
von Null verschiedene Gleitkommazahl an:
>> x=1; while x>0, xmin = x; x = x/2; end, xmin
xmin =
4.9407e-324
Eine while-Schleife kann mit dem Befehl break beendet werden, der die Kontrolle an den ersten Befehl
nach dem entsprechenden end zurückgibt. Eine unendliche Schleife kann mit while 1, ..., end erzeugt
werden. Dies kann nützlich sein, wenn es ungünstig ist, den Abbruchtest an den Anfang der Schleife zu
setzen. (Merke, dass MATLAB im Gegensatz zu manch anderen Sprachen keine ”repeat-until” Schleife
hat.)
Das vorige Beispiel lässt sich damit auch folgendermaßen notieren:
x = 1;
while 1
xmin = x;
x = x/2;
if x == 0, break, end
end
xmin
Der Befehl break kann auch verwendet werden, um eine for-Schleife zu verlassen. In einer verschachtelten
Schleife führt ein break zum Verlassen der Schleife auf der nächsthöheren Ebene. Der Befehl
continue setzt die Ausführung sofort in der nächsten Iteration der for- oder while-Schleife fort, ohne
die verbleibenden Befehle in der Schleife auszuführen.
for i=1:10
if i < 5, continue, end
disp(i)
end
28

In komplexeren Schleifen kann continue verwendet werden um umfangreiche if-Abfragen zu vermeiden.
Zuletzt bleibt noch der Kontrollbefehl switch. Er besteht aus ”switch Ausdruck”, gefolgt von einer
Liste von
”case Ausdruck Befehl”, die optional mit
”otherwise Ausdruck” enden und mit einem end beendet werden. Der Ausdruck bei switch wird
ausgewertet und die Befehle nach dem ersten passenden case Ausdruck werden ausgeführt. Falls keiner
der Fälle passt, werden die Befehle nach otherwise ausgeführt. Das folgende Beispiel wertet die p-Norm
eines Vektors x aus (also norm(x,p)):
switch p
case 1
y = sum(abs(x));
case 2
y = sqrt(x’*x);
case inf
y = max(abs(x));
otherwise
error(’p must be 1, 2 or inf.’)
end
Der Ausdruck nach case kann eine Liste von Werten sein, die in geschweiften Klammern eingeschlossen
ist (ein Cell-Array). In diesem Fall kann der switch-Ausdruck zu jedem Element der Liste passen.
x = input(’Enter a real number: ’); switch x
case {inf,-inf}
disp(’Plus or minus infinity’)
case 0
disp(’Zero’)
otherwise
disp(’Nonzero and finite’)
end
C Programmierer seien darauf hingewiesen, dass das switch-Konstrukt von MATLAB sich anders
verhält als das von C: Sobald ein MATLAB case Ausdruck zur Variable passt und die Befehle ausgeführt
wurden, wird die Kontrolle an den ersten Befehl nach dem switch-Block übergeben, ohne dass weitere
break Befehle nötig sind.
29

Kapitel 4
M-Dateien
Viele nützliche Berechnungen lassen sich über die Kommandozeile von MATLAB durchführen. Nichtsdestotrotz
wird man früher oder später M-Dateien schreiben müssen. Diese sind das Pendant zu Programmen,
Funktionen, Subroutinen und Prozeduren in anderen Programmiersprachen. Fügt man eine Folge
von Befehlen zu einer M-Datei zusammen, ergeben sich vielfältige Möglichkeiten, wie etwa
• an einem Algorithmus herumzuexperimentieren indem man eine Datei bearbeitet, anstatt eine lange
Liste von Befehlen wieder und wieder zu tippen
• einen dauerhaften Beleg für ein numerisches Experiment schaffen
• nützliche Funktionen aufzubauen die zu einem späteren Zeitpunkt erneut verwendet werden können
• M-Dateien mit anderen Kollegen austauschen
Im Internet findet man eine Vielzahl nützlicher M-Dateien, die von Benutzern geschrieben wurden.
Eine M-Datei ist eine Textdatei mit der Dateiendung .m, die MATLAB Befehle enthält. Es gibt zwei
Arten:
• Skriptdateien (oder Kommandodateien) haben keine Ein- oder Ausgabeargumente und operieren
auf Variablen im Workspace.
• Funktionsdateien enthalten eine function Definitionszeile und akzeptieren Eingabeargumente
und geben Ausgabeargumente zurück, und ihre internen Variable sind lokal auf die Funktion beschränkt
(sofern sie nicht als global deklariert wurden).
4.1 Skriptdateien
Ein Skript erlaubt es, eine Folge von Befehlen die wiederholt verwendet werden sollen oder in Zukunft
noch gebraucht werden. Ein Beispiel für ein Skript ist folgender „Sinus random plotter“:
%randSin
%Plottet die Sinusfunktion nur ausgewertet an n+2 zufälligen Stellen
n=10;
x=sort([0,rand(1,n)*2*pi,2*pi]);
y=sin(x);
plot(x,y);
Die ersten beiden Zeilen des Skripts beginnen mit dem % Symbol und sind daher Kommentare.
Sobald MATLAB auf ein % trifft ignoriert es den Rest der Zeile. Dies erlaubt das Einfügen von Text,
der das Skript für Menschen leichter verständlich macht. Angenommen dieses Skript wurde unter dem
Namen randSin.m gespeichert, dann ist die Eingabe von randSin an der Kommandozeile gleichwertig
zur Eingabe der einzelnen Zeilen des Skripts.
30

4.2 Funktionsdateien
Selbst geschriebene Funktionsdateien erweitern den Umfang von MATLAB. Sie werden auf die gleiche
Weise verwendet wie die bereits existierenden MATLAB Funktionen wie sin, eye, size usw.
Hier ist ein Beispiel für eine Funktionsdatei:
function y = maxentry(A)
%MAXENTRY Largest absolute value of matrix entries.
% MAXENTRY(A) is the maximum of the absolute values
% of the entries of A.
y = max(abs(A(:)));
Dieses Beispiel präsentiert mehrere Features. Die erste Zeile fängt mit dem Schlüsselwort function an,
gefolgt vom Ausgabeargument y, und dem Gleichheitszeichen. Rechts von = kommt der Funktionsname
maxentry, gefolgt vom Eingabeargument A in Klammern. (Im Allgemeinen kann es beliebig viele Einund
Ausgabeargumente geben.) Der Funktionsname muss der gleiche sein wie der Name der M-Datei, die
die Funktion enthält - in diesem Fall muss die Datei maxentry heißen.
Die zweite Zeile der Funktionsdatei heißt H1-Zeile (help 1). Sie sollte eine Kommentarzeile sein: Eine
Zeile die mit einem %-Zeichen beginnt und danach ohne Leerzeichen dem Funktionsname in Großbuchstaben
– gefolgt von einem oder mehr Leerzeichen und dann einer kurzen Beschreibung. Die Beschreibung
sollte mit einem Großbuchstaben anfangen und mit einem Punkt enden und dabei auf die Worte „der“,
„die“, „das“ und „ein“, „eine“ verzichten. Alle Kommandozeilen – beginnend mit der ersten bis zur ersten
Nichtkommentarzeile (in der Regel eine Leerzeile, um die Lesbarkeit des Codes zu erhöhen) – werden
beim Aufruf von help function_name angezeigt. Darum sollten diese Zeilen die Funktion und ihre Argumente
beschreiben. Funktionenname und -argumente groß zu schreiben ist eine allgemein akzeptierte
Konvention. Im Falle von maxentry sieht die Ausgabe folgendermaßen aus
>> help maxentry
MAXENTRY Largest absolute value of matrix entries.
MAXENTRY(A) is the maximum of the absolute values
of the entries of A.
An dieser Stelle sei noch einmal mit Nachdruck darauf hingewiesen, dass es sich lohnt, alle Funktionsdateien
auf diese Art und Weise zu dokumentieren. Oft ist es nützlich, in Kommentaren anzugeben,
wann die Funktion zuerst geschrieben wurde, und ob Veränderungen hinzugefügt wurden.
Der Befehl help funktioniert auf ähnliche Art und Weise mit Skriptdateien, er zeigt die Anfangsfolge
an Kommentaren an.
Die Funktion maxentry wird wie jede andere MATLAB Funktion aufgerufen:
>> maxentry(1:10)
ans =
10
>> maxentry(magic(4))
ans =
16
4.3 M-Dateien bearbeiten
Es gibt zwei Möglichkeiten, M-Dateien zu bearbeiten. Jeder beliebige ASCII-Editor kann verwendet
werden (benutzt man ein Textverarbeitungsprogramm, so ist sicherzustellen, dass das Programm die
Datei auch wieder im ASCII-Format speichert). Oder man benutzt den internen Editor/Debugger von
MATLAB. Dieser Editor verfügt über Funktionen, die das Bearbeiten von M-Dateien unterstützen. Zum
Beispiel werden Schleifen und if-Abfragen automatisch eingerückt, es gibt mehrfarbiges Syntax Highlighting,
und einen automatischen Vergleich von Klammern und Doppelpunkten. Diese und andere Features
können im Menü Tools-Optionen deaktiviert oder modifiziert werden.
31

4.4 Mit M-Dateien und der Pfadvariable von MATLAB arbeiten
Viele MATLAB-Funktionen sind M-Dateien die auf der Festplatte gespeichert werden, während andere in
den MATLAB-Interpreter integriert sind. Der MATLAB Suchpfad ist eine Liste von Ordnern, die angibt,
wo MATLAB nach M-Dateien sucht. Eine M-Datei ist nur dann verfügbar, wenn sie sich im Suchpfad
befindet. Geben Sie path ein, um den aktuellen Suchpfad angezeigt zu bekommen. Die Pfadvariable kann
über path gesetzt werden, und über addpath können Befehle hinzugefügt werden. Eine weitere Möglichkeit
zur Bearbeitung des Suchpfads ist der Pfad-Browser, der über Datei-Pfad Einstellen oder die Eingabe
von pathtool aufgerufen wird.
Der Suchpfad kann mit mehreren Befehlen durchsucht werden. Der Befehl what listet alle MATLAB
Dateien im aktuellen Verzeichnis auf;
what verzeichnisname listet alle MATLAB-Dateien im Ordner
verzeichnisname im Pfad. Der Befehl lookfor keyword durchsucht den Pfad nach M-Dateien, die
keyword in ihrer H1 Zeile enthalten (die erste Zeile des Hilfetextes). Um alle Kommentarzeilen, die bei
Eingabe von help angezeigt werden, zu durchsuchen, kann man lookfor mit dem Parameter -all aufrufen:
lookfor keyword -all
Manche MATLAB-Funktionen benutzen Kommentarzeilen nach dem ersten Block von Kommentaren,
um weitere Informationen zu liefern, wie etwa bibliographische Angaben (zum Beispiel fminsearch).
Auf diese Information kann über type zugegriffen werden. Sie wird beim Aufruf von help nicht angezeigt.
Die Eingabe von which foo zeigt den Pfad der Funktion foo an, oder gibt an, dass die Funktion builtin
ist, oder nicht vorhanden. Diese Funktion ist nützlich falls man wissen möchte, in welchem Ordner
sich eine bestimmte Funktion befindet. Falls mehr als eine Funktion mit dem Namen foo im Suchpfad
existiert, zeigt which foo -all alle Funktionen an.
Ein Skript, welches sich nicht auf dem Suchpfad befindet kann über den Befehl run gefolgt vom
vollständigen Pfad des Skriptes aufgerufen werden. Eine M-Datei foo.m kann über type foo oder type
foo.m am Bildschirm ausgegeben werden. (Falls es eine ASCII-Datei mit dem Namen foo gibt, so würde
der erste Befehl foo ausgeben anstatt foo.m) Folgt type auf den Befehl more on, so wird die Datei
seitenweise angezeigt (more off schaltet die seitenweise Darstellung wieder aus).
Erstellt man eine neue M-Datei, sollte man vermeiden, einen Namen zu wählen, der im Suchpfad
bereits vorhanden ist. Dies kann man mit Hilfe der Befehle which, type, help oder exist überprüfen.
Der Befehl exist(’name’) überprüft, ob name eine Variable im Workspace, eine Datei (mit mehreren
möglichen Endungen, unter Anderem .m) im Suchpfad, oder ein Ordner ist. Das Ergebnis 0 bedeutet,
dass keine Übereinstimmungen gefunden wurden, währen die Zahlen 1-7 bedeuten, dass es welche gibt.
Für die Bedeutung der Zahlen siehe help exist.
Wird eine Funktion, die sich im Suchpfad befindet, zum ersten Mal aufgerufen, wird sie in den Speicher
geladen. MATLAB kann im Allgemeinen feststellen, ob eine Funktionsdatei sich geändert hat, und
kompiliert sie automatisch erneut, wenn sie aufgerufen wird. Um die Funktion fun aus dem Speicher zu
löschen, benutzt man den Befehl clear fun. clear functions löscht alle Funktionen.
4.5 Dualität von Befehl und Funktion
Normalerweise werden vom Benutzer geschriebene Funktionen so aufgerufen: der Funktionenname gefolgt
von einer Liste von Argumenten in Klammern. Doch manche MATLAB-internen Funktionen, wie zum
Beispiel type und what, die im vorhergehenden Abschnitt behandelt wurden, werden normalerweise so
aufgerufen, dass die Argumente vom Funktionennamen durch ein Leerzeichen getrennt werden. Diese ist
keine Inkonsistenz von MATLAB sondern ein Beispiel für die Gleichheit von Befehl und Funktion.
function comfun(x,y,z)
%COMFUN Illustrative function with three string arguments.
disp(x), disp(y), disp(z)
32

Die Funktion comfun kann mit den Stringargumenten in Klammern (funktionale Form) oder mit den
Stringargumenten getrennt durch Leerzeichen aufgerufen werden (Befehlsform):
>> comfun(’ab’,’cd’,’ef’)
ab
cd
ef
>> comfun ab cd ef
ab
cd
ef
Die beiden Funktionsaufrufe sind gleichwertig. Andere Beispiele für die Dualität von Befehl und
Funktion sind
format long, format(’long’)
disp(’Hello’), disp Hello
diary mydiary, diary(’mydiary’)
warning off, warning(’off’)
Beachte, dass die Befehlsform nur dann verwendet werden sollte, wenn die Eingabeparameter der
Funktion Strings sind.
33

Kapitel 5
Lineare Algebra mit MATLAB
5.1 Norm und Kondition
Die Norm eines Vektors oder einer Matrix kann mit dem Befehl norm berechnet werden.
Befehl:
norm(A,p)
wobei A eine m x n Matrix und p=1,2,inf oder fro ist.
p Bedeutung
1 1-Norm, d.h. max. Spaltensumme
2 Spektralnorm, max. Singulärwert, (default)
inf Maximumsnorm, d.h. max. Zeilensumme
fro Frobeniusnorm, definiert als m
i=1
m
i=1 ai,j
Für höherdimensionale Matrizen sind Normberechnung für p = 2 relativ aufwendig und kostenintensiv
– daher werden oft Abschätzungen verwendet.
normest(A,tol)
Mit Hilfe von normest wird die 2-Norm von A bis auf die durch tol gegebene Genauigkeit berechnet.
Defaultwert für tol=1e-16.
Oft werden lineare Gleichungssystem auf das Verhalten von Störungen untersucht (so genannten
Stabilitätsanalyse). Ein Indikator hierfür ist die Kondition einer Matrix A, definiert als
κp(A) = Ap · A −1 p
Je nachdem ob κ groß bzw. klein ist, ist das System schlecht oder gut konditioniert.
Befehl:
cond(A,p)
p ist wie für norm definiert.
Anmerkung:
Normalerweise wird die Kondition nur für quadratische, nicht singuläre Matrizen berechnet. Für p = 2
kann auch die Kondition von rechteckigen Matrizen berechnet werden, wobei dann A ( − 1) durch die
Pseudoinverse (genauer die Moore-Penrose-Inverse) ersetzt wird.
Auch für die Kondition existieren Abschätzungsfunktionen, wie condest und rcond:
[c,v]=condest(A)
c Skalar
v Vektor
mit:
und A · v1 = A1∗v1
c
Befehl:
c ≤ κ1(A)
34

cond(A)
wobei für A singulär rcond(A)=0.
5.2 Lineare Gleichungssysteme
1
(A) ≈ rcond(A)
κ 1
Ein lineares Gleichungssystem sieht grundsätzlich folgendermaßen aus:
Ax = b
mit einer Matrix A und einem Vektor b. Gesucht wird ein Vektor x der das System löst.
5.2.1 A n × n Matrix
Falls A eine quadratische, nicht singuläre Matrix ist, existiert eine eindeutige Lösung. In MATLAB wird
diese wie folgt mit Hilfe des ’\’ berechnet.
5.2.2 A m × n Matrix mit m > n
x=A \ b
Wenn A eine rechteckige Matrix ist, die mehr Zeilen als Spalten hat, spricht man von einem überbestimmten
System, da mehr Bedingungen (Zeilen) als Unbekannte (Spalten) vorhanden sind. Eine eindeutige
Lösung, so dass Ax = b, ist im Allgemeinen nicht möglich. Es kann allerdings eine Minimallösung angegeben
werden, so dass A ∗ x − b2 = min! ist. (vgl. Numerik 1. „Lineare Ausgleichsrechnung“)
In diesem Fall wird durch den ’\’ Operator das lineare Ausgleichsproblem gelöst, mit Hilfe der „least
square solution“. Ist man nur an den nicht negativen Lösungen interessiert, ist der Befehl lsqnonneg zu
empfehlen.
x=lsqnonneg(A,b)
wobei x nur Einträge größer, gleich Null enthält.
5.2.3 A m × n Matrix mit m < n
Falls A eine Matrix mit weniger Zeilen als Spalten ist, so ist das LGS unterbestimmt und es existieren
entweder keine oder unendlich viele Lösungen. Falls das System unendlich viele Lösungen besitzt, gibt
’A\b’ eine Lösung aus, die k nichtnull Elemente besitzt, wobei k der Rang der Matrix A ist. Sollte das
System keine Lösungen haben gibt ’A\b’ eine Minimallösung aus, wie bei oben genannten überbestimmten
Systemen.
Falls man mehrere Gleichungssysteme, mit der selben Matrix A aber mit verschiedenen Seiten b (1) , . . . , b (n)
auf einmal lösen möchte, geschieht das am einfachsten dadurch, dass man die b (i) s als Spalten einer Matrix
B anordnet und den ’\’ Operator mit dieser Matrix aufruft. Das Ergebnis ist ein Matrix X mit
x (1) , . . . x (n) als Spalten, die das jeweilige System zu gegebenem b (i) lösen.
5.3 Inverse, Pseudoinverse und Determinante
In manchen Fällen – nicht oft, aber hin und wieder, vor allem in Hausaufgaben – muss man die Inverse
einer Matrix berechnen. In MATLAB geht das mit Hilfe des inv Befehls:
X=inv(A)
mit A ∗ X = X ∗ A = I, wobei A eine nicht singuläre, quadratische n × n Matrix sein muss.
Eine Matrix A ist singulär, falls die Determinante von A = 0 ist. Befehl:
det(A)
35

mit A einer n × n Matrix. Für gewisse Zwecke, z.B. zur Lösung eines least squares Problem ist die
so genannte Pseudoinverse einer Matrix A von Interesse. Die Pseudoinverse X von A erfüllt folgende
Bedingungen:
Befehl:
pinv(A)
XAX = X
AXA = A
(XA) T = XA
(AX) T = AX
wobei A hier nun auch eine rechteckige m × n Matrix sein kann.
5.4 Zerlegungen
Oben wurde bereits erwähnt, dass der ’\’ Operator lineare Gleichungssysteme löst, bzw. Näherungslösungen
dazu angibt. MATLAB verwendet dazu geeignete Algorithmen, die sich je nach Matrix unterscheiden
können.
MATLAB unterstützt aber auch das Zerlegen von Matrizen mit speziellen Zerlegungen, z.B. die LRoder
Cholesky-Zerlegung.
5.4.1 LR-Zerlegung
Befehl:
[L,R]=lu(A) \\ [L,R,P]=lu(A)
L untere Dreiecksmatrix mit 1 auf der Hauptdiagonale
R obere Dreiecksmatrix
wobei A eine quadratische n × n Matrix ist.
Nicht jede Matrix A kann auf diese Weise zerlegt werden, es existieren Matrizen bei denen ’Pivoting’
notwendig ist. Hierbei gibt der lu Befehl eine zusätzliche Permutationsmatrix P aus, sodass gilt: P ∗ A =
L ∗ R. Wird P bei der Rückgabe von lu nicht aufgefangen so wird L = P T · L.
Mit Hilfe der Zerlegung kann ein lineares Gleichungssystem dann wie folgt gelöst werden:
[L,R]=lu(A);
x=R\(L \ b);
5.4.2 Cholesky-Zerlegung
Falls A eine symmetrische, positiv definite (s.p.d.) Matrix ist, d.h. sie genügt:
1. A T = A
2. ∀x : x T Ax ≥ 0
existiert, die Cholesky Zerlegung von A in eine obere Dreiecksmatrix R, so dass gilt:
A = R T · R
Anmerkung:
In vielen Lehrbüchern wird die Cholesky-Zerlegung mit unteren Dreicksmatrizen L beschrieben. Beide
Formulierungen sind äquivalent, da für L = R T gilt:
Befehl:
R=chol(A)
[R,p]=chol(A)
A = L · L T
wobei A eine quadratische n × n Matrix ist. Falls A nicht positiv definit ist, ist p eine ganze Zahl größer
0, andernfalls gleich 0.
36

5.4.3 QR-Zerlegung
Die oben genannten Zerlegungen sind jeweils nur für quadratische Matrizen geeignet. Die QR-Zerlegung
jedoch arbeitet auch auf rechteckigen m x n Matrizen A , wobei A in eine orthogonale m x m Matrix Q
und eine obere m x n Dreiecksmatrix R zerlegt wird.
[Q,R]=qr(A) \\ [Q,R]=qr(A,0) \\ [Q,R,P]=qr(A)
Falls m>n ist und die Variante qr(A,0) benutzt wird, ist Q eine spaltenorthogonale m × n und R
eine n × n Matrix. Falls das Pivoting genutzt wird ([Q,R,P]=qr(A)) gilt: AP = QR wobei dann die
Diagonalelemente von R dem Betrag nach, abfallend geordnet sind.
Die QR-Zerlegung findet z.B. in der linearen Ausgleichsrechnung oder bei der Konstruktion von Orthonormalbasen
Verwendung.
5.4.4 Singulärwertzerlegung
Ähnlich den Eigenwerten, charakterisieren die so genannten Singulärwerte unterschiedliche Eigenschaften
einer Matrix. Jedoch sind für Eigenwerte quadratische Matrizen notwendig, die Singulärwertzerlegung
hingegen arbeitet auch mit rechteckigen m × n Matrizen A. Es gilt:
A = U · Σ · V
mit U m × m und V n × n unitären Matrizen Σ m × n diagonal Matrix mit σi (Singulärwerte) auf der
Hauptdiagonalen, wobei gilt:
Befehl:
[U,S,V]=svd(A)
σ1 ≥ σ2 ≥ · · · ≥ σ min(m,n)
Anmerkung:
Mit Hilfe der Singulärwertzerlegung ist es möglich, verschiedene Dinge über die Matrix A auszusagen.
So ist zum Beispiel die Anzahl der σi ungleich Null der Rang der Matrix A. Auch ist eine Orthonormalbasis
des durch die Spalten von A aufgespannten Raumes in der Singulärwertzerlegung enthalten. Es sind die
ersten k Spalten der Matrix U, wobei k der Rang von A ist.
5.5 Eigenwertpropleme
5.5.1 Eigenwerte
Sei A eine quadratische n×n Matrix. Dann ist λ ∈ C ein Eigenwert von A, wenn es einen vom Nullvektor
verschiedenen Vektor x gibt mit der Eigenschaft Ax = λx. Um diese Eigenwerte auszurechnen, berechnet
man normalerweise das charakteristische Polynom p = det(Iλ − A). Somit gilt:
p = pnλ n + · · · + p1λ + p0
Die Koeffizienten pn, · · · , p0 des charakteristischen Polynoms erhält man mit dem Befehl poly(A).
Die Eigenwerte bekommt man mittels e=eig(A). e ist ein Spaltenvektor der Länge n mit den Eigenwerten.
Mehrfache Eigenwerte (algebraische Vielfachheit) werden stehen auch mehrfach in e. Mit [V,D]=eig(A)
bekommt man eine n × n Diagonalmatrix D, die die Eigenwerte enthält, und eine n × n Matrix V, deren
Spaltenvektoren, wenn möglich, eine Basis aus Eigenvektoren bilden, so dass V −1 AV = D.
Falls man nicht n linear unabhängige Eigenvektoren erhält, ist die Matrix V nicht regulär. Dies verdeutlichen
wir mit dem folgenden Beispiel:
>> A=[2 -1;1 0]
A =
2 -1
1 0
>> [V,D]=eig(A)
37

V =
D =
0.7071 0.7071
0.7071 0.7071
1 0
0 1
Wie man an diesem Beispiel auch sieht, normiert MATLAB die Eigenvektoren immer bzgl. der 2-Norm.
Falls A eine hermitesche Matrix ist, d.h. A = A T , gibt es nur reelle Eigenwerte und eine Orthonormalbasis
aus Eigenvektoren. So eine Basis ist in V gespeichert.
>> [V,D]=eig([2 -1;-1 1])
V =
-0.5257 -0.8507
-0.8507 0.5257
D =
0.3820 0
0 2.6180
Um die Kondition der Berechnung der einzelnen Eigenwerte zu berechnen, ist der Befehl [V,D,s]=condeig(A)
implementiert. Die i-te Stelle im Vektor s entspricht der Kondition des i-ten Eigenwert.
>> [V,D,s]=condeig([2 0.9;200 5]);
>> [diag(D)’;s’]
ans =
-10.0000 17.0000
7.4416 7.4416
Wenn man eine sehr große quadratische Matrix A hat und sich nur für die 6 größten Eigenwerte
interessiert, kann man sich durch eigs(A) eine Approximation an diese Eigenwerte anzeigen lassen. Für
weitere Informationen help eigs.
5.6 Matrixfunktionen
Zum Lösen gewöhnlicher Differentialgleichungen wird oft die Exponentialfunktion mit einer Matrix als
Argument benötigt. Diese ist auch wie folgt definiert:
Von MATLAB wird dies direkt unterstützt:
expm(A)
exp(A) =
wobei A eine quadratische n × n Matrix ist
Anmerkung: Im Gegensatz zu der Funktion expm operiert exp nur auf den einzelnen Komponenten
der Matrix A!
Weiterhin sind in MATLAB folgenden Matrixfunktionen definiert:
∞
i=1
• logm: Der Logarithmus einer Matrix als Umkehrfunktion der Exponentialfunktion, d.h. logm(expm(A))=A
• sqrtm: Quadratwurzel aus A, d.h. B=sqtrm(A) mit B · B = A
• funm: Mit Hilfe von funm können Funktionen als Argument Matrizen übergeben werden. Zum Beispiel
funm(A,@sin) berechnet den Sinus der Matrix A.
38
A i
i

Kapitel 6
Eigene Funktionen
Eine eigene Funktion steht sobald sie etwas komplexer wird in einer m-Datei. Der grundlegende Aufbau
ist in Abschnitt 4.2 besprochen worden.
Daneben ist es bei kurzen Funktionen oft praktisch, diese direkt zu definieren ohne eine neue Datei
anlegen zu müssen. Dies funktioniert mit dem Befehl inline.
>> f=inline(’exp(a+log(x))/42’,’x’,’a’)
f =
>> f(1,2)
Inline function:
f(x,a) = exp(a+log(x))/42
ans =
0.1759
Erzeugt eine Funktion, die mit z.B.f(x, a) ausgewertet werden kann. Die Abfolge hinter der Funktionsvorschrift
definiert die Reihenfolge der Argumente beim Funktionsaufruf.
Meistens geht man bei der Entwicklung von Funktionen von einem einfachen, meistens eindimensionalen
Beispiel aus und versucht an Hand von diesem zu einer vektorwertigen Funktion zu gelangen. Dies
geschieht in Matlab mit Hilfe des vectorize Befehls.
vectorize(FUNKTION)
Der Befehl erzeugt aus einer gegebenen Funktion eine neue, die auf komponentenweise auf den Elementen
von Vektoren bzw. Matrizen operiert.
6.1 Referenzen
Wie im vorhergehende Kapitel besprochen wurde, können mit Hilfe von funm Funktionen mit Matrizen
als Argument ausgewertet werden. Hierzu wird eine so genannte Referenz auf eine Funktion übergeben.
Diese Referenz ist nichts anderes als ein Verweis auf eine Funktion, die dann im Laufe des Aufrufs von
funm mit feval ausgewertet wird.
feval(@Funktionsname,x1,...,xn)
@Funktionsname erzeugt den Verweis auf die Funktionen x1, . . . , xn sind die Argumente die an „Funktionsname“
zur Auswertung übergeben werden sollen.
In neueren Matlabversionen ist es möglich. Einer Referenz direkt die Argument zu übergeben, dies
sollte allerdings aus Gründen der Abwärtskompatibilität zu älteren Matlabversionen unterlassen werden.
Beispiel:
• neuere Matlabversion :
func_handle=@test_function; func_handle(4)
erzeugt eine Funktionsreferenz auf test_function und wertet dann die Referenz an der Stelle 4
aus.
39

• ältere Matlabversionen > diffd(@sin, 0.5)
ans =
0.8776
>> cos(0.5)
ans =
0.8776
6.2 Subfunktionen
Zu einem ’sauberen’ Programmierstil gehört, dass man sich wiederholende Operationen ausgliedert in so
genannte Subfunktionen. Da diese in der Regel nur im Kontext des entsprechenden M-Files Sinn machen,
werden sie einfach an die Hauptfunktion angefügt. Sie werden wie jede andere Funktion definiert durch:
function [RÜCKGABEWERTE]=FUNKTIONSNAME (EINGABEPARAMETER)
Sie sind jedoch nur sichtbar für alle anderen Unterroutinen und die Hauptfunktion.
function y=hauptfunktion(x)
% Hier wird etwas gemacht, wozu man immer wieder die Wurzel
% aus u+u^2 durch pi braucht. Der Aufruf erfolgt mit subfunktion(u).
function t=subfunktion(u)
t=sqrt(u+u^2)/pi;
6.3 Globale Variablen und Rekursion
Oft stellt sich das Problem, dass man Konstanten oder Verweise, in allen Funktionen zur Verfügung haben
muss. Anstatt diese nun von Funktion zu Funktion immer und immer wieder zu übergeben werden sie
als ’global’ deklariert.
Falls man nun in all seinen Funktionen auf den Wert der Variable GLOB_VAR zugreifen will, deklariert
man sie im Command Window mit ’global GLOB_VAR und verweist beim schreiben seiner Funktionen mit
’global GLOB_VAR’ darauf dass die verwendete Variable schon vorhanden ist. Allerdings ist auch Vorsicht
geboten beim Umgang mit globalen Variablen, da sie nicht schreibgeschützt sind, d.h. es ist möglich ihren
Wert in Funktionen zu verändern.
Rekursion bezeichnet einen Aufruf einer Funktion durch sich selbst. Am besten erklärt sich das an
Hand eines Beispiels. Die Fakultät einer natürlichen Zahl n ist definert durch:
n! = 1 · 2 · 3 · · · (n − 1) · n
In Matlab mit Hilfe der Rekursion führt das zu folgendem:
40

function ret_val=fak(n)
if (n

Kapitel 7
Ein- und Ausgabe
Im letzten Kapitel haben wir gelernt wie man eigene Funktionen korrekt in MATLAB schreibt – aber
diese konnten weder Daten einlesen noch Daten ausgeben. Dieses Manko wollen wir in diesem Kapitel
beseitigen, da insbesondere viele Funktion direkte Eingaben vom Benutzer erwarten.
7.1 Direkte Eingabe
Direkte Eingabe heißt, dass der Nutzer des Programmes aufgefordert wird, Daten einzugeben.
x=input(’Beschriftungstext’)
x=input(’Beschriftungstext’,’s’)
Wird die Funktion mit nur einem Parameter aufgerufen erwartet MATLAB die Eingabe im MATLAB-
Syntax:
>> x=input(’Bitte Zahl eingeben: ’);
Bitte Zahl eingeben: sin(0.5)
>> x
x =
0.4794
Mittels eines zweiten Parameters ’s’ kann man MATLAB anweisen, die Eingabe immer als Text zu
interpretieren.
>> x=input(’Bitte Zahl eingeben: ’,’s’);
Bitte Zahl eingeben: sin(0.5)
>> x
x =
sin(0.5)
Zur Abfrage von Koordinaten in einer graphischen Oberfläche wird die Funktion ginput verwendet.
[x,y] = ginput(n)
x x Koordinaten relativ zu dem geklickten Fenster
y y Koordinaten relativ zu dem geklickten Fenster
n Anzahl der Klicks die abgefangen werden sollen
Im Vektor x werden folglich die x-Koordinaten der nächsten n Mausklicks gespeichert. Für den Vektor
y gilt das Entsprechende. Diese Art der Eingabe ist besonders bei einem schon bestehenden Plot sinnvoll.
Um zwischen zwei Befehlen n Sekunden zu warten, gibt es den MATLAB-Befehl pause(n). Dies wird
üblicherweise bei Anzeigen von verschiedenen Plots angewandt.
42

7.2 Bildschirmausgabe
Einfache Ausgaben können über den Befehl disp erfolgen:
disp(’Zeichenfolge’)
disp(a)
Bei Ausgabe einer Zeichenfolge muss disp verwendet werden, bei Aufruf von disp mit einer Variablen
als Argument wird der Inhalt der Variablen formatiert ausgegeben (formatiert wie am interaktiven
Prompt). Für komplexere und formatierte Ausgaben kann man den Befehl fprintf verwenden:
fprintf(’FORMATSTRING’,Wert)
FORMATSTRING Ein Formatierungsstring der Form %a.b(e/f)\n.
a Anzahl der Stellen vor dem Komma
b Anzahl der Stellen hinter dem Komma
e/f Exponential oder Gleitkommadarstellung
\n Nach Ausgabe eine neue Zeile beginnen.
Wert Werte die ausgegeben werden sollen.
Ein Minus hinter dem % Zeichen erzwingt eine linksbündige Ausgabe:
fprintf(’%-3.5f\n%3.5f\n’, 9, 103)
9.00000
103.00000
Für die Ausgabe von mehreren Werten müssen diese in dem Formatstring gekennzeichnet werden. Es
können auch Beschriftungen eingefügt werden z.B.:
fprintf(’Skalarprodukt von [1 1] und [1 2]: %3.5f\n’,[1,1]*[1;2])
Skalarprodukt von [1 1] und [1 2]: 3.00000
Des weiteren ist es möglich, auch komplette Matrizen zeilenweise ausgeben zu lassen:
A=[1 2 3; 4 5 6; 7 8 9];
fprintf(’a1=%g, a2=%g, a3=%g\n’, A);
a1=1, a2=4, a3=7
a1=2, a2=5, a3=8
a1=3, a2=6, a3=9
Um ’, % und \ in einem Formatstring auszugeben, müssen ’’, \% und \\ verwendet werden. Für die
kombinierte Ausgabe von Zahlen und Zeichenketten ist es auch möglich, die beiden zu verbinden, indem
man die Zahlen in Strings umwandelt mit Hilfe von num2str bzw. int2str:
disp([’a’, num2str(4)])
a4
7.3 Speichern und Laden
MATLAB unterstützt das einfache Speichern und Laden von Variablen. Mit dem Befehl save können
Variablen in Dateien geschrieben werden.
>> A=magic(10);
>> B=magic(3);
>> save ’magic’ A B
Die von MATLAB geschriebenen Dateien enden auf ’.mat’ und sind in einem binären Format, welches
-je nach MATLAB Version- auch komprimiert ist. Gibt man dem save Befehl nur einen Dateinamen als
Argument, wird der komplette Workspace in der Datei gespeichert.
Um gespeicherte Variablen zu laden gibt es den load Befehl. Er hat die gleiche Syntax wie das
save Kommando. Um sich den Inhalt einer ’.mat’ Datei anzuzeigen kann man den Befehl whos -file
verwenden.
43

whos -file ’magic’
Name Size Bytes Class Attributes
A 10x10 800 double
B 3x3 72 double
>> clear A B
>> B
??? Undefined function or variable ’B’.
>> load ’magic’ B
>> B
B =
8 1 6
3 5 7
4 9 2
Im obigen Beispiel haben wir mit dem clear Befehl die Variablen aus dem Workspace gelöscht.
7.4 Indirekte Eingabe und Ausgabe
Indirekte Eingabe und Ausgabe heißt, dass man aus einer *.txt-Datei Daten einliest bzw. in diese Datei
Daten, die z.B. eine Funktion geliefert hat, reinschreibt.
Zuerst muss man Matlab sagen, in welcher Datei es nach Daten suchen oder Daten schreiben soll.
Dies wird durch den Befehl fid=fopen(’myoutput.txt’,’r/w’) erledigt, wobei r für das Einlesen steht
bzw. w für das Eingeben von Daten. Mit fprintf kann man dann Daten in myoutput.txt schreiben.
>> fid=fopen(’myoutput.txt’,’w’);
>> a=[1 2 3 4];
>> for i=1:4
fprintf(fid,’Das %g. Element des Vektors a: %g\n’,i,a(i));
end
>> fclose(fid)
Nun enthält myoutput.txt erwartungsgemäß folgendes:
Das 1. Element des Vektors a: 1
Das 2. Element des Vektors a: 2
Das 3. Element des Vektors a: 3
Das 4. Element des Vektors a: 4
Diese Datei kann folgendermaßen eingelesen werden:
>> fid=fopen(’myoutput.txt’,’r’);
>> X=fscanf(fid,’Das %g Element des Vektors a: %g\n’)
X =
1
1
2
2
3
3
4
4
>> fclose(fid);
44

scanf funktioniert also folgendermaßen: Überspringe ’Das ; lese irgendeine floating point Zahl (%g) ein,
überspringe wieder Element des Vektors a: und lese die zweite floating point Zahl ein. Schreibe alle
Zahlen der Reihe nach in den Vektor X.
Mit reshape formt man X in eine Matrix um:
>> X=reshape(X,2,4)
X =
1 2 3 4
1 2 3 4
Wenn man nur eine Matrix mit lauter reelen Zahlen einlesen will, macht man dies folgendermaßen.
In Matrix.txt steht z.B.
1 4 6 7
7 9 10 11
99 1 5 6
1 103 4 89
Nun muss man nur die Dimensionen der Matrix fscanf bekannt machen.
>> fid=fopen(’Matrix.txt’,’r’);
>> X=fscanf(fid,’%g’,[4,4]);
>> X=X’
X =
1 4 6 7
7 9 10 11
99 1 5 6
1 103 4 89
>> fclose(fid)
Außerdem können Dateien, die nur Zahlen erhalten, einfacher mit fread und fwrite bearbeitet werden.
Informieren Sie sich dazu in der Hilfe.
45

Kapitel 8
Optimierung von M-Files
Bei großen Problemen ist es sinnvoll und notwendig, Algorithmen effizient zu implementieren. Durch
die Beachtung einiger Regeln kann man enorme Zeitgewinne erreichen (vor allem in älteren MATLAB-
Versionen ohne JIT-Compiler).
8.1 Vektorisierung
In MATLAB sind Matrix- und Vektoroperationen annähernd optimal implementiert. Deshalb sollte man
so oft wie möglich auf sie zurückgreifen, insbesondere for-Schleifen sollten möglichst ersetzt werden. Dazu
ein Beispiel:
>> n = 5e5; x = randn(n,1);
>> tic, s = 0; for i=1:n, s = s+x(i)^2; end, toc
elapsed time is 1.532000 seconds
>> tic t=sum(x.^2); toc
elapsed time is 0.046000 seconds
>>s-t
ans = 0
>> 0.046/1.532
ans = 0.0300
Offensichtlich wird in beiden Fällen die Summe der Quadrate der Elemente von x berechnet, beide
Male mit dem selben Ergebnis. Der Zeitgewinn ist allerdings phänomenal: Durch die vektorielle Implementierung
benötigt man lediglich 3% der Zeit der intuitiven Version mittels einer for-Schleife. 1
Weitere Beispiele:
• Berechnung der Fakultät:
>> n=1e7;
>> p1=1; for i=1:n, p=p*i; end %9.625 sec
>> p2=prod(1:n) %0.531 sec
• Ersetzen zweier Zeilen einer Matrix durch Linearkombinationen:
⎛
⎜
⎝
←− A1 −→
.
←− Aj −→
.
.
←− Ak −→
.
⎞ ⎛
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ↩→ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎟ ⎜
⎠ ⎝
←− A1 −→
.
←− c ∗ Aj − s ∗ Ak −→
.
.
←− s ∗ Aj + c ∗ Ak −→
.
←− An −→
←− An −→
1 Dieses Missverhältnis ist in aktuelleren MATLAB Versionen nicht mehr so drastisch, trotzdem hat man häufig noch
einen Unterschied vom Faktor 4.
46
⎞
⎟
⎠

temp = A(j,:);
>> A(j,:) = c*A(j,:) - s*A(k,:);
>> A(k,:) = s*temp + c*A(k,:);
>> A([j k],:) = [c -s;s c]*A([j k],:);
8.2 Preallokierung von Speicher
Eine bequeme Eigenschaft von MATLAB besteht darin, dass Arrays (Vektoren) vor ihrer Benutzung
nicht deklariert werden müssen, und man sich ins Besondere die Festlegung auf eine Größe (Höchstzahl
der Elemente) spart. Werden an ein vorhandenes Array neue Elemente angehängt, wird die Dimension
automatisch angepasst. Dafür muss immer neuer Speicher belegt werden – in Extremfällen kann dieses
Vorgehen deshalb zu Ineffizienz führen:
>> clear;
>> n=1e4;
>> tic, x(1:2) = 1; for i=3:n, x(i)=0.25*x(i-1)^2-x(i-2); end, toc
elapsed time is 5.547000 sec
>> clear
>> n=1e4
>> tic, x=ones(n,1); for i=3:n, x(i)=0.25*x(i-1)^2-x(i-2); end, toc
elapsed time is 0.062000 sec
Es ist zu erkennen, dass die arithmetischen Operationen im Vergleich zur Speicher-Allokierung einen
verschwindend geringen Anteil an der Rechenzeit haben.
47

Kapitel 9
Tipps und Tricks
9.1 Leere Arrays
Wir haben die Möglichkeik Arrays der Dimensionen (4,0), (0,7) oder auch (0,0) zu erzeugen, im Folgenden
„leere Arrays“ genannt. Die Regeln für Operationen mit leeren Arrays werden aus denen für „normale“
Arrays hergeleitet. So zum Beispiel bei der Matrix-Multiplikation:
>> k = 5; A = ones(2,k); B = ones(k,3); A*B
ans=
5 5 5
5 5 5
>> k = 0; A = ones(2,k); B = ones(k,3); A*B
ans=
0 0 0
0 0 0
Und wofür das Ganze? Es unterstützt uns bei unserem Vorhaben, for-Schleifen zu vermeiden – wie
das folgende Beispiel zeigt:
for i=j-1:-1:1
s=0;
for k=i+1:j-1
s=s+R(i,k)*R(k,j);
end
end
for i=j-1:-1:1
s=R(i,i+1:j-1)*R(i+1:j-1,j);
end
Im Fall i=j-1 wird R(i,i+1:j-1) zu einer 1 × 0 - Matrix, R(i+1:j-1,j) zu einer 0 × 1 - Matrix und wir
erhalten als Produkt das die 1 × 1-Matrix.
9.2 ∞ und −∞
Über den Nutzen von ∞ und −∞ im Zusammenhang mit der Achsenbeschriftung bei plots wird unten
noch etwas gesagt. Ein weiteres Gebiet, an dem uns damit geholfen wird, sind die p-Normen. Möchte
man nämlich die zu p gehörige q-Norm berechnen, so dass p −1 + q −1 = 1 gilt, muss man sich um die
Spezialfälle p = 1 (⇒ q = ∞) bzw. p=∞ keine Gedanken machen, sondern kann ruhigen Gewissens
q=1/(1-1/p) berechnen:
>> x=1:10; p=1;
>> norm(x,p)
ans = 55
48

norm(x,1/(1-1/p)
ans = 10;
49

Kapitel 10
Grafiken mit MATLAB erstellen
10.1 Grafiken
In MATLAB ist es relativ leicht verschiedenste Arten von Grafiken zu erzeugen. Das Erscheinungsbild
kann sehr individuell gestaltet werden. Beispielsweise kann man Farben, Achsenskalierungen und Beschriftungen
den eigenen Vorstellungen anpassen. Grundsätzlich bestehen zur Modifikation von Grafiken
zwei Möglichkeiten, einerseits direkt über die Kommandozeile oder alternativ interaktiv mit der Maus in
der vorhandenen Grafik. Wir werden uns auf die erste Variante beschränken, aber es ist durchaus ratsam,
auch mal mit den „fertigen“ Grafiken rumzuspielen.
10.2 2-dimensionale Plots
Die einfachste Variante zweidimensionale Plots zu erzeugen, besteht darin zwei Vektoren mit gleichen
Dimensionen zu koppeln. Hat man zwei solcher Vektoren (x und y) gegeben, werden mit dem Befehl
plot(x,y) die jeweiligen x(i) und y(i) als zusammengehörig erkannt und ein dementsprechender Plot
erzeugt.
Beispiel:
>> x = [1.5 2.2 3.1 4.6 5.7 6.3 9.4];
>> y = [2.3 3.9 4.3 7.2 4.5 3.8 1.1];
>> plot(x,y)
Mit zusätzlichen Angaben kann man das Aussehen modifizieren. Ein allgemeinerer Aufruf der Funktion
plot hat die Form plot(x,y,String ), wobei sich der String aus bis zu drei Angaben (Farbe, Knoten,
Linienart) zusammensetzt. Die möglichen Eingaben können Tabellen 10.1 entnommen werden:
50

Farbe
r Red
g Green
b Blue
c Cyan
m Magenta
y Yellow
k Black
w White
Marker
◦ Kreis
∗ Stern
. Punkt
+ Plus
x Kreuz
s Quadrat
d Diamant
^ Dreieck nach oben
v Dreieck nach unten
> Dreieck nach rechts
< Dreieck nach links
p Fünfpunktestern
h Sechspunktestern
Linienart
- durchgezogene Linie
– gestrichelte Linie
: gepunktete Linie
-. gepunktet und gestrichelte Linie
Tabelle 10.1: Parameter für das Aussehen eines Plots
Ein typischer Aufruf hätte die Form plot(x,y,’mx:’), das gleiche Resultat erhält man auch mit
plot(x,y,’m:x’), woran man sieht, dass die Reihenfolge der Angabe irrelevant ist.
Es ist auch möglich mehr als einen Graphen in das Koordinatensystem zu legen:
>> x = [1.5 2.2 3.1 4.6 5.7 6.3 9.4];
>> y = [2.3 3.9 4.3 7.2 4.5 3.8 1.1];
>> a = 1:.1:10;
>> b = 1./a;
>> plot(x,y,’rp--’,a,b,’mx:)
51

Es werden allerdings nicht nur Vektoren als „Datenquellen“ akzeptiert, sondern auch Matrizen.
Wenn x ein m-dimensionaler Vektor und Y eine m x n Matrix ist, bewirkt plot(x,Y) das gleiche wie
plot(x,Y(:1),x,Y(:2),...,x,Y(:,n)). Wenn zusätzlich X auch eine m x n Matrix ist, kann man mit
plot(X,Y) die jeweils korrespondierenden Spalten der beiden Matrizen zu einem Graph verbinden, es
handelt sich also um eine verkürzte Schreibweise von plot(X(:1),Y(:1),...,X(:,n),Y(:,n). Nun stellt
sich die Frage, was passiert, wenn die Einträge in den beteiligten Vektoren und Matrizen nicht reellwertig
sondern komplex sind. In diesem Fall wird der imaginäre Teil ignoriert. Allerdings gibt es eine Ausnahme
- übergibt man plot als einziges Argument eine komplexe Matrix Z, erhält man das identische Resultat
wie mit dem Kommando plot(real(Z),imag(Z)). plot können weitere Attribute übergeben werden,
beispielsweise LineWidth:
>> x = [1.5 2.2 3.1 4.6 5.7 6.3 9.4];
>> y = [2.3 3.9 4.3 7.2 4.5 3.8 1.1];
>> plot(x,y,’LineWidth’,2)
Das Resultat sieht folgendermaßen aus:
Für manche Anwendungen ist es sinnvoller, die Achsen logarithmisch zu skalieren. Dazu verwendet
man statt plot eine der folgenden Anweisungen:
• semilogx(x,y), die x-Achse wird logarithmisch skaliert
• semilogy(x,y), die y-Achse wird logarithmisch skaliert
52

• loglog(x,y), beide Achsen werden logarithmisch skaliert
Beispiel:
Wir wollen den Fehler bei der quadratischen Taylor-Approximation bei kleinen Zahlen visualisieren
und zeigen, dass er sich proportional zu h3 verhält. Dazu betrachten wir |1 + h + h2 − exp(h)| und zum
2
Vergleich h3 jeweils ausgewertet für h = 10−4 , 10−3 , 10−2 , 10−1 , 1 und mit logarithmischer Skalierung:
>> h = 10.^[0:-1:-4];
>> taylor = abs((1+h+h.^2/2)-exp(h));
>> loglog(h,taylor)
>> hold on
>> xlabel(’h’)
>> ylabel(’absoluter Fehler’)
>> title(’Fehler in quadratischer Taylor-Entwicklung’)
>> plot(h,h.^3,’--’)
Das Ergebnis bestätigt unsere Theorie:
Neben loglog haben wir noch einige weitere neue Befehle benutzt, die allerdings mit Ausnahme von
hold on selbsterklärend sein sollten. hold on sorgt dafür, dass beim Plotten von weiteren Funktionen
die bisherigen erhalten bleiben und nicht - wie standardmaßig eingestellt bzw. bei hold off - zunächst
das figure-Fenster „geleert“ und erst dann der neue Plot eingefügt wird. Das ist in unserem Beispiel
durchaus sinnvoll, da wir so überprüfen können, ob die beiden Geraden tatsächlich annähernd parallel
sind. Trotzdem ist es komisch, dass MATLAB grundsätzlich in das figure-Fenster mit der Nummer 1
zeichnet. Das muss doch auch anders gehen?! Tut es auch! Mit dem Befehl figure wird ein neues figure-
Fenster geöffnet, mit figure(n) kann man ein beliebiges figure-Fenster aktivieren, so dass sich alle
folgenden (Grafik-) Befehle auf dieses beziehen.
Viele Eigenschaften der Achsen können mit dem axis-Kommando beeinflusst werden. Mögliche Einstellungen
sind:
• axis [xmin xmax ymin ymax]
• axis auto
• axis equal
• axis off
• axis square
• axis tight
53

Für den Fall, dass man nur die Grenzen einer Achse festlegen möchte, stehen die Befehle xlim([xmin,xmax])
und ylim([ymin,ymax]) zur Verfügung. Sollte man sich an einem Ende des Intervalls nicht festlegen wollen
oder können, sorgt die Angabe von -inf bzw. inf dafür, dass sich MATLAB darum kümmert. Warum
es an manchen Stellen sinnvoll ist, die Achseneinstellungen selbst vorzunehmen, zeigt folgendes Beispiel:
Wir betrachten die Funktion
Achsen, dann greifen wir manuell ein.
>> x = linspace(0,3,500);
>> plot(x,1./(x-1).^2+3./(x-2).^2)
>> grid on
>> ylim([0 50])
1
(x−1) 2 + 3
(x−2) 2 , zunächst übernimmt MATLAB selbst die Begrenzung der
Weiter oben haben wir ja schon gesehen, wie man seinem Plot einen Titel verpasst, doch man kann
auch Text an einer beliebigen Stelle einfügen und sogar einer automatisch erstellten Legende kann
man sich bedienen. Um Text einzufügen, reicht der Befehl text(x,y,’string), wobei (x, y) die Koordinate
festlegt, an der der Text beginnen soll. Zum Einfügen der Legende lautet das Kommando
legend(’string1’, ... ,’stringn’, Position), die Reihenfolge und die Anzahl der übergebenen
Strings sollte mit der im plot- bzw loglog- Befehl übereinstimmen. Mögliche Werte für Position:
• -1: rechts des Plots
• 0: MATLAB entscheidet
54

• 1: rechts oben
• 2: links oben
• 3: links unten
• 4: rechts unten
Es ist möglich (und teilweise auch notwendig) in Strings TEX-Code zu benutzen. Um zum Beispiel
folgenden Text am Punkt (−0.6, 0.7) in einer Grafik einzufügen: (n + 1)Pn+1(x) = (2n + 1)xPn(x) −
nPn−1(x) schreibt man idealerweise:
>> text(-.6,.7,’(n+1)P_{n+1}(x)=(2n+1)xP_n(x)-nP_{n-1}(x)’)
10.3 Mehrere Plots in einem Fenster
Der Befehl subplot(m,n,p) teilt das figure-Fenster in m Zeilen und n Spalten auf. p ist ein Skalar und
bezeichnet das aktive Feld.
>> subplot(2,2,1), fplot(’exp(sqrt(x)*(sin(12*x))’,[0 2*pi])
>> subplot(2,2,2), fplot(’sin(round(x))’,[0 10], ’--’)
>> subplot(2,2,3), fplot(’cos(30*x)/x’,[0.01 1 -15 20], ’-.’)
>> subplot(2,2,4), fplot(’[sin(x), cos(2*x),1/(1+x)’,[0 5*pi -1.5 1.5])
Hier haben wir eine neue Funktion genutzt: fplot. MATLAB wertet dabei die Funktion an „genug“
Stellen aus, um einen realitätsnahen Graph zu erhalten. Natürlich können auch fplot weitere Parameter
übergeben werden. Mehr dazu findet man - wie zu jeder anderen Funktion auch - unter doc fplot. Auch
eine unregelmäßige Aufteilung des figure-Feldes ist möglich:
>> x = linspace(0,15,100);
>> subplot(2,2,1), plot(x,sin(x))
>> subplot(2,2,2), plot(x,round(x))
>> subplot(2,2,3:4), plot(x, sin(round(x)))
55

10.4 3-dimensionale Plots
Analog zum Befehl plot im zweidimensionalen existiert auch der Befehl plot3 zum Plotten von Kurven
in 3-D. Im Grunde funktioniert er genauso.
>> t = -5:.005:5;
>> x = (1+t.^2).*sin(20*t);
>> y = (1+t.^2).*cos(20*t);
>> z = t;
>> plot3(x,y,z)
>> grid on
plot3 ist zwar ganz nett, kann aber nur zur Visualisierung von Kurven f : R → R 3 genutzt werden,
nicht aber von Funktionen g : R 2 → R, anschaulich gesprochen werden ausschließlich Linien und nie
Flächen dargestellt.
Einen ersten Ausweg aus diesem Dilemma bietet der Befehl ezcontour, der für eine Funktion f :
[xmin, xmax] × [ymin, ymax] → R eine Höhenkarte erzeugt, indem man ezcontour(’f’,[xmin xmax
ymin ymax]); ausführt.
Ähnliches liefert auch die Funktion contour, ihr müssen allerdings zwei Vektoren x und y, sowie eine
Matrix Z = (zi,j) mit zi,j = f(xi, yi) übergeben werden:
56

subplot(211)
>> ezcontour(’sin(3*y-x^2+1)+cos(2*y^2-2*x)’,[-2 2 -1 1]);
>> x = -2:.01:2; y = -1:.01:1;
>> [X,Y] = meshgrid(x,y);
>> Z = sin(3*Y-X.^2+1)+cos(2*Y.^2-2*X);
>> subplot(212)
>> contour(x,y,Z,20)
Um Z zu berechnen haben wir uns hier komponentenweisen Operationen auf Matrizen bedient. Es ist
leicht einzusehen, dass x und y dazu in zwei Matrizen X und Y konvertiert werden müssen, deren Zeilen
bzw. Spalten Kopien der Ursprungsvektoren sind. Genau das erreichen wir durch den Befehl meshgrid
in der vierten Zeile. Beispielsweise liefert [X,Y]=meshgrid(1:4,5:7) die beiden Matrizen
X =
Y =
1 2 3 4
1 2 3 4
1 2 3 4
5 5 5 5
6 6 6 6
7 7 7 7
Natürlich können contour auch mehr als drei Argumente übergeben werden, so dass zum Beispiel die
Anzahl der unterschiedlichen Höhen beeinflusst werden kann. Für Einzelheiten in der Hilfe nachschauen,
bei der Gelegenheit auch mal clabel nachschlagen.
Die Befehle mesh und meshc erwarten als Eingabe die gleichen Datentypen wie contour, sie liefern
uns endlich dreidimensionale Plots, wie wir sie uns vorstellen, meshc legt in die x-y-Ebene zusätzlich eine
Höhenkarte.
>> x = 0:.1:pi; y = 0:.1:pi;
>> [X,Y] = meshgrid(x,y);
>> Z = sin(Y.^2+X)-cos(Y-X.^2);
>> subplot(221)
>> mesh(Z)
>> subplot(222)
>> meshc(Z)
>> subplot(223)
>> mesh(x,y,Z)
57

axis([0 pi 0 pi -5 5])
>> subplot(224)
>> mesh(Z)
hidden off
Es fällt auf, dass nur netzartige Strukturen entstanden sind. Ausgefüllt bekommt man die Graphen
durch die Befehle surf bzw. surfc. Ein ähnliches Resultat liefert auch waterfall.
>> Z = membrane; FS = ’FontSize’;
>> subplot(221), surf(Z), title(’\bf{surf}’,FS,14)
>> subplot(222), surfc(Z), title(’\bf{surfc}’,FS,14), colorbar
>> subplot(223), surf(Z), shading flat
>> title(’\bf{surf} shading flat’,FS,14)
>> subplot(224), waterfall(Z), title(’\bf{waterfall}’,FS,14)
10.4.1 Animationen
Es gibt zwei Möglichkeiten, animierte Plots zu erzeugen.
• Durch Erzeugen einer Sequenz von figures, die gespeichert und in Form eines Films abgespielt wird:
58

Z = peaks; surf(Z)
>> axis tight
>> set(gca,’nextplot’,’replacechildren’)
>> for j = 1:11
>> surf(cos(2*pi*(j-1)/10).*Z,Z)
>> F(j) = getframe;
>> end
>> movie(F)
• Durch Manipulation der Objektattributte XData, YData und ZData, beispielsweise durch Aufruf
der Funktion comet oder comet3:
>> x = linspace(-2,2,500);
>> y = exp(x).*sin(1./x);
>> comet(x,y)
>> t = -pi:pi/500:pi;
>> comet3(sin(5*t),cos(3*t),t)
10.5 Diagramme
10.5.1 Balkendiagramme
Zum Erzeugen von Balkendiagrammen stehen uns im zweidimensionalen die Funktionen bar und barh,
im dreidimensionalen die Funktionen bar3 und barh3 zur Verfügung, das ’h’ steht dabei für horizontal,
wir erhalten also waagerechte Balken. Balkendiagramme aggieren auf Matrizen. Deshalb erzeugen wir
uns zunächst eine Beispiel-Matrix, die uns durch dieses Kapitel begleitet:
>> Y = [7 6 5; 6 8 1; 4 5 9; 2 3 4; 9 7 2];
MATLAB gruppiert jeweils die Elemente einer Zeile
>> subplot(2,2,1), bar(Y)
Durch zusätzliche Übergabe eines Vektors x kann man die Beschriftung der x-Achse ändern.
>> x = 0:5:20;
>> subplot(2,2,2), bar(x,Y)
Bisher wurde das Attribut grouped verschwiegen, eigentlich müsste der Aufruf bar(x,Y,’grouped’)
heißen, allerdings wird grouped als Standard angenommen. Die Alternative dazu lautet stacked.
>> subplot(2,2,3), bar(Y,’stacked’)
>> subplot(2,2,4), barh(Y)
Im Dreidimensionalen funktionieren diese Befehle natürlich auch.
59

10.5.2 Tortendiagramme
Tortendiagramme werden mit pie bzw. pie3 erzeugt und erwarten als Parameter einen Vektor. Es besteht
die Möglichkeit einige Tortenteile „herauszutrennen“ bzw. die Torte alternativ zu beschriften:
>> x = [1.5 3.4 4.2];
>> subplot(2,2,1), pie(x)
>> subplot(2,2,2), pie(x,[0,0,1])
>> subplot(2,2,3), pie(x,{’aaa’,’bbb’,’ccc’})
>> subplot(2,2,1), pie3(x,[0,1,0])
60

Kapitel 11
Troubleshooting
11.1 Errors und Warnings
Es ist bestimmt schon jedem ein Tipp- oder Programmierfehler unterlaufen, der von MATLAB durch
einen Error quittiert wird:
>> mod(3,sqrt(-2))
??? Error using ==> mod
Arguments must be real.
Zusätzlich zum Wort Error besteht die Fehlermeldung aus einem erläuternden Text - wie aussagekräftig
auch immer der sein mag...
Auf jeden Fall ist es auch möglich sich selbst solche Fehlermeldungen ausgeben zu lassen, das folgende
Beispiel sollte selbserklärend sein:
if ~isreal(arg2), error(’Arguments must be real.’), end
Die Funktion warning zeigt, wie error, sein Argument an, stoppt die Ausführung des Programms aber
nicht. Warum dann nicht einfach disp benutzen? Das hat vor allem zwei Gründe - zum einen kann man
mit warning(’off’), die Warnmeldungen einfach unterdrücken, zum anderen ist es auch möglich alle
aufgetretenen Fehler in einer Variable zu speichern: warns=warning.
11.2 Debugging
Die einfachste Möglichkeit, sich wichtige Zwischenergebnisse bei der Berechnung anzeigen zu lassen, besteht
darin, die gewünschte Variable ohne Semikolon in den Code zu schreiben.
Ein mächtiges Werkzeug von MATLAB ist aber auch der so genannte Keyboard-Modus. Er kann an
einer bestimmten Stelle durch die Eingabe von keyboard oder alternativ mit zum Beispiel dbstop at
5 in fak aufgerufen werden. Auf diese Art und Weise lässt sich auch die nützliche Version dbstop if
error implementieren.
Im Keyboard-Modus steht eine Kommandozeile zur Verfüegung, so dass man sowohl Werte von Variablen
abfragen als auch verändern kann.
61

Kapitel 12
Weiterführende
MATLAB-Funktionen
Im abschließenden Kapitel sollen noch kurz einige, der vielen weiteren Möglichkeiten mit MATLAB
zu programmieren vorgestellt werden. Dies erfolgt beispielhaft an einigen interessanten Toolkits, der
Möglichkeit GUIs zu erstellen und MATLAB mit anderen Programmiersprachen zu kombinieren.
12.1 Toolkits
Die Funktionalität von MATLAB wurde von einigen Toolboxen erweitert.Um herauszufinden, ob eine
Toolbox bereits installiert ist, schaut man die Liste durch, die MATLAB nach dem Kommando ver
ausgibt. Wenn der Name der gewünschten Toolbox enthalten ist, so ist diese auch vorhanden.
Es gibt eine Vielzahl solcher Toolboxen z.B. zur Optimierung, für Neuronale Netzwerke, Splines,Partielle
Differentialgleichungen oder für Wavelets. Eine aktuelle Liste solcher Toolboxen findet sich unter
http://www.mathworks.com/products/product_listing/index.html
wo es auch entsprechende Dokumentationen gibt. Außerdem gibt es noch eine Vielzahl von Toolboxen,
die von Privatpersonen oder Organisationen zur Verfügung gestellt werden. Diese haben meist sehr
spezielle Zielsetzungen (z.B. INTLAB, Hidden Markow Modell Toolbox, Bioelectromagnetism Toolbox).
Wir werden uns nun mit einer kleinen Auswahl beschäftigen.
12.1.1 Symbolic Math Toolbox
Um auch symbolische Rechnungen (wie im Maple) in MATLAB zu machen, benötig man die Symbolic
Math Toolbox. Diese basiert auf MAPLE und liefert einen Teil der dort vorhandenen Funktionen in
MATLAB-Syntax mit. Um symbolische Variablen einzuführen, verwendet man den Befehl sym oder syms:
>> b = sym(sqrt(2))
>> syms x y n a
>> f = sin(x*y)/(x*y)
Um diese Variablen wieder in numerische umzuwandeln, verwendet man vpa und um die Genauigkeit
festzulegen digits:
>> digits(25)
>> vpa(b)
Außerdem kann man den symbolischen Variablen auch Werte zuweisen:
>> solve(a*x^2+b*x+c)
>> subs(y,{a,b,c},{1,-1,-1})
Differential- und Integralrechnung
Nachdem man eine Funktion f mit symbolischen Variablen erzeugt hat, kann man diese nun auch ableiten
mit diffoder integrieren mit int:
62

diff(f)
>> int(f)
Außerdem lassen sich auch Grenzwerte symbolisch berechnen mit limit:
>> limit((1 + x/n)^n,n,inf)}
Vereinfachung
Um die Ausgabe leichter lesbar zu machen gibt es das pretty- Kommando:
>> pretty(f)
Um Ausdrücke zu vereinfachen, kann man entweder simplify oder simple verwenden, wobei simple
den Ausdruck sucht, der am kürzesten ist:
>> simplify((1/a^3+6/a^2+12/a+8)^(1/3))
>> simple((1/a^3+6/a^2+12/a+8)^(1/3))
Gleichungssysteme lösen
Desweiteren kann man auch Gleichungen mit solve und Differentialgleichungen mit dsolve lösen:
>> solve(’cos(n*x)+sin(x)=1’)
>> dsolve(’Dy=1+y^2’)
12.1.2 Image Processing Toolbox
Die Image Processing Toolbox bietet die Möglichkeit auf Bilder zuzugreifen, sie zu verändern und zu
speichern.
Lesen und Schreiben von Bildern
Dazu lädt man zuerst ein Bild mit dem Befehl imread. Dieser unterstützt unter anderm die Formate
JPEG, TIFF, GIF, BMP oder PNG. Mit imwrite kann man Bilder speichern. Der Befehl imfinfo gibt
Informationen:
>> A = imread(’test.jpg’);
>> imwrite(A,’test2.jpg’);
>> imfinfo(’test.jpg’)
Anzeigen und Bearbeiten von Bildern
Das Bild kann man sich mit dem Befehl imshow anzeigen lassen:
>> imshow(A)
Den Kontrast eines Graustufenbildes kann man mit dem Befehl imadjust verbessern. Mit dem Befehl
imfilter kann man beliebige Filter auf ein Bild anwenden. Eine Auswahl solcher Filter stellt fspecial
zur Verfügung.
>> imadjust(A)
>> h=fspecial(’sobel’)
>> imfilter(A,h)
12.2 Der MATLAB C-Compiler
Mit dem MATLAB Compiler kann man auch Standalone Anwendungen erstellen oder C-, C++ Shared
Libraries. Dazu muss auf dem System erstmal die MATLAB Component Runtime installiert sein. (im
63

MATLAB-Verzeichnis unter root\toolbox\compiler\deploy\win32). Anschließend muss man den Compiler
konfigurieren. Dazu ruft man in MATLAB mbuild -setup auf und wählt dort das Verzeichnis, in
dem der C-Compiler liegt. Danach kann man mit mcc die eigenen m-Dateien kompilieren. Wenn man eine
Standalone Anwendung erstellen möchte verwendet man:
>> mcc -m eigenefun.m
Für ein C Shared Library:
>> mcc -l eigenefun.m
Für ein C++ Shared Library:
>> mcc -l eigenefun.m -W cpplib -T link:lib
Um die so erzeugte Anwendung oder Bibliothek weiterzugeben, muss man natürlich die compilierte
Datei weitergeben, außerdem die eigenefun.ctf und das MATLAB Component Runtime (unter Windows
MCRInstaller.exe, unter Linux MCRInstaller.zip). Nun kann man auf jedem System über die Kommandozeile
das Programm starten, dabei werden die evtl. vorhandenen Parameter einfach nach einem
Leerzeichen angehängt.
12.3 Andere Programmiersprachen mit MATLAB verwenden
MATLAB ist sehr nützlich für mathematische Programmierung, bietet aber auch die Möglichkeit andere
Programmiersprachen zu nutzen. So kann man z.B. bereits bestehende Programme in C oder Fortran
einbinden oder Java-Klassen nutzen.
12.3.1 Fortran und C
Viele mathematische Programme sind in FORTRAN oder C geschrieben sind und man kann sie auch in
MATAB nutzen, indem man sie etwas ändert und compiliert. Daher testen wir zuerst, ob unser Systm
dafür passend konfigueriert ist. Dazu kompieren wir yprime.c ins aus \extern\examples\mex Arbeitsverzeichnis.
Nun rufen wir mex auf:
>> mex yprime.c
Kann man nun yprime wie eine normale M-Funktion verwenden, funktioniert alles. >> yprime(1,1:4)
Ansonsten sollte man mit mex -setup sicherstellen, dass ein geeigneter Compiler ausgewählt ist.
Ebenso verfährt man mit Fortran-Programmen. Beim Aufruf des Compilers mex kann man auch noch
eine Optionsdatei
(z.B. aus \bin\win32\mexopts) mitgeben:
>> mex yprime.c -f lccopts.bat
Solche Optionsdateien kann man auch selbst erstellen, wenn man zum Beispiel einen nicht supporteten
Compiler verwenden will, oder mehr Einfluss auf den Compilationsprozess nehmen will.
Um ein C bzw. Fortran-Programm MATLAB kompatibel anzupassen, benötigt man eine Gatewayroutine.
Außerdem muss im C-Header auch # include „mex.h“ stehen. Die Gatewayroutine stellt die
Schnittstelle zwischen MATLAB und C dar:
void mexFunction( int nlhs, mxArray *plhs[], int nrhs, const
mxArray*prhs[] )}
nlhs gibt die Anzahl der Ausgabeparameter,nrhs sie Anzahl der Eingabeparameter an. Die Parameter
plhs und prhs enthalten die Pointer auf die entsprechenden Eingabe-/Ausgabevektoren. Danach
kommt C Code, der die Eingaben prüft und die Datenstrukturen (natürlich MATLAB kompatibel, z.B.
mxArray) für die Ausgabe anlegt. Die eigentliche C Routine ist meist eine eigene Funktion, die von hier
aus aufgerufen wird und deren Ergebnis dann durch die Gatewayroutine an MATLAB zurückgegeben
wird.
Ruft man nun die Funktion in Matlab auf, findet MATLAB die MEX-Datei vor M-Dateien mit
gleichem Namen. Dies kann man sich für die MATLAB Hilfe zunutze machen. Da die MEX-Datei keine
für MATLAB lesbare Hilfe hat, sucht MATLAB weiter und gibt die Hilfe einer gleichnamigen M-Datei
aus, falls vorhanden.
Auch Fortran benötigt eine Gatewayroutine, die der in C sehr ähnlich sieht:
subroutine mexFunction(nlhs, plhs, nrhs, prhs)
64

integer plhs(*), prhs(*)
integer nlhs, nrhs,
die anschließend die Eingaben prüft, den Ausgabevektor initialisiert und die eigentliche Funktion aufruft.
Außerdem kann man auch Matlab Routinen in C oder Fortran verwenden. Dazu läuft eine seperate
MATLAB Engine, die das C bzw. Fortran Programm ansteuern kann. Dazu muss engine.h eingebunden
sein. Mit engOpen(“\0“) startet man die MATLAB-Engine. Man erhält dabei einen Pointer auf die Engine.
Nun kann man Matlab kompatible Variablen deklarieren und mit engPutVariable an Matlab geben.
Die Auswertung eines Ausdrucks erfolt mit engEvalString. Wenn man alle Auswertungen ausgeführt
hat, gibt man den Speicher wieder frei und schließt die MATLAB Engine mit engClose, z.B.:
Engine *ep;
ep = engOpen("’\0"’); T = mxCreateDoubleMatrix(1, 10, mxREAL);
engPutVariable(ep, "’T"’, T);
engEvalString(ep,"’D=.5.*(-9.8).*T.^2;"’);
mxDestroyArray(result);
engClose(ep);
Matlab in Fortran einzubinden funktioniert analog.
12.3.2 Java
MATLAB liefert außerdem bei seiner Installation eine JVM (Java Virtual Machine) mit und bietet die
Möglichkeit auf Java-Objekte zuzugreifen. Dabei kann man den Pfad entweder statisch in der classpath.txt
(unter \toolbox\local) oder dynamisch mit javaaddpath C:\Java einbinden. Wenn man jar-Archives einbinden
will, muss man ihren vollständigen Pfad inklusiv ihrem Namen angeben, bei normalen Javaklassen
reicht der Pfad zu einem Elternverzeichnis um alle Klassen darin in MATLAB verfügbar zu machen. Nun
kann man wie man es aus Java gewohnt ist, mit dem Konstruktor Instanzen einer Java-Klasse erzeugen
und bearbeiten: >> frame = java.awt.Frame(’Frame A’);
>> frame.setSize(100,60);
>> frame.setVisible(true);
Mittels Java-Klassen kann man zum Beispiel Daten aus dem Internet holen:
>> url = java.net.URL(’http://www.fs.tum.de/FSMPI/Kurse/Matlab/test.html’)
>> is = openStream(url);
>> isr = java.io.InputStreamReader(is);
>> br = java.io.BufferedReader(isr);
>> for k = 1:85
s = readLine(br);
end
>> s = readLine(br);
>> disp(s)
12.4 GUIs programmieren
Mit dem MATLAB Compiler haben wir eine Möglichkeit kennengelernt, Standalone Anwendungen zu
erstellen, allerdings ist die Parameter-Übergabe wenig intuitiv. Daher ist es sinnvoll für solche Anwendungen
eine GUI zu erstellen. MATLAB bietet dazu direkt Funktionen an oder ein graphisches Tool, mit
dem man die Steuerelemente anordnen kann.
12.4.1 GUI Kommandos
Um Steuerelemente direkt zu programmieren, kann man das Kommando uicontrol verwenden. Dem
Kommando werden verschiedene Werte mitgegeben, z.B. gibt ’Style’ an, was für ein Element man möchte
(z.B. checkbox, edit, listbox, popupmenu pushbutton, radiobutton, slider, text). Man kann zum Beipiel
65

einer figure einen Button zum Schließen des Fensters mitgeben:
>> fh = figure(’NumberTitle’,’off’,’Name’,’GUI’);
>> ah = axes(’Position’,[0.1 0.1 0.65 0.85]);
>> membrane;
>> ph = uicontrol(fh, ’Style’, ’pushbutton’, ’String’, ’Ende’, ’Units’, ’normalized’,
’Position’, [0.8 0.08 0.18 0.12], ’ToolTipString’,’Schließt das Fenster’,’Callback’,
’close(gcbf)’);
12.4.2 GUIDE
Guide ist ein graphisches Interface um GUIs zu erzeugen. Um es zu starten tippt man den Befehl guide.
Nun kann man auf einem leeren GUI die Komponenten per Drag’n’Drop anordnen. Und mit dem Property
Manager Eigenschaften zuordnen (z.B. Farbe, Text, Closefunction). Wenn man die fertige GUI
gespeichert hat, findet man eine .fig und .m Datei desselben Namens. Bis jetzt haben wir nur eine Gui,
die aber noch keine Funktionalität besitzt, wenn wir sie starten. Wenn wir die .m-Datei editieren, weisen
wir nun die entsprechenden Funktionen zu. In der generierten M-Datei findet sich am Anfang eine Initialisierung,
die man nicht änern sollte. Anschließend kommt die eigene Opening Function. Hier schreiben
wir alle Funktionen hinein, die nur einmal und zwar beim Öffnen der Gui erledigt werden sollen (z.B.
Beispielplot). Mit setappdata stellen wir dann die gebrechneten Daten der GUI zur Verfügung. Die Output
Funktion verwenden wir, wenn wir Werte z.B. an eine weitere GUI weitergeben möchten (so muss
man sie nicht öffentlich deklarieren). In der Callback Funktion implementieren wir die Funktionalität der
einzelnen Elemente, z.B. Auslesen eines Wertes von einem Slider (hObject ist das Handle des Sliders):
>> f = get(hObject,’Value’);
66

Literaturverzeichnis
[1] Stoer: Numerische Mathematik 1. Springer-Verlag, Berlin Heidelberg, New-York
67

Index
[], 21
function, 31
charakteristisches Polynom, 37
Cholesky-Zerlegung, 36
Debugging, 61
Determinante, 35
Eingabe, 42
Funktionen
addpath, 32
all, 24
and, 24
any, 24
axis, 53
bar3, 59
barh3, 59
barh, 59
bar, 59
blkdiag, 13
break, 28
case, 29
chol, 20
clabel, 57
clear, 32, 44
comet3, 59
comet, 59
condest, 34
continue, 28, 29
contour, 56, 57
cos, 19
cumsum, 20
dbstop, 61
diag, 12
diff, 20, 62
digits, 62
disp, 43, 61
doc, 55
dsolve, 63
eigs, 38
elseif, 27
else, 27
error, 61
exist, 32
expm, 38
exp, 19, 38
eye, 11
ezcontour, 56
68
factorial, 19
feval, 39
figure, 53, 66
find, 26
fminsearch, 32
for, 9, 14, 26–28, 46, 48
fplot, 55
fprintf, 43, 44
fread, 45
fscanf, 45
fspecial, 63
funm, 38, 39
fwrite, 45
gallery, 14
ginput, 42
global, 40
guide, 66
help, 31, 32
hilb, 13
hold, 53
if, 26, 27, 29
imadjust, 63
imfilter, 63
imfinfo, 63
imread, 63
imshow, 63
imwrite, 63
inline, 39
int2str, 43
int, 62
invhilb, 13
inv, 35
isequal, 23
isnan, 23
keyboard, 61
legend, 54
length, 19
limit, 63
linspace, 14
load, 43
logical, 24
loglog, 53
logm, 38
lookfor, 32
lsqnonneg, 35
lu, 36
magic, 13
max, 20
meshc, 57

meshgrid, 57
mesh, 57
more, 32
normest, 34
norm, 20, 34
not, 24
num2str, 43
numel, 19
ones, 11
or, 24
pathtool, 32
path, 32
pause, 42
pie3, 60
pie, 60
plot3, 56
plot, 9, 50–52, 56
poly, 37
pretty, 63
primes, 16
prod, 20
qr, 37
randn, 11, 12
rand, 11, 12
rcond, 34
repmat, 13
reshape, 21, 45
run, 32
save, 43
scanf, 45
semilogx, 52
semilogy, 52
simple, 63
simplify, 63
sin, 19
size, 19
solve, 63
sort, 20
sqrtm, 38
sub2ind, 16
subplot, 55
sum, 20
surfc, 58
surf, 58
switch, 26, 29
syms, 62
sym, 62
text, 54
tril, 20
triu, 20
type, 32
uicontrol, 65
vectorize, 39
ver, 62
vpa, 62
warning, 61
waterfall, 58
what, 32
69
which, 32
while, 26, 28
whos , 43
xlim, 54
xor, 24
ylim, 54
zeros, 11
eig, 37
hilb, 18
hold, 9
input, 42
invhilb, 18
spdiags, 10
speye, 10
subplot, 59, 60
condeig, 38
fopen, 44
lu, 36
norm, 34
pinv, 36
globale Variablen, 40
GUI, 65
GUIDE, 66
Hilbertmatrix, 13
Inverse, 35
Keyboard-Modus, 61
Komplexe Zahlen, 5
Kondition, 34
kubische Splines, 7
leere Felder, 48
lineare Gleichungssysteme, 35
logical, 23
logische Felder, 24
LR-Zerlegung, 36
magische Quadrate, 13
Matrix, 11
Moore-Penrose-Inverse, 34
natürlicher Spline, 7
Norm, 34
NumPy, 5
Octave, 5
Operatoren, 23
\, 35
=, 23
:, 14
’, 16
*, 17
+, 17

-, 17
.’, 16
.*, 17
:, 15
=, 23
Pseudoinverse, 36
Python, 5
QR-Zerlegung, 37
Rekursion, 40
SciLab, 5
SciPy, 5
symbolisches rechnen, 62
Tortendiagramme, 60
transponieren, 16
Variablen
ans, 5
Vektor, 11
Workspace, 43
70