1 Einleitung

1
Einleitung
1.1
Ziel des Kurses
Neben einer kurzen Wiederholung allgemeiner Konzepte, die bereits in der Vorlesung “Einführung in die Programmierung” behandelt worden sind, soll das Arbeiten und Programmieren mit
MATLAB erlernt werden. Das Ziel ist, dass die Teilnehmer nach diesem Kurs dazu in der Lage
sind,
• selbstständig Algorithmen in MATLAB zu implementieren;
• die Arbeitsweise von MATLAB zu verstehen und Erweiterungen (Toolboxen) nutzen zu
können sowie auch selber MATLAB erweitern zu können;
• MATLAB-Programme von anderen nachvollziehen zu können und zu verstehen.
1.2
Wie funktioniert ein Computer?
Ein Computer kann in vier Teile aufgeteilt werden:
1. CPU: verarbeitet Befehle;
2. Arbeitsspeicher: enthält Daten und Befehle;
3. Bus: transportiert Daten zwischen CPU, Speicher und der Peripherie;
4. Peripherie: alles, was an den Computer angeschlossen wird, wie etwa Geräte zur Ein- und
Ausgabe oder Datenspeicherung.
Die Befehle, die von der CPU ausgeführt werden, liegen im Arbeitsspeicher in einem bestimmten
Format vor, dem sogenannten Maschinencode. Dieser ist für Menschen nicht sehr leserlich.
1.3
Was ist eine Programmiersprache?
Eine Programmiersprache ist eine formale Sprache, die Programme beschreibt, jedoch im Gegensatz
zu Maschinencode meist lesbar ist. Ein Programm in einer Programmiersprache muss erst von einem sogenannten Compiler (Übersetzer) in Maschinencode übersetzt werden, bevor das Programm
auf dem Computer ausgeführt werden kann.
Es gibt verschiedene Abstraktionsebenen mit zugehörigen Programmiersprachen:
• Assembler ist etwa eine Programmiersprache, die ziemlich direkt Maschinencode entspricht,
jedoch den Vorteil hat auch für Menschen (gut) lesbar zu sein.
• Low-Level-Sprachen wie C, in der es Befehle gibt, die vom Compiler in mehrere Maschinenbefehle übersetzt werden. Etwa wird aus der Anweisung
if (a == b) fprintf("sind gleich");,
die im Falle der Gleichheit zweier Variablen einen Text ausgibt, ein ganzer Satz von Maschinenbefehlen.
• High-Level-Sprachen wie Java oder MATLAB, die völlig von der unterliegenden CPU abstrahieren und erlauben, mit komplexen Objekten (etwa Matrizen) zu arbeiten, ohne sich um die
Details (Speicherverwaltung, Operationen, ...) zu kümmern.
MATLAB hat einen sehr hohen Abstraktionsgrad.
Weiterhin gibt es verschiedene Programmierparadigmen, die wichtigsten sind imperative Programmierung, funktionale Programmierung, logische Programmierung sowie objektorientierte Programmierung. Imperative Programmierung entspricht der Arbeitsweise einer CPU: imperative Programme sind eine Ansammlung von Befehlen, die in einer gewissen Reihenfolge ausgeführt werden.
Funktionale und logische Programmierung dagegen sind anders; dies soll hier weiter nicht diskutiert werden, bis auf den Hinweis, dass sich diese bei gewissen Problemen besser eignen als etwa
imperative Programmierung. Das vierte angesprochene Paradigma, objektorientierte Programmierung, stellt im Gegensatz zur imperativen Programmierung nicht den Befehle in den Mittelpunkt,
sondern Objekte. Die Programmiersprache Java, die in der Vorlesung “Einführung in die Programmierung” behandelt wird, erlaubt objektorientierte und imperative Programmierung.
In MATLAB kann sowohl imperativ wie auch objektorientiert programmiert werden. Wir werden objektorientierte Programmierung in diesem Kurs jedoch nicht behandeln.
1
1.4
Algorithmen
Ein Algorithmus ist im wesentlichen eine Sammlung von Befehlen, die Eingabedaten in einem
vorher spezifizierten Format verarbeitet und Ausgabedaten in einem vorher spezifizierten Format
zurückliefert. Ein sehr bekannter Algorithmus aus der linearen Algebra ist der Gaußsche Algorithmus: als Eingabe erwartet er eine n × m-Matrix mit Einträgen aus einem Körper, und er liefert
eine n × m-Matrix mit Einträgen in ebendiesem Körper zurück, welche sich in Zeilenstufenform
befindet. Wie dies erreicht wird, ist (zumindest in informeller Form) in jedem Skript zur Linearen
Algebra zu finden: dort steht dann, welche Zeilenumformung wann ausgeführt werden muss, um
schliesslich eine Matrix in Zeilenstufenform zu erhalten.
Es gibt verschiedene Art und Weisen, Algorithmen zu spezifizieren. Oft geschieht dies in Textform: etwa als Programm in einer Programmiersprache, oder als “Pseudo-Code”, also Text, der
Ähnlichkeit mit bekannten Programmiersprachen aufweist. Andere Formen von Algorithmen sind
etwa Flussablaufdiagramme. Siehe auch Abbildung 1.
1. Setze a ← sin x
a = sin ( x );
b = cos ( x );
if a < b
c = b - a ^2;
2. Setze b ← cos x
3. Vergleiche a und b
• Ist a < b, setze c ← b − a2
2
• Sonst setze c ← a − b
a = sin x
b = cos x
else
c = a - b ^2;
end
(a) Pseudo-Code
(b) MATLAB-Code
Ist a < b?
::
:: Nein
Ja ::
:
2
c=b−a
c = a − b2
(c) Flussablaufdiagramm
Abbildung 1: Der gleiche Algorithmus in verschiedenen Beschreibungen
1.5
Komplexität
Wenn man einen Algorithmus hat, interessiert einem oft, wie effizient dieser ist. Eine Möglichkeit,
dies zu messen, ist die benötigte Laufzeit und den Speicherverbrauch in Relation zur Grösse der
Eingabedaten anzugeben.
Man ist häufig nur an der asymptotischen Laufzeit interessiert: wenn die Laufzweit zweier Algorithmen sich nur um einen konstanten Faktor unterscheidet, haben sie dieselbe asymptotische Laufzeit. Um dies zu beschreiben, hat sich die Landau-Notation, auch Gross-O-Notation, eingebürgert.
Sind f, g : N → R>0 Funktionen, so sagt man, dass f von der Ordnung g ist, in Zeichen f = O(g),
falls gilt
f (n)
lim sup
< ∞.
n→∞ g(n)
(In Worten: der Quotient f /g ist für n → ∞ beschränkt.) Dies ist äquivalent dazu, dass es Konstanten c > 0 und n0 ∈ N gibt mit f (n) ≤ c · g(n) für alle n ≥ n0 .
Wenn man etwa eine n×m-Matrix A = (aij )ij mit P
einer m×`-Matrix B = (bjk )jk multipliziert,
m
so muss man für jedes Paar (i, k) die Summe cik = j=1 aij bjk berechnen. Es gibt n · k solche
Paare. Zur Berechnung eines Eintrages cik werden nun m − 1 Additionen und m Multiplikationen
benötigt, womit man insgesamt
nk(m − 1) Additionen und nkm Multiplikationen
benötigt. Insgesamt braucht man also nk(2m − 1) arithmetische Operationen; und wenn man die
Landau-Notation verwendet:
O(nkm) Operationen.
2
Dies ist ein wenig besser lesbar als nk(2m − 1); bei komplizierteren Algorithmen wären solche exakten Ausdrücke noch wesentlich komplizierter und der Vereinfachungseffekt der Landau-Notation
ist um so stärker.
Hat man etwa eine Laufzeit, die von zwei Parametern n, m abhängt, und die durch den folgenden
Ausdruck abgeschätzt wird:
35n3 m2 + 75n2 m · log n · (log m)5 +
13n5
1
− m2 · log log n
2
n + 11 3
Mit der Landau-Notation lässt sich dies durch O(n3 m2 ) ausdrücken. Hat man für das gleiche
Problem ein weiteres Programm mit der asymptotischen Laufzeit O(n2 m2 ), so kann man sofort
sehen, dass das zweite Programm für grosse Werte von n schneller ist. Es kann jedoch sein, dass
das erste Programm für kleine Werte von n schneller ist: die Landau-Notation sagt nur etwas über
“gross genuge” Argumente aus.
Es gibt etwa zum Multiplizieren von zwei n × n-Matrizen einen Algorithmus von Coppersmith
und Winograd, der O(n2.3727 ) Operationen benötigt – im Vergleich zu den O(n3 ) Operationen für
den “naiven” Algorithmus. Wenn n sehr gross ist, ist dieser Algorithmus somit wesentlich schneller.
Praktische Relevanz hat dieser Algorithmus jedoch nicht, da sein Geschwindigkeitsvorteil erst bei
Matrizen sichtbar wird, die aufgrund ihrer Grösse von heutigen Computern nicht mehr verarbeitet
werden können.
1.6
MATLAB
MATLAB steht für “MATrix LABoratory”. Es ist entstanden als eine Sammlung von (FORTRAN)Programmen zur Manipulation von Matrizen. Es wurde später schliesslich zu einer eigenen Programmiersprache, mit der besonders einfach – und ohne sich um die konkrete Umsetzung der
Befehle etwa in FORTRAN kümmern zu müssen – mit Matrizen gearbeitet werden kann.
Allgemein ist MATLAB gut geeignet für numerische Anwendungen, sowohl in der Forschung,
in der Industrie, wie auch in Übungen zu Numerik-Vorlesungen :-) MATLAB zu beherrschen lohnt
sich also nicht nur für die Numerik-Vorlesung, sondern je nach angestrebten Werdegang für viele
weitere Dinge.
1.7
Zum Ablauf des Kurses
Der Kurs besteht aus zehn Tagen mit je drei Stunden. Diese Stunden teilen sich auf in Vorlesungsanteile, in denen Konzepte eingeführt oder Anweisungen vorgestellt werden, und in Übungsteile,
in denen die Teilnehmer die zuvor kennengelernten Konzepte und Anweisungen benutzen sollen.
Zum Abschluss des Kurses wird es Projekte geben. Jedem Teilnehmer wird ein Projektthema
zugeordnet, welches dieser alleine bearbeiten soll. Das Bearbeiten kann an den letzten Kurstagen
geschehen, oder in den ersten zwei Vorlesungswochen. Um die Kreditpunkte für den Kurs zu
erhalten, müssen die Teilnehmer dem Kursleiter ihr bearbeitetes Projekt präsentieren und Fragen
dazu beantworten können. Termine können direkt mit dem Kursleiter ausgemacht werden.
Die Projekte werden Anfang der zweiten Kurswoche zugewiesen.
3
2
Bedienung von MATLAB und erste Ausdrücke
2.1
Einleitung
• MATLAB besteht aus zwei Teilen:
– einer Benutzeroberfläche samt Editor (dort kann man Programme schreiben) und Debugger (Hilfsmittel zum Fehler finden);
– einer Kommandozeile, in der etwas ausprobiert werden kann, im Editor geschriebene
Funktionen aufgerufen werden können, oder von der aus Skripte (Programme) gestartet
werden können.
• Die Kommandozeile ist auch ohne Benutzeroberfläche nutzbar; wenn man sich etwa per SSH
einloggt und MATLAB startet, bekommt man nur diese.
• Alternativ zu MATLAB kann auch Octave verwendet werden; dies ist ein Open-SourceProgramm, welches grosse Teile von MATLAB selber nachbildet. Für fast alles1 in diesem
Kurs reicht Octave völlig aus.
– Octave kann man etwa unter
http://www.gnu.org/software/octave/
finden.
– Octave selber hat nur eine Kommandozeile.
– Es gibt jedoch separate GUIs, wie etwa qtoctave.
– Octave/qtoctave bieten sich an, wenn man Zuhause programmieren will, ohne sich per
SGD oder SSH auf den Uni-Rechnern einzuloggen (oder weil alle Uni-Lizenzen belegt
sind).
2.2
Die Kommandozeile
• Man kann Ausdrücke (etwa 1 + 1, pi^2/6), Anweisungen (etwa fprintf(’test\n’)) und
Definitionen eingeben
• Diese werden sofort ausgeführt, bzw. bei grösseren Konstrukten (Verzweigungen, Funktionsdefinitionen, Schleifen, ...) wird solange gewartet, bis das Konstrukt vollständig eingegeben
ist, bevor es ausgeführt wird
• Eine Berechnung kann abgebrochen werden, falls sie zulange dauert: einfach Ctrl+C drücken
(Strg+C auf deutschen Tastaturen).
1 Der einzige Teil des Kurses, der sich in Octave (noch) nicht machen lässt, ist der Abschnitt über Toolboxen,
und insbesondere die symbolische Toolbox.
4
2.3
Kurzüberblick über die graphische Benutzeroberfläche (GUI)
• Ganz oben findet sich das Menü (File, Edit, Debug, ...) und die Toolbar, in der sich Icons
für neue Skripte, zum Öffnen von Skripten, Bearbeiten von Text, ... befinden.
• Darunter befinden sich “Shortcuts”, mit denen man direkt vorher festgelegte Sequenzen von
MATLAB-Befehlen ausführen kann, sozusagen Makros. Dies können auch Aufrufe der OnlineHilfe sein. Der erste Shortcut “How to add...” beschreibt, wie man Shortcuts hinzufügen kann.
• Darunter ganz links befindet sich die Dateiauswahl. Hier können .m-Dateien (dazu später
mehr) ausgewählt werden, per Doppelklick im Editor geöffnet werden, und in der Schnellansicht darunter wird angezeigt, welche Funktion(en) sich in der Datei befinden.
• Mittig befindet sich das “Command Window”, die Kommandozeile, in der direkt MATLABBefehle eingegeben werden können. Befehle müssen hinter dem aktuellen Prompt >> eingegeben werden. Der Eingabecursor befindet sich hinter dem aktuellen Prompt.
• In der Spalte rechts befinden sich oben der Workspace Browser (dazu später mehr).
• Rechts unten findet sich die “Command History”, in der alle in der Kommandozeile ausgeführten MATLAB-Befehle gesammelt werden. Diese lassen sich etwa per Doppelklick nochmal ausführen. Die Befehle sind jeweils nach der Sitzung sortiert.
2.4
Die Online-Hilfe
MATLAB hat eine mächtige und hilfreiche Online-Hilfe. Diese kann mit dem Befehl doc in der Kommandozeile aufgerufen werden. Eine Nur-Text-Variante, die direkt in der Kommandozeile angezeigt
wird, ist der help-Befehl. Indem man nur doc eingibt, erscheint das Hilfe-Fenster. Wenn man Hilfe
zu einem bestimmten Befehl haben möchte, gibt man in der Kommandozeile help Befehl oder
doc Befehl ein.
Beispiele:
>> help sin
SIN
Sine of argument in radians .
SIN ( X ) is the sine of the elements of X .
See also asin , sind .
Overloaded methods :
codistributed / sin
Reference page in Help browser
doc sin
>> doc cos
5
Beim doc-Befehl erscheint in etwa folgendes Fenster:
2.5
Ausdrücke und Variablen
Ausdrücke sind im Wesentlichen Formeln, die MATLAB versteht. Es ist wichtig, dass man den
Aufbau von Ausdrücken kennt und versteht, sowie auch deren Interpretation durch MATLAB. In
vielerlei Beziehung verhält sich MATLAB, wie man es erwartet.
Ein weiteres Konzept sind Variablen. Diese speichern einen Wert. Man kann ihnen einen Wert
zuweisen und den Wert verwenden. Der Wert einer Variable ist derjenige, der als letztes in ihr
gespeichert wurde.
Wir wollen zuerst die Grundstruktur von Ausdrücken anschauen. Was ein Ausdruck ist kann
man einerseits – da es ein sehr vertrautes Konzept ist – anhand von Beispielen “definieren”. Ein
einfacher Ausdruck ist 3 * (2 + 1): dieser hat den Wert 9. Andererseits kann man auch formal
definieren, was ein Ausdruck sein soll. Dies macht man am einfachsten rekursiv:
• Sind A und B Ausdrücke, so auch
– (A) (Klammerung),
– ~A (logische Negation),
– -A (Negation),
– A^B (Exponentiation),
– A * B (Multiplikation), A / B (Division) und A \ B (“Linksdivison”, ist gleich B / A),
– A + B (Addition) und A - B (Subtraktion),
– ==, ~=, <, <=, > und >= (Test auf Gleichheit, Ungleichheit, Kleiner, Kleinergleich, ...),
– A & B (logisches Und),
– A | B (logisches Oder).
Die Operatorpräzedenz ist absteigend aufgelistet (“Punkt-vor-Strich-Rechnung”:
1 + 2 & 3 * 4 + 5
ist gleich
(1 + 2) & ((3 * 4) + 5);
bei Operatoren gleicher Ordnung wird von Links nach Rechts interpretiert (1 - 2 + 3 ist
gleich (1 - 2) + 3).
Die Vergleichsoperatoren und die logischen Operatoren geben den Wert 0 oder 1 zurück.
Dabei bedeutet 0 false und 1 true. Wendet man die logischen Operatoren auf beliebige
Zahlen an, so wird 0 als false und alles andere als true interpretiert.
Die Symbole true und false sind in MATLAB nicht definiert.
Eine gute Möglichkeit, die Struktur eines Ausdruckes zu visualisieren, sind Bäume. Ein Knoten des Baumes repräsentiert ein zwischendurch auftretenden Wert bzw. Ausdruck, und die
Kinder eines Knotens sind die zugehörigen Teilausdrücke bzw. die Zwischenergebnisse, aus
6
denen der Wert des aktuellen Knotens berechnet wird. Der Baum zum obigen Ausdruck
1 + 2 & 3 * 4 + 5 ist z.B.
o & OOOO
ooo
OOO
o
o
o
+>
+>
>>
>>
1
*>
>>
2
3
5
4
Um den Wert eines Ausdrucks zu bestimmen, kann man jeweils die Zwischenergebnisse an
die Knoten schreiben:
&O
ooo 1 OOOOO
o
o
O
oo
+>
+>
>>
>>
3
1
17
*>
>
12 >
2
3
5
4
Aufgabe 2.1: Bestimme für die folgenden Paare (op1 , op2 ) von Operatoren, ob es ganzzahlige Konstanten (a1 , a2 , a3 ) ∈ Z3 gibt so, dass (a1 op1 a2 ) op2 a3 einen anderen Wert annimmt
als a1 op1 (a2 op2 a3 ). Wenn es solche Konstanten gibt, gebe solche explizit an und überprüfe,
wie MATLAB die Ausdrücke auswertet.
1. (op1 , op2 ) = (-, -);
5. (op1 , op2 ) = (+, |);
9. (op1 , op2 ) = (^, *);
2. (op1 , op2 ) = (*, +);
6. (op1 , op2 ) = (&, |);
10. (op1 , op2 ) = (*, ==);
3. (op1 , op2 ) = (+, &);
7. (op1 , op2 ) = (|, &);
11. (op1 , op2 ) = (<, >);
4. (op1 , op2 ) = (-, +);
8. (op1 , op2 ) = (<, |);
12. (op1 , op2 ) = (&, >=).
Aufgabe 2.2: Füge maximal viele Klammern ein (ohne doppelte Klammern!), ohne die
Abfolge der Operationen zu verändern, und bestimme den zugehörigen Baum und damit den
Wert des Ausdrucks. Verifiziere dies, indem du den Ausdruck in MATLAB eingibst.
1.
2 + 4 * - 1 / 3 / 4
2.
2 + 4 == 5 | 3 + 5 ^ - 1 & 2
3.
- 3 < 4 < 5
4.
4 < - 2 < 5
5.
- 3 < - 2 < - 1
6.
sin ( n + 1 ) / ( n + 2 )
• Sind A1, ..., An Ausdrücke und ist f eine Funktion, die auf n Parameter anwendbar ist, so ist
f(A1, ..., An) ebenfalls ein Ausdruck.
Beispiele für Funktionen:
– sin(x) (Sinus; Argument in Bogenmass);
– cos(x) (Kosinus; Argument in Bogenmass);
– tan(x) (Tangens; Argument in Bogenmass);
– exp(x) (Exponential von x);
– log(x) (natürlicher Logarithmus von x);
– log2(x), log10(x) (Logarithmus zur Basis 2 bzw. 10 von x);
– real(x), imag(x) (Realteil bzw. Imaginärteil von x).
7
Diese Funktionen verlangen jeweils nur einen Parameter. Wir werden jedoch später sehen,
wie wir selber Funktionen schreiben können, die auch mehr als einen Parameter erwarten.
Weitere können mit help elfun (elementare Funktionen), help specfun (speziellere Funktionen) und help elmat (Matrix-Funktionen) aufgelistet werden.
• Weitere Ausdrücke sind (numerische) Konstanten und Variablen:
– 1 ist eine Konstante (vom Typ double; dazu später mehr)
– -123.45e67 ist ebenfalls eine Konstante vom Typ double mit dem Wert −123.45·1067 =
−1.2345 · 1069
– .123 ist eine Konstante mit dem Wert 0.123 = 1.23 · 10−1 ; alternativ kann man auch
123e-3 oder 1.23e-1 schreiben
– 3i ist eine komplexe Zahl mit Realteil 0 und Imaginärteil 3. Anstelle i kann man auch
j schreiben.
Aufgabe 2.3:
1. Überlege, wie man eine komplexe Zahl von Polarkoordinaten (Winkel in Bogenmass und
Radius) in kartesische Koordinaten (Real- und Imaginärteil) schreiben kann.
2. Berechne das multiplikativ Inverse von 1 + 2i mit MATLAB.
– Variablen sind sozusagen mit Namen versehene Speicherplätze. Im Gegensatz zur üblichen
Vorgehensweise in der Mathematik, wo man einem Symbol (Name) einmal einen Wert
zuweist und diesen normalerweise nicht ändert,2 kann man den Wert von Variablen in
Programmen beliebig oft ändern, und dies ist sogar erwünscht und führt erst zu der
Flexibilität, die zur Lösung vieler Probleme benötigt wird.
∗ Namen von Variablen können (wie in Java) aus Buchstaben, Ziffern und Unterstrichen (_) bestehen, das erste Zeichen darf jedoch keine Ziffer sein.
∗ Es wird zwischen Gross- und Kleinschreibung unterschieden.
∗ Variablen kann man einem Wert zuweisen (x = 1 – dies ist eine Anweisung, die
der Variablen x den Wert 1 zuweist) oder als Ausdruck verwenden (x – dies ist ein
Ausdruck, dessen Wert gleich dem Wert der Variable ist). Beispiele:
· x = sin(pi/4) – speichert den Wert sin π4 in der Variablen x;
· asin(x)/pi – berechnet den Arkussinus vom Wert der Variablen x, und teilt
das Ergebnis durch π.
– Es gibt einige vordefinierte Variablen (deren Wert man jedoch ändern kann!):
∗
∗
∗
∗
∗
∗
pi: Approximation der Konstanten π;
i oder j: die komplexe Einheit i, die i2 = −1 erfüllt;
eps: die relative Fliesskommagenauigkeit ε, meist 2−52 (dazu unten mehr);
realmin: die kleinste positive Fliesskommazahl (meist 2−1022 );
realmax: die grösste positive Fliesskommazahl (meist (2 − ε)21023 );
Inf: das positiv Unendliche, +∞ (dies repräsentiert ein Ergebnis grösser als realmax,
etwa das Ergebnis von 1/0 oder von exp(2^1000)); es gibt auch -Inf, etwa als Ergebnis von -1/0;
∗ NaN: “Not a Number” (ein nicht wohl-definiertes Ergebnis; etwa das Ergebnis von
0/0); im Gegensatz zu Inf ist NaN vorzeichenlos.
Diese Variablen sollten unter keinen Umständen umdefiniert werden! Das Umdefinieren
kann auch sehr komische Effekte haben:
2 Falls die Variable mehr als einen Wert haben soll, verwendet man meist eine Folge: der Startwert ist x , dann
1
erhält man x2 , dann x3 , etc. Bei der Übertragung von Algorithmen aus mathematischen Beschreibungen in eine
Programmiersprache wie MATLAB muss man dies meist rückgängig machen, d.h. eine Folge x1 , x2 , x3 , . . . ersetzen
durch eine Variable für xn , wobei n sich im Laufe des Programmes vergrössert (und eventuell eine Variable für
xn−1 , falls dieser Wert zusammen mit xn verwendet wird, etc.).
8
>> Inf = 1
Inf = 1
>> 1/0
ans = Inf
>> ans == Inf
ans = 0
oder
>> i = -1
i = -1
>> 3 i
ans = 0 + 3 i
>> 3* i
ans = -3
• Befehle in MATLAB sind (nach bisherigem Stand) von folgenden möglichen Formen:
1. Variable = Ausdruck
2. Ausdruck
Steht hinter einem Befehl ein Semikolon “;”, so wird das Ergebnis des Befehls nicht angezeigt,
andernfalls schon. Das Ergebnis ist im ersten Fall gleich dem Wert der Variable, der etwas
zugewiesen wird; im zweiten Fall ist es der Wert des Ausdrucks, und dieser wird in der
Variablen ans gespeichert.
Beispiel:
>> 7;
>> ans
ans = 7
>> x = 8
x = 8
>> ans + 2
ans = 9
>> ans + 1
ans = 10
Aufgabe 2.4:
gerade hat:
>>
>>
>>
>>
>>
>>
Gebe bei folgender Abfolge von Befehlen nach jedem Befehl an, welchen Wert ans
23;
ans ^2;
x = sqrt ( ans );
x ^2 - ans ;
x ^2 - ans ;
ans - x ^2;
Hinweis: mit den bisherigen Mitteln sind die folgenden Aufgaben relativ mühsam zu lösen. Wir
werden diese Aufgaben später in ähnlicher Form nochmal bearbeiten, wenn bessere Hilfsmittel zur
Verfügung stehen.
P∞ 1
π2
Aufgabe 2.5: Verifiziere numerisch, dass
k=1 k2 = 6 gilt, indem du die Partialsumme
Pn
1
π2
k=1 k2 mit MATLAB für n = 10 und n = 15 auswertest und und 6 vergleichst.
Aufgabe 2.6: Sei f : R → R eine differenzierbare Funktion. Das Newton-Verfahren zum Nullstellenfinden funktioniert so: man wählt einen Startpunkt x0 , möglichst nahe einer Nullstelle,
n)
und definiert iterativ eine Folge xn+1 := xn − ff0(x
(xn ) . Wenn die Bedingungen günstig sind, gilt
f (limn→∞ xn ) = 0. (Dazu mehr in der Numerik-Vorlesung!)
Führe die Newton-Iteration bis zur Berechnung von x5 explizit für folgende Funktionen und
Startwerte durch:
1. f (x) = sin x, x0 = 3;
2. f (x) = x5 − 14x4 + x2 − 3x + 5, x0 = 5.
Versuche, das ganze so zu schreiben, dass du möglichst einfach viele Iterationen durchführen kannst.
Falls du dies schaffst, probiere, wie lange du iterieren musst, um bei 1. ein xn zu finden mit
|f (xn )| < 10−10 .
9
Aufgabe 2.7: Eine weitere numerische Methode, eine Nullstelle einer Funktion zu finden, ist das
Bisektionsverfahren. Man fängt mit zwei Startwerten x1 und x2 an, so dass f (x1 )f (x2 ) < 0 ist.
2
. Dann gibt es drei Fälle:
Man wählt x3 = x1 +x
2
• f (x1 )f (x3 ) < 0: in dem Fall fährt man mit den Startwerten (x1 , x3 ) fort;
• f (x1 )f (x3 ) > 0: in dem Fall fährt man mit den Startwerten (x3 , x2 ) fort;
• f (x3 ) = 0: in dem Fall ist x3 eine Nullstelle.
Nach dem Prinzip der Intervallschachtelung nähert man sich immer weiter eine Nullstelle von f
an. (Der Beweis des Zwischenwertsatz funktioniert über dieses Prinzip.)
Führe dieses Verfahren explizit für f (x) = cos x, x1 = 1 und x2 = 2 durch, bis |x2 − x1 | ≤ 2−5
ist.
2.6
Matrizen
MATLAB basiert auf den Grundsatz
“Alles ist eine Matrix”:
• eine Zahl ist eine 1 × 1-Matrix;
• ein Zeilenvektor ist eine 1 × n-Matrix, ein Spaltenvektor eine n × 1-Matrix;
• eine Zeichenkette der Länge n ist eine 1 × n-Matrix (bestehend aus einzelnden Zeichen).
Matrizen können einfach erzeugt werden:
• Sind A1 , ..., An Matrizen mit gleicher Zeilenanzahl, so ist [A1 , ..., An ] eine Matrix, in der
die Matrizen hintereinander geschrieben werden.
– Anstelle eines Kommas kann auch ein Leerzeichen benutzt werden.
– Leerzeichen kann gefährlich sein: [ 1 -2 ] = [ -1 ] vs. [ 1, -2 ].
• Sind A1 , ..., An Matrizen mit gleicher Spaltenanzahl, so ist [A1 ; ...; An ] eine Matrix, in
der die Matrizen untereinander geschrieben werden.
• “,” und “;” können natürlich kombiniert werden, um eine Blockmatrix zusammenzusetzen
(solange die Matrizen das passende Format haben).
Beispiele:
– [1, 2 3] erzeugt einen Zeilenvektor 1, 2, 3 (beachte, dass Zahlen 1×1-Matrizen sind);
1 2
– [1, 2; 3, 4] erzeugt die 2 × 2-Matrix
;
3 4
– ist A = [1, 2; 3, 4], so ist [A A A;A A A] gleich der Blockmatrix


1 2 1 2 1 2
 3 4 3 4 3 4


1 2 1 2 1 2.
3 4 3 4 3 4
• a : b erzeugt einen Zeilenvektor mit den Einträgen a, a+1, a+2, ...; der letzte Eintrag ist ≤
b.
• a : b : c erzeugt einen Zeilenvektor mit den Einträgen a, a+b, a+2b, ...; der letzte Eintrag
ist ≤ c (falls b < 0: ≥ c). Ist b = 0, so wird die leere Matrix erzeugt.
Beispiele:
– 1 : pi erzeugt den Zeilenvektor 1, 2, 3 ;
– 3 : 0.03 : pi erzeugt den Zeilenvektor
3, 3.03, 3.06, 3.09, 3.12 ;
10
– pi : -0.3 : 3 erzeugt den Zeilenvektor
3.1416, 3.1116, 3.0816, 3.0516, 3.0216 .
• Mit [] wird die leere Matrix (vom Format 0 × 0) erzeugt.
• Mit den Funktionen eye, zeros, ones, rand und randn lassen sich Matrizen erzeugen:
– wird ein Argument n angegeben, so wird eine n × n-Matrix erzeugt;
– (ausser eye) werden zwei oder mehr Argumente k1 , . . . , kn angegeben mit n ≥ 2, so
wird eine k1 × · · · × kn -Matrix (n-dimensional) erzeugt;
– dabei ist eye eine Einheitsmatrix, ones eine Matrix mit allen Einträgen gleich 1, zeros
eine Matrix mit allen Einträgen gleich 0, rand eine Matrix mit Einträgen aus dem
Intervall [0, 1], die mit einer Gleichverteilung zufällig gewählt werden, und randn eine
Matrix mit Einträgen, die mit einer Standardnormalverteilung zufällig gewählt werden.
• Ist v ein (Zeilen- oder Spalten-)Vektor, so ist diag(v) die Diagonalmatrix mit den Einträgen
aus v auf der Diagonalen.
• Ist A eine Matrix, so ist A.’ die Transponierte von A, und A’ die komplex konjugierte Transponierte von A (macht nur einen Unterschied bei Matrizen mit echt komplexen Einträgen).
Aufgabe 2.8:
Befehlen:
Konstruiere folgende Matrizen mit möglichst kurzen und wenigen MATLAB-
1.

1
0

0

0

0

0

0

0
0
2.
3.
1
1
0
0
0
0
0
0
0
0
1
1
0
0
0
0
0
0
0
0
0
2
0
0
0
0
0
0
0
0
1
2
0
0
0
0
0
0
0
0
0
2
0
0
0
0
0
0
0
0
0
5
0
0
0
0
0
0
0
0
0
5
0
1
1

2

2
2
1
1
2
2
2
1
1
2
2
2
1
1
2
2
2
3
0
0
6
6
0
4
0
6
6

0
0

5

7
8
1
0
0
0
0
2
0
0
0
0
3
0
0
0
0
4
5
6
7
8
5
1
0
5
6
0
2
6


5
6

7
8
5
6
7
8

0
0

0

0

0

0

0

0
5
7
3
0
7

8
0

4
8
Hinweis: der Befehl ones(...) erzeugt eine Matrix, die nur aus Einsen besteht. Um eine Matrix
zu erzeugen, die nur aus Vieren besteht, muss man z.B. 4 * ones(...) schreiben. (Dazu später
mehr.)
Es gibt viele Möglichkeiten, auf Inhalte von Matrizen zuzugreifen:
• Ist A eine Matrix, so kann man an die (k, `)-te Stelle zugreifen per A(k, l).
• Ist A ein (Zeilen- oder Spalten-)Vektor, so liefert A(k) den k-ten Eintrag von A zurück. Ist A
dagegen eine Matrix, so liefert A(k) den k-ten Eintrag des Vektors
[A11 , . . . , An,1 , A12 , . . . , An,2 , . . . , A1,m , . . . , An,m ],
falls A eine n × m-Matrix ist; in diesem Vektor sind die Einträge der Matrix spaltenweise
aufgelistet.
11
• Die Funktion sum(A) liefert einen Zeilenvektor zurück, dessen k-ter Eintrag die Summe der
Einträge in der k-ten Spalte von A ist. Falls A ein (Zeilen- oder Spalten-)Vektor ist, ist sum(A)
einfach die Summe aller Einträge von A.
• Die Funktion diag(A) liefert die Diagonaleinträge einer Matrix A als Spaltenvektorzurück.
1 2
Mit diag(A, k) kann die k-te (Neben-)Diagonale ausgelesen werden. Ist etwa A =
,
3 4
so ist diag(A) gleich [1, 4], diag(A, 1) ist 2 und diag(A, -1) ist 3. Und insbesondere
gilt für jeden Spaltenvektor v, dass diag(diag(v, k), k) wieder v ist.
Quizfrage:
Wie kann man v zurückerhalten, wenn v ein Zeilenvektor ist?
• Es kann auch auf Teilmatrizen zugegriffen werden. In A(k, l) kann k oder l ersetzt werden
durch eins der folgenden:
– durch :, dann wird die komplette Zeile bzw. Spalte zurückgeliefert: so ist A(1, :) die
erste Zeile von A und A(:, 1) die erste Spalte von A;
– durch einen Zeilen- oder Spaltenvektor v. Ist v = [v1 , ..., vn ], so liefert A(v, :)
die Teilmatrix zurück, welche n Zeilen hat und dessen erste Zeile die v1 -te Zeile von A
ist, dessen zweite Zeile die v2 -te Zeile von A ist, etc.
∗ Ist A eine 3× 3-Matrix
mit dein Einträgen aij , so liefert A([1 3], [1 2]) die
a11 a12
Teilmatrix
zurück.
a31 a32
Mit diesen Zugriffstechniken auf Teilmatrizen und einfachen Zuweisungen lassen sich etwa Zeilenund Spaltenumformungen durchführen. Um etwa viermal die dritte Spalte von A zu der ersten
Spalte von A zu addieren, schreibt man einfach
A(:, 1) = A(:, 1) + 4 * A(:, 3).
Und um die zweite Zeile von A mit der vierten zu tauschen, schreibt man
A([2 3], :) = A([3 2], :).
Weiterhin kann man etwa die fünfte und siebte Zeile von A auf 0 setzen, indem man
A([5 7], :) = zeros(2, 10)
schreibt, falls A 10 Spalten hat.
Aufgabe 2.9:
1. Beschreibe, wie mit MATLAB das arithmetische Mittel aller Einträge einer Matrix A mit
n Zeilen und m Spalten berechnet werden kann.
2. Untersuche den Mittelwert von Matrizen, die mit rand und randn erzeugt wurden. Fällt
an den Mittelwerten etwas auf, wenn die Matrizen gross sind (also viele Zeilen und Spalten
haben)?
3. Überführe die Matrix


1 2 3 4
5 6 7 8


 9 10 11 12


13 14 15 16
17 18 19 20
mit elementaren Zeilenumformungen in MATLAB in Zeilenstufenform. (Versuche dies
möglichst geschickt zu machen, ohne streng dem Gaußschen Algorithmus zu folgen.)
4. Erzeuge eine 4 × 4-Matrix mit rand und führe sie mit elementaren Zeilenumformungen in
reduzierte Zeilenstufenform über. Führe dies in MATLAB durch und gebe keine Konstanten
explizit ein. (Halte dich hier an den Gaußschen Algorithmus.)
Bonusfrage: wie sieht die reduzierte Zeilenstufenform einer solchen Matrix in wahrscheinlich
fast allen Fällen aus?
12
5. Schlage in der Onlinehilfe die Befehle rank, null, rref und orth nach. Wie kann mit diesen
ein lineares Gleichungssystem Ax = b gelöst werden, wenn A und b in MATLAB als Matrix
bzw. Vektor vorliegen? Probiere dies mit einfachen linearen Gleichungssystemen aus.
Hinweis: ‘row echolon form’ bedeutet ‘Zeilenstufenform’, und der ‘nullspace’ einer Matrix ist
ihr Kern. Schliesslich ist ‘range space’ der Bildraum.
Verschiedene Methoden, lineare Gleichungssysteme numerisch zu lösen, werden in der
Numerik-Vorlesung vorgestellt. Das klassische Gauß-Verfahren wird im Allgemeinen nicht
verwendet, da es numerisch schlechte Eigenschaften hat.
2.7
Operationen auf Matrizen
Wie oben schon angedeutet, kann man einfach A + B oder A * B schreiben, um zwei Matrizen A und
B passenden Formats zu addieren oder multiplizieren. Im wesentlichen kann man alle Operationen
bei Ausdrücken auch auf Matrizen anwenden. Es gibt jedoch ein paar Feinheiten und Extras zu
beachten:
• Mit * wird die Matrizenmultiplikation bezeichnet; ebenso sind /, ^ und \ in Bezug auf die
Matrizenmultiplikation zu sehen.
Falls man komponentenweise multiplizieren, dividieren, exponentieren will, so muss man
stattdessen .*, ./, .^ oder .\ schreiben.
• Man kann Matrizen A auch mit Skalaren s multiplizieren: s * A, A * s und A / s sind
erlaubt.
• Bei den Operationen +, - kann auch eins der Argumente ein Skalar sein. In dem Fall wird er
als Matrix im passenden Format aufgefasst mit allen Einträgen gleich diesem Skalar.
6 7
Beispiel: [1 2; 3 4] + 5 ergibt die Matrix
.
8 9
Des weiteren können Funktionen auf Matrizen angewandt werden:
• Alle elementaren Funktionen wie sin und sqrt können auf Matrizen angewendet werden.
Diese Anwendung erfolgt jedoch komponentenweise (und nicht nach einem Funktionenkalkül);
dies entspricht also den Punkt-Operatoren bei Matrizen (.*, ./, .^ etc.).
– Ist A eine Matrix mit reellen Einträgen, so ist etwa sqrt(A .^ 2) dasselbe wie abs(A)
Quizfrage:
Was macht sqrt(A.*A’.’) für welche Eingaben?
– Dagegen ist im Allgemeinen sqrt(A^2) nicht gleich abs(A), da A^2 das Matrixprodukt
A*A ist, während sqrt davon komponentenweise die Wurzel zieht.
– Die Addition von Matrizen mit Skalaren lässt sich so auffassen: ist s ein Skalar, so
betrachtet man die Funktion ϕs : x 7→ x + s. Dann ist A + s gleich A eingesetzt in ϕs .
– Vorsicht ist geboten bei Vergleichsoperatoren wie ==, <, <=, > und >=, und bei logischen
Operatoren wie & und |. Diese arbeiten ebenfalls Komponentenweise und liefern somit
eine Matrix zurück! Beispiel:
>> A = [1 2; 3 4]; B = [1 2; 4 3];
>> C = [1 2 3; 4 5 6];
>> A == C
??? Error using == > eq
Matrix dimensions must agree .
>> A == B
ans = 1 1
0 0
Wenn getestet werden soll, ob zwei Matrizen gleich sind, muss man isequal verwenden:
13
>> isequal (A , C )
ans = 0
>> isequal (A , B )
ans = 0
>> isequal (A , [1 2; 3 4])
ans = 1
• Es gibt jedoch auch Funktionen, die “richtig” mit Matrizen arbeiten; help elmat gibt eine
Liste von solchen Funktionen.
– Ein Beispiel ist expm, welche das Matrix-Exponential ausrechnet (dies ist definiert als
P∞
k
exp(A) := k=0 Ak! ; man zeigt ähnlich wie bei der “gewöhnlichen” Exponentialfunktion,
dass dies für alle Matrizen absolut konvergiert). Für Diagonalmatrizen stimmt expm mit
exp überein, für andere Matrizen im Allgemeinen jedoch nicht!
(Das Matrixexponential wird z.B. für Differentialgleichungen benötigt.)
– Die bereits oben erwähnte Funktion isequal gehört ebenfalls in diese Kategorie.
Aufgabe 2.10:
1. Erzeuge eine Wertetabelle der Funktion f (x), womit eine 2 × 41-Matrix gemeint ist, in deren
erster Zeile die Zahlen −10, −9.5, −9, . . . , +10 stehen und in der zweiten Zeile die Zahlen
f (−10), f (−9.5), f (−9), . . . , f (10).
(a) f (x) = x5 − 4x4 + 3x2 − 1;
ix
(b) f (x) = e 10 ;
(c) f (x) = (sin x)3 − cos x.
2. Was tun die folgenden Ausdrücke?
(a) A’.’.^A;
(b) diag(diag(A)) + diag(diag(A, 1), 1) + diag(diag(A, 2), 2), falls A eine n ×
n-Matrix ist mit n ≥ 4?
P∞
2
Aufgabe 2.11:
numerisch, dass k=1 k12 = π6 gilt, indem du mit MATLAB die n-te
PnVerifiziere
Partialsumme k=1 k12 ausrechnest. Hierfür solltest du Befehle finden, die bei gesetzter Variable
n den Wert der Partialsumme mit Hilfe von Matrix-Operationen bestimmt.
2.8
Exkurs: Fliesskommazahlen
Der standardmässig verwendete Datentyp ist double: eine Fliesskommazahl mit doppelter Genauigkeit. (Das “doppelt” ist historisch zu sehen im Vergleich zu einer Fliesskommazahl mit “einfacher”
Genauigkeit.)
Es gibt nur endlich viele Fliesskommazahlen. Deswegen können nicht beliebig grosse oder kleine
Werte angenommen werden. Der Bereich darstellbarer Zahlen ist jedoch recht gross, er geht von
−(2 − 2−52 )21023 bis −2−1022 , −0, 0, 2−1022 bis (2 − 2−52 )21023 .
Eine Fliesskommazahl besteht aus einem Vorzeichen s, einer Mantisse m und einem Exponenten
e. Der Wert ist s · m · 2e . Dabei ist s ∈ {−1, 1}, e ∈ {−1022, . . . , 1023}, und m ∈ [1, 2) ist von der
Form 1 + x · 2−52 , wobei x ∈ {0, 1, . . . , 252 − 1} ist.
Zusätzlich gibt es noch spezielle Zustände, wie etwa ±Inf, NaN und ±0 (es gilt 0 == -0 und
NaN ~= NaN, jedoch 1/(+0) = +Inf und 1/(-0) = -Inf).
Da es nur endlich viele Fliesskommazahlen gibt, muss gerundet werden. Für zwei Fliesskommazahlen x1 = s1 · m1 · 2e1 und x2 = s2 · m2 · 2e2 definiert man das Produkt x1 · x2 etwa durch
Runden von s1 s2 · m1 m2 · 2e1 +e2 auf die nächste Fliesskommazahl x3 = s3 · m3 · 2e3 : es gilt also
s3 = s1 s2 , |m1 m2 2e1 +e2 −e3 − m3 | ≤ 2−52 /2 = 2−53 . Insbesondere sind Fliesskommazahloperationen im allgemeinen weder assoziativ noch distributiv.
Die Zahl eps = ε = 2−52 ist die Maschinengenauigkeit: es ist die kleinste Zahl, so dass 1 + ε
als Fliesskommazahl nicht gleich 1 ist. Insbesondere gilt 1 + eps/2 == 1, und deswegen gilt etwa
14
1 + (eps/2 + eps/2) == 1 + eps ~= 1 == (1 + eps/2) + eps/2;
d.h. die Addition ist nicht unbedingt assoziativ. Ebenso gilt
(1 + eps) * ((1 + eps) - 1) == (1 + eps) * eps
~= eps == (1 + 2 * eps) - (1 + eps)
== (1 + eps) * (1 + eps) - (1 + eps) * 1,
da (1 + ε)2−52 eine andere Fliesskommazahl ist als 1 · 2−52 ; d.h. das Distributivgesetz gilt ebenfalls
nicht.
Beim Rechnen mit Fliesskommazahlen ist also eine gewisse Vorsicht geboten! Dies wird noch
ausführlicher in der Numerik-Vorlesung behandelt, für den Kurs reicht es aus zu wissen, dass man
aufpassen muss.
Etwa ist es meist unklug, Fliesskommazahlen direkt zu vergleichen; stattdessen sollte man die
Differenz bilden und schauen, ob diese klein genug ist (etwa |a − b| < 2−30 überprüfen anstelle
a = b).
Aufgabe 2.12:
1. Stelle folgende Zahlen als Fliesskommazahlen dar, soweit dies möglich ist. Falls es nicht exakt
möglich ist, begründe warum das der Fall ist.
(a)
15
(b)
0.5
(c)
0.1
(d)
1
3
(e)
1
256
2. Versuche, die Rechnungen oben nachzuvollziehen. Warum gelten jeweils Gleichheit bzw. Ungleichheit?
3. Wenn die oben genannten Fliesskommazahlen alle möglichen sind, wieviele Fliesskommazahlen vom Typ double gibt es dann? (Hier soll zwischen +0 und -0 unterschieden werden.)
2.9
Native Datentypen
Wie schon erwähnt, gibt es einen Standarddatentypen: double (Fliesskommazahl). Daneben gibt
es jedoch auch noch weitere, wie logical oder char.
Verschiedene Datentypen haben verschiedene Wertebereiche und Genauigkeiten. Es gibt beispielsweise Ganzzahltypen, die ganze Zahlen in jeweils einem gewissen Intervall exakt darstellen
können. Es gibt auch Verbundtypen, mit denen verschiedene Daten in einer Variable gespeichert
werden können – zwei davon werden wir später behandeln (struct und cell).
Neben double gibt es die folgenden Typen:
• logical (Wahrheitswert: 0 für false und 1 für true),
• single (Fliesskommazahl einfacher Genauigkeit),
• char (Zeichen; ganzzahliger Wert in [0, 216 − 1)),
• int8, int16, int32, int64 (Ganzzahlen in [−27 , 27 ), [−215 , 215 ), [−231 , 231 ) oder [−263 , 263 )),
• uint8, uint16, uint32, uint64 (nicht-negative Ganzzahlen < 28 , < 216 , < 232 oder < 264 ),
• function_handle (Funktionenhandle; wird später behandelt),
• struct und cell (erweiterte Datentypen, Verbundtypen; werden später behandelt).
Den Typ eines Ausdrucks A kann man mit class(A) herausfinden. Den Typ ändern (casten)
kann man mit typname(Wert). Beispiele:
>> x = 1;
>> class ( x )
ans = double
>> x = char (65)
x = A
>> class ( x )
15
ans = char
>> int8 (1000)
ans = 127
Beachte:
• das Zeichen A hat den ASCII-Code 65;
• ein int8 kann nur Werte von -128 bis 127 annehmen; da 1000 zu gross ist, wird der grösste
zulässige Wert genommen.
Man kann in bestimmten Fällen Werte verschiedenen Typs in Ausdrücken verwenden.
1. man kann einen intX-Typ nur mit intX-Typen,3 chars oder doubles verknüpfen, und das
Ergebnis ist dann immer vom Typ intX;
2. verknüpft man double mit single – egal in welcher Reihenfolge –, ist das Ergebnis immer
vom Typ single;
3. verknüpft man logical oder char mit single oder double, so ist das Ergebnis ein single
bzw. double;
4. verknüpft man char mit logical, so ist das Ergebnis ein double;
5. verknüpft man char mit intX, so ist das Ergebnis ein intX.
Verknüpft man dagegen ein intX-Typ mit einem intY-Typ mit X6=Y, so erhält man einen Fehler.
Um den Typ eines Ausdruckes zu bestimmen, bietet es sich an, zuerst einen Baum zu dem
Ausdruck zu konstruieren und dann dort Schrittweise den Typ hinzuzuschreiben, ähnlich wie zuvor bei der Bestimmung des Wertes eines Ausdrucks. Um den Wert zu bestimmen ist es sowieso
essentiell, die Typen mit zu beachten. Betrachten wir etwa den Ausdruck 2 * x - (y / 3 & 1).
Diesem Ausdruck entspricht der folgende Baum:
o - OOOO
ooo
OOO
o
o
o
*=
&
===
===
x
2
/<
1
<<
y
1
Hierbei sei x eine Variable vom Typ single und y eine Variable vom Typ char. Man erhält dann
folgende Typen:
gg - WWW
ggggg single WWWWWWWWW
g
g
g
g
WWWW
gggg
* gNNN
p & NN
p
p
N
ppplogicalNNNNN
pp single NNN
p
p
p
p
N
N
pp
pp
x
N
2
/
1
N
p
N
p
ppp double NNNNN
single
double
double
p
p
yp
1
char
double
Eine Zeichenkette in MATLAB ist übrigens eine Matrix mit Einträgen vom Typ char: der
Ausdruck v = ’Test’ liefert eine 1 × 4-Matrix, und es ist etwa v(2) == ’e’. Zeichenketten aneinanderhängen kann man mit Matrixoperationen: so ergibt etwa [’ab’, ’cd’] die 1 × 4-Matrix,
die der Zeichenkette ’abcd’ entspricht.
Der folgende Befehl gibt eine Zeichentabelle aus:
3 Verknüpft man einen intX-Typ mit einem anderen Wert vom Typ intX, so verhält sich MATLAB anders als
die meisten anderen Programmiersprachen: wäre das Ergebnis einer solcher Operation eine Zahl, die nicht mehr im
gültigen Intervall des Datentyps liegt, so wird der kleinste bzw. grösste darstellbare Wert des Types intX genommen,
je nachdem ob das theoretische Ergebnis unterhalb bzw. oberhalb des kleinsten bzw. grössten darstellbaren Wertes
liegt.
16
>> reshape ( char (32 : 127) , 16 , 6) ’
ans =
!"#$%&’()*+ , -./
0123456789:; <= >?
@ABCDEFGHIJKLMNO
PQRSTUVWXYZ [\]^ _
‘ abcdefghijklmno
pqrstuvwxyz {|}~
Quizfrage:
Versuche, Anhand dieses Beispiels die Bedeutung des reshape-Befehls zu erraten.
Aufgabe 2.13:
Überlege, welche Typen die folgenden Ausdrücke haben, und gebe
Wert an.
den 1 2
Verifiziere dies mit MATLAB, ob Typ und Wert stimmen. Sei dazu A die Matrix
.
3 4i
1. A .* A’ - (A.’.^A)’;
2. isequal(A, A’);
3. sum(sum(A - A’)’) == 10;
4. sum(diag(A == A’)) & abs(sum(sum(A)));
5. int8(255) + 1;
6. int32(int8(255) + 1) * 5;
7. logical(255) + 1;
8. int64(double(int64(2)^63) - 1) - int64(2)^63.
2.10
Der Workspace Browser
Der Workspace ist der momentane Arbeitsbereich von MATLAB: er umfasst alle gerade definierten
Variablen mit Informationen zu diesen, sprich dem Format der Matrix und dem Typ der Einträge.
Eine Liste aller Variablen im Workspace kann mit who ausgegeben werden, und der Workspace
kann mit clear in den leeren Zustand zurückgesetzt werden.
Beispiel:
>> x = 1;
>> clear
>> y = int16 (5);
>> z = 1 | 2;
>> who
Your variables are :
y z
>> class ( z )
ans = logical
Eine weitere Übersicht bietet der Befehl whos an: er zeigt nicht nur die Namen der Variablen
im Workspace, sondern auch ihr Format (also Grösse der Matrix), ihren Speicherbedarf (in Bytes)
sowie ihren Datentyp:
>> A = rand (5 , 10);
>> t = ’ blah ’;
>> whos
Name
Size
A
5 x10
t
1 x4
y
1 x1
z
1 x1
Bytes
400
8
2
1
Class
double
char
int16
logical
17
Attributes
Alternativ kann man den Workspace im Workspace Browser betrachten; dies ist das Fenster,
was sich normalerweise rechts oben vom Kommandozeilenfenster befindet. Es sieht dann etwa so
aus wie das rechte Fenster hier:
Neben dem Namen der Variable wird der Wert angezeigt, bzw. das Format inklusive Datentyp
bei Matrizen. Wenn man nach rechts scrollt, kann man bei Arrays noch den grössten und kleinsten
Eintrag sehen. Klickt man eine Matrix (Zeichenketten gelten hier nicht als Matrix) doppelt an,
öffnet sich der Variable Editor (links im Bild). Dort kann man eine Matrix inspizieren und die
Werte ändern. Bei anderen Variablen (1 × 1-Matrizen und Zeichenketten) kann man den Wert
editieren, indem man den Wert der Variable markiert und dann nochmal anklickt.
Aufgabe 2.14: Erzeuge die Matrix

0 0
0
0 0 0
0 0
0
0 0 0

0 0 1.23456 0 0 0

0 0
0
0 0 0

0 0
0
0 0 0

0 0
0
0 0 0

0 0
0
0 0 0

0 0
0
0 0 0

0 0
0
0 0 0
0 0
0
0 0 0
0
0
0
0
0
0
0
0
0
0
0 0
0 0
0 0
0 0
0 0
42 0
0 0
0 0
0 0
0 0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
0
23
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0

0
0 

0 

0 

9.8765

0 

0 

0 

0 
0
vom Format 10 × 18 in MATLAB, indem du zuerst eine Matrix dieser Grösse, bestehend nur aus
Nullen erzeugst, und dann mit Hilfe des Variable Editors die Zahlen 6= 0 einfügst.
Bisherige Lernziele
• Wissen was ein Ausdruck in MATLAB ist
• Typ und Wert eines Ausdrucks bestimmen können, ohne ihn in MATLAB einzugeben
• (komplexe) Matrizen erstellen können und auf Elemente und Teilmatrizen zugreifen können
• Matrizen manipulieren, u.a. Zeilen- und Spaltenoperationen, Verknüpfen von Matrizen, etc.
• Wissen, wo Probleme bei der Verwendung von Fliesskommazahlen liegen
18