›  Demo-MAT1: MATLAB Tutorial - Der Einstieg für Anfänger

MATLAB ist eine kommerzielle Entwicklungsumgebung des Unternehmens Mathworks für die Modellierung und Simulation mathematischer und speziell numerischer Probleme und verwendet eine eigene Programmiersprache, die ebenfalls MATLAB heißt. MATLAB bietet Funktionalität zum einfachen Erstellen von Arrays und Matrizen und für die visuelle Darstellung von Funktionen und Daten, sowie für die Umsetzung mathematischer Algorithmen, die physikalische Probleme modellieren, z.B. aus dem Bereich des Maschinenbaus oder der Elektrotechnik. Das vorliegende Tutorial vermittelt die Grundlagen der MATLAB-Sprache und verwendet MATLAB 2020 als Entwicklungs­umgebung. Die Syntax der Sprache (Variablen, Operatoren, Eingabe, Ausgabe, Arrays, Matrizen, Funktionen und Plots) wird mit Hilfe kleiner Beispiele veranschaulicht, die wir interaktiv ausführen oder als MATLAB-Skripte speichern. Die hier verwendeten Beispiele können auch in der kostenlos verfügbaren Software Octave geschrieben und ausgeführt werden.

MATLAB Umgebung

Um MATLAB verwenden und MATLAB Skripte ausführen zu können, ist eine funktionierende MATLAB oder Octave Installation erforderlich. Eine MATLAB Testversion kann auf der Mathworks Webseite heruntergeladen werden. Falls Sie Student sind, stellt Ihre Hochschule Ihnen ggf. auf andere Art und Weise einen MATLAB-Zugang zur Verfügung.

MATLAB's Editor-Tab ist in vier Fenster organisiert, die für die Entwicklung und Ausführung von Skripten verwendet werden. Die Anordnung dieser Fenster kann über das Layout-Menü angepasst werden.

• Datei-Browser: zeigt die Ordner und Dateien an, die MATLAB-Skripte enthalten. Hier werden neue Ordner und Skripte erstellt.
• Workspace: zeigt die Variablen und Funktionen der laufenden Skripte an.
• Editor: zeigt den Inhalt der Skript-Dateien an. Hier wird der MATLAB-Quellcode erstellt.
• Kommandofenster (Command Window): zeigt die MATLAB-Befehle an, wird für die Eingabe und Ausführung von Befehlen verwendet, sowie als allgemeines Ausgabefenster.

MATLAB kann auf verschiedene Arten verwendet werden:

• Interaktiver Modus: MATLAB wird im interaktiven Modus verwendet, indem man Befehle direkt in das Kommandofenster eingibt. Die Ausgabe wird ebenfalls im Kommandofenster angezeigt. Der interaktive Modus ist nützlich für kleinere Programme und um Codefragmente zu testen.
• MATLAB Skripte: Größere MATLAB-Programme sind Sammlungen von MATLAB-Skripten, die in einem gemeinsamen Ordner gespeichert werden. Dieser Ordner kann an einem beliebigen Speicherort abgelegt werden, muss jedoch zum MATLAB Pfad hinzugefügt werden, mit Hilfe des HOME > Set Path Menüpunktes.
• MATLAB LiveScript: LiveScripts bieten erweiterte Funktionalität für Inline-Dokumentation. Sie haben die Dateiendung *.mlx und bestehen aus Codezellen, die den ausführbaren Code enthalten, und Markdownzellen, die formatierte Erläuterungen des Codes speichern. Die Erstellung und Verwendung von LiveScripts wird im nächsten Teil des Tutorials: MATLAB LiveScripts erstellen und verwenden gezeigt.

Ein MATLAB-Skript ist eine Textdatei mit der Dateiendung *.m, die die Befehle des MATLAB-Programms enthält. Die Namen von MATLAB-Skripten dürfen nur aus Zeichen, Zahlen und Unterstrich (_) bestehen. Gültige Skript-Namen sind z.B. myscript1.m, myscript2.m, myfun1.m, myfun2.m, nicht gültig: myscript-1.m oder myscript+1.m.
MATLAB-Skripte werden mit Hilfe der Befehle des EDITOR > FILE Menüs erstellt: New, Open, Save, und mit Hilfe der Befehle des EDITOR > RUN-Menüs ausgeführt: Run, Run and Advance, Run Section. Besonders hervorzuheben ist der Befehl Run Section: damit kann man einen einzelnen Abschnitt eines Skripts ausführen, wobei Abschnitte durch zwei Prozentzeichen %% markiert werden.

Erste Zeilen in MATLAB

MATLAB Befehle bzw. Anweisungen sind: Deklarationen und Zuweisungen von Variablen, Operationen mit Variablen, Eingabe- und Ausgabe-Befehle, Befehle für die Programm­ablauf­steuerung (Verzweigungen und Schleifen) und Funktions­aufrufe, die definierte Teilaufgaben ausführen. MATLAB Anweisungen können mit einem Semikolon beendet werden oder nicht. Falls am Ende einer Anweisung kein Semikolon steht, wird der Inhalt der jeweiligen Variablen automatisch ausgegeben. Falls am Ende einer Anweisung ein Semikolon steht, wird die Anweisung keine Ausgabe erzeugen. Ehe wir die Syntax der MATLAB-Sprache weiter untersuchen, stellen wir einige Befehle vor, die häufig benötigt werden, um den Workspace und das Kommandofenster überschaulich und konsistent zu halten.

• clear – Löscht die Variablen des Workspace. Man kann entweder alle oder nur ausgewählte Variablen löschen. Nützlich, wenn man mehrere Skripte entwickelt, und dieselben Variablen-Namen wiederverwendet.
• clc – Löscht den Inhalt des Kommandofensters, Befehle und Ausgabe. Nützlich bei Demos und Vorführungen, wo man mit einem leeren Fenster beginnen möchte.
• format compact – Zeigt den Inhalt des Kommandofensters kompakt an, mit weniger Leerzeilen. Mit format long werden alle Kommazahlen mit doppelter Genauigkeit (d.h. mit mehr Nachkommastellen) angezeigt.
• help – Der Befehl help startet die MATLAB Hilfe. Falls man help gefolgt von dem Nahmen eines Befehls eingibt, wird die Hilfe zu dem betreffenden Befehl angezeigt.

Beispiel: Finde heraus, was der Befehl clc bewirkt.

Wenn wir "help clc" in das Kommandofenster eingeben, wird die Dokumentation des Befehls wie abgebildet angezeigt.

Hello World-Programm in MATLAB

Ein Hello-World-Programm ist das kleinste lauffähige Programm in einer Programmiersprache und gibt den Text "Hello World" in die Default-Ausgabe (hier: das Kommandofenster) aus. Wir erstellen das Programm zunächst im interaktiven Modus und dann als Skript.

Interaktiver Modus
Im interaktiven Modus verwenden wir nur das Kommandofenster. Befehle werden nach dem Prompt-Zeichen (>>) eingegeben und mit der ENTER-Taste bestätigt.

Wir geben den Befehl text='Hello World' in das Kommandofenster ein und bestätigen mit ENTER. Wie in der Abbildung zu sehen ist, werden der Variablen-Name (hier: text) und ihr Inhalt (hier: Hello World) im Kommandofenster angezeigt. Als Nächstes geben wir den Befehl disp('Hello World') ein und bestätigen durch Drücken der ENTER-Taste. Die Zeichenkette 'Hello World' wird wieder angezeigt, diesmal jedoch ohne den Namen der Variablen auszugeben.

Skript-Modus
Im Skript-Modus erstellen wir ein neues Skript mit den Namen test_hello.m, schreiben die MATLAB-Befehle in das Skript, speichern die Datei und führen das Skript aus, indem wir den RUN-Button in der Menüleiste anklicken.

Nach Erstellen der Skript-Datei, Editieren des Quellcodes und Ausführen des Skriptes sieht die MATLAB-Plattform wie unten abgebildet aus.

Der Code beginnt in Zeile 1 mit einem Kommentar (eingeleitet durch das "%"-Symbol), der den Namen der Skript-Datei angibt. Die weiteren Zeilen sind zum besseren Verständnis ebenfalls kommentiert. In Zeile 2 und 3 wird der Code für das Zurücksetzen des Workspace und des Kommandofensters eingefügt. In Zeile 4 erstellen wir eine neue Variable "text" und weisen ihr den Wert 'Hello world' zu. In Zeile 5 geben wir den Text 'Hello World' mit Hilfe der Funktion disp() direkt aus.

 % Script: test_hello.m
 clear;clc; % Clear workspace and command window 
 format compact % Compactify command window output
 text = 'Hello World' 
 disp('Hello World!'); 

Kommentare in MATLAB

Kommentare in MATLAB werden durch ein Prozentzeichen ("%"-Symbol) eingeleitet, gefolgt von Text. Kommentare werden für die Dokumentation des Quellcodes eingesetzt und vom System nicht ausgeführt. Zwei Prozent-Symbole "%%" markieren einen Abschnitt. Abschnitte können separat mit Hilfe des RUN SECTION-Menüpunktes ausgeführt werden, dabei ist ggf. die richtige Reihenfolge zu beachten.

 %% Abschnitt 1 
 % Kommentar 1: Erster Kommentar für Abschnitt 1 
 text = 'Let''s start simple' % Weise der Variablen text einen Wert zu 
 %% Abschnitt 2 
 % Kommentar 2: Erster Kommentar für Abschnitt 2 
 a = 10 % Weise der Variablen a den Wert 10 zu 
 b = 20 % Weise der Variablen b den Wert 20 zu 

Variablen und Datentypen

Variable sind benannte Speicherplätze, in denen die Daten des Programms gespeichert werden. Variablen werden in MATLAB deklariert, sobald man ihnen einen Wert zuweist. Der Datentyp (Zahl, Zeichenkette etc.) wird automatisch durch MATLAB vergeben. Alle numerischen Werte in MATLAB (ganze Zahlen und Fließkommazahlen) werden intern als Fließkommazahlen mit doppelter Genauigkeit gespeichert. Die Kenntnis des Datentyps der Variablen ist wichtig, da der Datentyp die Menge der Operationen bestimmt, die man mit den Variablen ausführen kann. Zum Beispiel kann man eine ganze Zahl und eine Fließkommazahl addieren, nicht jedoch eine ganze Zahl und eine Zeichenkette.

Beispiel: Variablen verwenden
Das Beispiel zeigt, wie man Variablen deklariert und Operationen darauf ausführt. Zu Beachten ist dabei, dass das +-Symbol unterschiedliche Operationen bezeichnet: in Zeile 3 bezeichnet es die Addition von Zahlen, in Zeile 5, das Zusammenfügen von Zeichenketten.

Nach Ausführen des Skriptes test_variables.m ist die Ausgabe im Kommandofenster wie abgebildet.

Skript	Ausgabe
% test_variables.m a = 10; b = 20.5; sum = a + b s1 = "apples";s2 = "pears"; text1 = s1 + "+" + s2 text2 = replace(text1, '+',' or ')

Erläuterung des Quellcodes:

• Zeile 2: Deklariere zwei Variablen a, b und weise ihnen Werte zu. Da die Zuweisungen mit einem Semikolon abgeschlossen werden, erfolgt keine Ausgabe im Kommandofenster.
• Zeile 3: Addiere die beiden Variablen und speichere das Ergebnis in der Variablen sum.
• Zeile 4: Deklariere zwei String-Variablen s1 und s2.
• Zeile 5: Füge die beiden Zeichenketten in einer neuer Zeichenkette zusammen.
• Zeile 6: Ersetze das "+"-Zeichen mit der Zeichenkette ' or '.

Datentypen

MATLAB unterstützt die üblichen Datentypen, die intern durch Klassen abgebildet werden:

• Numerische Datentypen: int, single, double
• Boolesche Datentypen: logical
• Datentypen für Zeichen und Zeichenketten: char, string

Um den Datentyp und die Größe von Variablen herauszufinden, werden die Befehle whos und class verwendet. Mit whos wird der Datentyp und die Größe von Workspace-Objekten zurückgegeben. Mit class wird der Datentyp bzw. die Klasse einer Variablen bestimmt.

Skript	Ausgabe
a = 10; b = 20.5; whos a whos b

Zeichenketten bzw. String-Variablen

String-Variablen in MATLAB werden entweder durch die Klasse "string" oder als "character array" abgebildet. Wenn man eine Zeichenkette mit Hilfe von doppelten Hochkommas deklariert, z.B. text = "Hello", wird sie intern als ein Array aus einzelnen Zeichen hinterlegt. Wenn man eine Zeichenkette mit Hilfe von einfachen Hochkommas deklariert, z.B. text = 'Hello', wird sie intern als String abgelegt. Deklariert man Zeichenketten als String, stehen eine Reihe nützlicher Funktionen für die Textbearbeitung zur Verfügung.

Skript	Ausgabe
text1 = "Hello" whos text1 text2 = 'from Kaiserslautern' whos text2

Eingabe und Ausgabe

Der Inhalt von Variablen kann im Workspace eingesehen werden oder im Kommandofenster ausgegeben werden.

Ausgabe im Kommandofenster

Es gibt drei Wege, um den Inhalt einer Variablen im Kommandofenster auszugeben.

• Semikolon weglassen: Schreibe den Namen der Variablen in eine neue Zeile, ohne abschließendes Semikolon. Oder: lasse das Semikolon am Ende einer Zuweisung weg.
• Verwende disp()-Funktion. Diese Funktion erwartet als Argument eine Variable, einen Vektor oder eine Matrix und gibt sie aus, ohne den Namen der Variablen mit auszugeben.
• Verwende fprintf()-Funktion. Diese Funktion erzeugt eine formatierte Ausgabe mit Hilfe von Platzhaltern für die einzufügenden Variablen. In unserem Beispiel wird an die Stelle wo %d steht, der Wert der Variablen a eingefügt.

Beispiel: Ausgabe im Kommandofenster
In diesem Beispiel wird die Summe zweier Variablen berechnet und das Ergebnis im Kommandofenster ausgegeben.

Skript	Ausgabe
% test_output.m a = 10; b = 20; sum = a + b; % (1) No semicolon disp('(1) Output by typing variable name') sum % output: sum = 30 % (2) Use disp disp('(2) Output using disp()') disp([a b sum]) % output: 10 20 30 % (3) Use fprintf for formatted output disp('(3) Output using fprintf') % output: a = 10, b = 20, Sum = 30 fprintf('a = %d, b = %d, Sum = %d\n', a, b, sum)	Beim Ausführen des Skriptes test_output.m sieht die Ausgabe wie abgebildet aus.

Eingabe über das Kommandofenster

Falls man ein Skript für nicht-technische Anwender schreibt, ist es nützlich, die Eingabeparameter über das Kommandofenster oder einen Eingabedialog abzufragen. In das Kommandofenster eingegebene Werte können mit Hilfe der input(prompt)-Funktion gespeichert werden.

Skript	Ausgabe
% Display a prompting text prompt = 'Enter a: '; % Read input a = input(prompt); prompt = 'Enter b: '; b = input(prompt); sum = a + b; fprintf("Sum = %.2f\n", sum);

Eingabedialog erstellen

Ein Eingabedialog kann wie abgebildet mit Hilfe der Funktion inputdlg erstellt werden. Die Funktion erwartet vier Argumente:

• prompt – die Beschriftungen (Labels) der Eingabefelder
• dlgtitle – der Titel des Dialogfensters
• windowsize – die Größe des Dialogfensters
• definput – gibt den Default-Wert der Eingabefelder an. Das Argument für definput muss dieselbe Anzahl an Elementen haben wie prompt.

Die Funktion gibt ein Array aus Zeichenketten "answer" zurück, das die eingegebenen Werte speichert.

Skript	Ausgabe
prompt = {'Enter a:', 'Enter b:'}; dlgtitle = 'Input'; windowsize = [1 50]; definput = {'10','20'}; answer = inputdlg(prompt, dlgtitle, windowsize, definput) a = str2num(answer{1}) b = str2num(answer{2})

Programmablaufsteuerung

Die Befehle zur Programm­ablaufsteuerung werden verwendet, um abhängig von einer Bedingung den einen oder anderen Codeabschnitt auszuführen (bedingte Verzweigungen, if-else), oder um einen Codeabschnitt mehrfach zu wiederholen (while-loop, for-loop). Diese Befehle werden auch unter dem Begriff Kontrollstrukturen zusammengefasst, da sie den Programmablauf steuern bzw. kontrollieren. Kontrollstrukturen sind mehrzeilige Befehle, die mit dem Schlüsselwort end abgeschlossen werden müssen, um das Ende des Codeblocks anzuzeigen.

Verzweigungen

Eine bedingte Verzweigung ist eine Kontrollstruktur, die festlegt, welcher von zwei (oder mehr) Anweisungsblöcken, abhängig von einer (oder mehreren) Bedingungen, ausgeführt wird. Bedingte Verzweigungen werden in MATLAB, wie in fast allen Programmiersprachen, mit der if-else-Anweisung beschrieben. Das Schlüsselwort "elseif" bedeutet: "Wenn die vorherigen Bedingungen nicht zutreffen, versucht es mit dieser Bedingung" und das Schlüsselwort "else" fängt alles ab, was von den vorhergehenden Bedingungen nicht erfasst wird.

Beispiel: Ausgabe eines Textes abhängig von der Größe der eingegebenen Zahl
In diesem Beispiel wird der Anwender um die Eingabe einer Zahl gebeten. Abhängig von der Größe der eingegebenen Zahl erfolgt eine Ausgabe ins Kommandofenster. In Zeile 5 wird die Bedingung"a < 30" ausgewertet: falls sie wahr ist, wird die Anweisung in Zeile 5 ausgeführt und der Programmablauf wird in der ersten Zeile nach der if-else-Anweisung fortgesetzt.

Skript	Ausgabe
% test_ifelse.m prompt = 'Enter number < 100: '; a = input(prompt); disp('Your number:'); disp(a); % display it if a < 30 disp('Small number!') elseif a < 80 disp('Medium number!') else disp('Large number!') end

Schleifen

Schleifen ermöglichen es, Anweisungen wiederholt auszuführen, und zwar so lange, wie eine Ausführungsbedingung erfüllt ist. MATLAB verfügt über zwei Schleifenbefehle: while-Schleife und for-Schleife. Um den Kontrollfluss in Schleifen zu steuern, werden zusätzlich zu der Ausführungsbedingung die Anweisungen break und continue eingesetzt. Man kann in vielen Fällen eine for-Schleife als while-Schleife formulieren und umgekehrt. Sobald man verschachtelte Schleifen verwenden muss, z.B. um die Zeilen und Spalten einer Matrix auszulesen, ist die Verwendung von for-Schleifen knapper und übersichtlicher.

while-Schleife

Eine while-Schleife wiederholt die Anweisungen in einem Block, solange wie eine Ausführungsbedingung als wahr ausgewertet wird.

Beispiel: Berechne die Summe der ersten n Zahlen
In diesem Beispiel wird die Summe der ersten n Zahlen : sum = 1+2+...+n berechnet. Zunächst wird in Zeile 2 eine Zählvariable i mit 1 initialisiert. In Zeile 3 wird die Schleifenbedingung "i <= 5" überprüft. Falls "wahr", werden die Anweisungen in Zeilen 4-6 ausgeführt: gebe Wert von i aus, addiere Wert von i zur Summe hinzu, erhöhe Wert von i um 1. Danach wird die Schleifenbedingung erneut überprüft und falls wahr, wird die Schleife wiederholt.

Skript	Ausgabe
sum = 0; i = 1; % (1) Initialize counter i while i <= 5 % (2) Check condition fprintf("%d + \n", i); sum = sum + i; i = i+1; % (3) Increment counter end

for-Schleife

Die for-Schleife erlaubt, Anweisungen wiederholt auszuführen, indem sie für festgelegte Zählvariablen Startwert, Endwert und Schrittweite festlegt.

Beispiel: Berechne Summe der ersten n Zahlen

Hier berechnen wir die Summe der ersten n Zahlen: sum = 1+2+...+n mit Hilfe einer for-Schleife. In Zeile 3 wird die Zählvariable i mit 1 initialisiert, während des Durchlaufs mit Schrittweite 2 erhöht und läuft bis zum Endwert n.

Skript	Ausgabe
n = 6; sum = 0; % Start at index 1, use increment 2, end at index n for i=1:2:n fprintf("%d + \n", i); sum = sum + i; end fprintf("---\n"); fprintf("%d\n", sum);

Vektoren

Vektoren bzw. eindimensionale Arrays sind Listen von Datenobjekten, die im Arbeitsspeicher zusammenhängend abgelegt werden. Ein einzelnes Datenobjekt wird Element des Arrays genannt. In MATLAB können Vektoren als Zeilen- oder Spalten-Arrays deklariert werden, dies wird durch das Trennzeichen festgelegt, mit dem die Elemente aufgelistet werden. Zum Beispiel deklariert x = [1, 4, 9] einen Zeilen-Vektor, und x = [1; 4; 9] einen Spaltenvektor. Die Elemente eines Vektors werden über einen Index ausgewählt, d.h. ihre Position in der Liste, und in MATLAB beginnt dieser bei 1. Um das i-te Element aus einem Vektor x zu holen, schreibt man x(i) - hier mit runden Klammern.

Vektoren können auf unterschiedliche Arten erzeugt werden: durch Aufzählen ihrer Elemente in eckigen Klammern, mit Hilfe von Funktionen (Doppelpunkt-Operator, linspace, repmat), durch Zuweisen der Elemente in einer Schleife.

Beispiel: Erzeuge Vektor mit 5 Elementen
Wir erstellen einen Zeilenvektor mit 5 Elementen, geben das zweite Element des Vektors aus, dann die Elemente zwei bis 4, und ändern den Wert des dritten Elementes.

Skript	Ausgabe
x = [1 4 9 16 25] disp('Element 2 is: ') disp(x(2)) disp('Elements from 2 to 4 are:') disp(x(2:4)) % Change element 3 to be sum of element 1 and 2 disp('Vector x after changing 3rd element:') x(3) = x(1) + x(2)

Beispiel: Bestimme Speichergröße und Länge eines Vektors
Mit Hilfe des Befehls whos, gefolgt vom Namen eines Vektors, können wir seine Dimensionen, seine Speichergröße und seinen Datentyp herausfinden, hier: x ist eine Matrix mit einer Zeile und 5 Spalten (also ein Vektor), hat die Klasse double und verwendet 40 Bytes Speicherplatz.

Skript	Ausgabe
x = [1 4 9 16 25] disp('Whos x:') whos x disp('Size of x:') sz = size(x) disp('Length of x:') n = length(x)

Vektoren aus Sequenzen

Bei der Entwicklung numerischer oder statistischer Anwendungen benötigt man oft regelmäßige Folgen (Sequenzen bzw. äquidistante Vektoren), wie z.B. 2, 4, 6, 8, 10 oder 0, 0.1, 0.2,..., 1. In MATLAB werden Sequenzen mit Hilfe des Doppelpunkt-Operators oder mit Hilfe der Funktion linspace erstellt. Der Ausdruck x = 1:n erzeugt den Vektor [1, 2, ..., n]. Allgemeiner erzeugt der Ausdruck x = a:h:b den Vektor [a, a+h, a+2*h, ..., b] mit Anfangswert a, Schrittweite h und Endwert b, und die Funktion x = linspace(a, b, n+1) denselben Vektor [a, a+h, a+2*h, ..., b], mit Schrittweite h = 1/n.

a = 0; b = 1; n = 10; h = 1/n;
x = linspace(a, b, n+1) % Ausgabe: 0, 0.1, 0.2,..., 1
x = a:h:b % Ausgabe: 0, 0.1, 0.2,..., 1

Vektoren aus Zufallszahlen

Ein weiterer Anwendungsfall zum Erstellen von Vektoren ist die Erzeugung von Zufallszahlen mit Hilfe der Funktionen rand, randi, randn. rand erzeugt gleichmäßig verteilte Zufallszahlen des Datentyps double in dem offenen Intervall (0, 1). Abhängig von den Argumenten, die beim Funktionsaufruf übergeben werden, wird eine Matrix, ein Spaltenvektor, ein Zeilenvektor, oder eine einzelne Zahl erzeugt. randi erstellt gleichmäßig verteilte ganzzahlige Zufallszahlen c, als Matrix, Spaltenvektor oder Zeilenvektor.

% 3x5 Matrix aus Zufallszahlen in (0, 1)
r_mat = rand(3, 5)
% Spaltenvektor aus 5 Zufallszahlen in (0, 1)
r_col = rand(5, 1)
% Zeilenvektor aus 5 Zufallszahlen in (0, 1)
r_row = rand(1, 5) 
a = 10; b = 20; n = 5;
% Zeilenvektor aus double-Zufallszahlen in (a, b)
r_row_10_20 = rand(1, n)*(b-a) + a 
% Zeilenvektor aus int-Zufallszahlen in (a, b)
r_int_10_20 = randi([a, b],1, n)

Operationen mit Vektoren

MATLAB unterstützt zwei Arten von Operationen für Vektoren: (1) Vektor-Operationen, d.h. mathematische Operationen entsprechend den Regeln der linearen Algebra und (2) Array-Operationen, die elementweise durchgeführt werden. Elementweise Operationen werden durch die Verwendung des Punkt-Operators (engl. dot-Operator) ausgezeichnet.
x * y bezeichnet die mathematische Multiplikation von Vektoren bzw. Matrizen, und funktioniert für Vektoren nur, falls x eine 1xn Matrix bzw. ein Zeilenvektor und y eine nx1 Matrix bzw. ein Spaltenvektor ist.
x .* y bezeichnet die elementweise Multiplikation und funktioniert nur, wenn x und y Vektoren derselben Länge sind.

Vektor-Operationen und elementweise Operationen sind für Addition und Subtraktion gleich, so dass die Operatoren .* und .- nicht benötigt werden.

Skript	Ausgabe
x = 0:2:8 % x = 0,2,4,6,8 % Add 1 to each element y = x + 1 % y = 1,3,5,7,9 % Multiply x and y elementwise z = x .* y % z = 0*1+2*3+...+8*9 % Slicing % Extract a slice from 2 to 5 xslice = x(2:4) % x1 = 2,4,6

Matrizen

Die Daten in vielen numerischen MATLAB-Programmen werden in ein- und zweidimensionalen Arrays gespeichert, d.h. Vektoren und Matrizen. Variablen and Vektoren werden intern ebenfalls als Matrizen abgebildet.

Matrizen können auf unterschiedliche Arten erzeugt werden: (1) durch explizites Aufzählen ihrer Elemente in eckigen Klammern, (2) mit Hilfe vordefinierter MATLAB-Funktionen, oder (3) mit Hilfe von Schleifen.

(1) Erstelle Matrix durch Angabe der Elemente
Wird eine Matrix durch Angabe der Elemente erstellt, müssen Zeilen-Elemente mit einem Komma und Spalten mit einem Semikolon getrennt werden.

(2) Erstelle Matrix mit Hilfe vordefinierter Funktionen
Viele mathematische Probleme verwenden Matrizen, die mit festgelegten Werten initialisiert werden, wie z.B. die Einheitsmatrix, die 1en auf der Diagonale hat und sonst nur 0-Werte. In MATLAB können Funktionen wie zeros(), ones() or eye() verwendet werden, um diese Matrizen zu definieren.

(3) Erstelle Matrix mit for-Schleifen
Das Erstellen einer Matrix mit for-Schleifen ist dann notwendig, wenn es sich um große Matrizen handelt, und wenn die Größe und die Werte sich dynamisch ändern bzw. von Parametern abhängen. In diesem Fall wird empfohlen, den maximal benötigten Speicherplatz mit Hilfe der zeros()-Funktion zu reservieren.

Auf die Elemente einer Matrix wird über einen Zeilenindex und einen Spaltenindex zugegriffen, beide beginnen bei 1. Mit dem Ausdruck A(i, j) wird auf das Element in Zeile i und Spalte j einer Matrix A zugegriffen. A(1, 1) ist das Element in Zeile 1 und Spalte 1, A(1, 2) das Element in Zeile 1 und Spalte 2 etc.

Beispiel: Erzeuge Matrix durch explizites Aufzählen
In diesem Beispiel erzeugen wir eine Matrix mit zwei Zeilen und drei Spalten, geben sie mit disp aus, und bestimmen nachher Typ und Größe der Matrix mit whos. Der whos-Befehl zeugt, dass eine 2x3 Matrix angelegt wurde und diese 48 Bytes Speicherplatz benötigt.

Skript	Ausgabe
A = [1 2 3;4 5 6]; % 2 rows, 3 cols disp('Matrix A:') disp(A) whos A

Beispiel: Erzeuge Matrizen mit Hilfe von MATLAB-Funktionen
In diesem Beispiel erstellen wir drei Matrizen: A1 ist eine Matrix mit m Zeilen und n Spalten, deren Elemente mit 0 initialisiert werden. A2 ist eine Matrix deren Elemente alle mit 1 initialisiert werden. I_n ist die Einheitsmatrix mit n Zeilen und n Spalten, mit 1 auf der Diagonale und 0 an allen anderen Positionen.

Skript	Ausgabe
m = 2; n = 3; % mxn matrix with elements initialized to 0 A1 = zeros(m, n) % mxn matrix with elements initialized to 1 A2 = ones(m, n) % nxn identity matrix with 1 on diagonal I_n = eye(n, n)

Beispiel: Extrahiere Elemente aus einer Matrix
Die Elemente einer Matrix werden über ihren Index extrahiert. In diesem Beispiel extrahieren wir das element mit Zeilenindex 2 und Spaltenindex 3 und speichern es in einer Variablen el23, danach extrahieren wir die Zeilen 1 bis 3 und alle Spalten und speichern sie in einer neuen Matrix A1, zuletzt extrahieren wird die Zeilen 2 und 3 und Spalten von 1 bis 2 uns speichern das Ergebnis is einer neuen Matrix A2.

Skript	Ausgabe
A = [1 2 3; 4 5 6; 7 8 9] el23 = A(2,3) % el23 = 6: % Extract rows 1 and 3 A1 = A([1,3],:) % A1 = [1 2 3; 7 8 9] % Extract rows 2 and 3 and and columns 1 and 2 A2 = A(2:3,1:2) % A2 = [4 5; 7 8]

Operationen mit Matrizen

MATLAB unterstützt zwei Arten von Operationen für Matrizen: (1) Matrix-Operationen, d.h. mathematische Operationen entsprechend den Regeln der linearen Algebra und (2) Array-Operationen, die elementweise durchgeführt werden. Elementweise Operationen werden durch die Verwendung des Punkt-Operators (engl. dot-Operator) ausgezeichnet.
A * B bezeichnet die mathematische Multiplikation von Matrizen, und funktioniert nur, falls die Anzahl der Spalten von A mit der Anzhl der Zeilen von B gleich sind, z.B. A eine mxn und B eine nxp Matrix ist.
A .* B bezeichnet die elementweise Multiplikation und funktioniert nur wenn A und B Matrizen mit derselben Anzahl von Zeilen und Spalten sind.

Matrix-Operationen und elementweise Operationen sind für Addition und Subtraktion gleich, so dass die Operatoren .* und .- nicht benötigt werden.

Beispiel: Operationen mit Matrizen
Dies Beispiel zeigt häufig verwendete Operationen mit Matrizen: Transposition, Addition, Matrix-Multiplikation und elementweise Multiplikation. Die Transponierte einer Matrix wird erstellt indem man A' schreibt, d.h. den Namen der Matrix, gefolgt von einem einfachen Hochkomma. Alternativ kann auch die Funktion transpose() verwendet werden, und transpose(A) erzeugt die transponierte Matrix.

Skript	Ausgabe
% Transpose a matrix A = [1 2; 3 4] B = A' % B = [1 3; 2 4] % Matrix addition A = [1 2; 3 4];B = [1 3; 2 4]; C = A + B % C = [2 5; 5 8] % Matrix multiplication A = [1 2; 3 4];B = [1 3; 2 4]; D = A * B % D = [5 11; 11 25] % Elementwise multiplication A = [1 2; 3 4];B = [1 3; 2 4]; E = A .* B % E = [1 6; 6 16]

Funktionen

Eine Funktion ist ein wiederverwendbarer Codeblock, der nur ausgeführt wird, wenn er aufgerufen wird. Funktionen werden einmal definiert und können dann beliebig oft aufgerufen werden. Man kann Daten oder sogenannte Parameter an eine Funktion übergeben. Eine Funktion kann auch Daten/Parameter zurückgeben. Funktionen kommen auf zweierlei Arten zum Einsatz: zum einen verwendet man vorhandene Funktionen, die von MATLAB bereitgestellt werden, um gewisse Aufgaben durchzuführen. Zum anderen entwickelt man eigene Funktionen für Teilaufgaben und strukturiert damit größere Programme.

MATLAB bietet vordefinierte Funktionen für Matrix-Bearbeitung (zeros, ones, eye, diag, ...), Erstellen von Grafiken( plot, surf, quiver, contour, ...) und zur Berechnung der Lösungen gewöhnlicher oder partieller Differentialgleichungen, sogenannte Solver (ode45, ode15s, pdepe, ...) und viele mehr. Um diese effizient nutzen zu können, ist ein Verständnis für die Funktionsweise und Verwendung von Funktionen erforderlich.

Benutzerdefinierte Funktionen können als globale, lokale oder anonyme Funktionen definiert werden, und die Art der Definition legt den Geltungsbereich fest:

• Globale Funktion: Funktion wird in einer eigenen m-Skript-Datei gespeichert.
• Lokale Funktionen: Funktion wird inline in dem Skript gespeichert, wo sie auch verwendet wird.
• Anonyme Funktion: Funktion wird als Variable des Typs type function_handle definiert.

(1) Globale Funktionen

In den meisten Fällen ist es sinnvoll, die Funktion in ihrer eigenen Skript-Datei zu speichern. Dies sichert die Wiederverwendbarkeit der Funktion in anderen Skripten.
Ein Funktions-Skript ist eine MATLAB m-Datei die nur die Definition einer Funktion enthält und nicht ausführbar ist. Das Funktions-Skript muss denselben Namen haben wie die Funktion, die es enthält, z.B. muss eine Funktion mit dem Namen myfun1 in einem Skript mit dem Namen myfun1.m gespeichert werden.
Wird eine Funktion in einer eigenen Skript-Datei gespeichert, kann sie in anderen Skripten verwendet werden. Der Name der Funktion sollte in diesem Fall eindeutig sein, um Fehler durch die Verwendung einer falschen Variante der Funktion zu vermeiden.

Funktion definieren
Funktionen werden durch das Schlüsselwort "function", eingeleitet, gefolgt durch
outputargs = function_name(inputargs)
und enden mit dem Schlüsselwort "end". Die Anweisungen, die zur Implementierung der Funktion gehören und die Beziehung zwischen den Eingabe-Parametern inputargs und Ausgabeparametern outputargs herstellen, werden in den zwischen die erste "function"-Zeile und letzte "end"-Zeile geschrieben.
Um die allgemeine Syntax einer Funktionsdefinition zu zeigen und eine Vorlage für eine neue Funktion zu erstellen wird das New > Function-Menü im EDITOR-Tab verwendet. Damit wir ein neues Funktion-Skript "untitled.m" für die Funktion "untitled" erstellt, mit zwei generischen Eingabe-Parametern und zwei generischen Ausgabeparametern. Ausgehend von dieser Vorlage können eigene Funktionen erstellt werden, indem der Name der Funktion, die Eingabe- und Ausgabeparameter, sowie die Funktionsanweisungen angepasst werden.

 function [outputArg1,outputArg2] = untitled(inputArg1,inputArg2)  
 %UNTITLED Summary of this function goes here  
 %   Detailed explanation goes here  
 outputArg1 = inputArg1;  
 outputArg2 = inputArg2;  
 end  

Beispiel: Definiere und verwende eine Funktion myfun1
Im folgenden Beispiel erstellen wir eine Funktion myfun1, die als Eingabeparameter ein Array x erhält und dafür die Funktionswerte y = x*exp(-x²) berechnet. Der Quellcode zeigt die Funktionsdefiniton im eigenen Funktion-Skript. Im Test-Skript myscript1.m erstellen wir zunächst einen Vektor aus äquidistanten Punkten x, berechnen durch einen Funktionsaufruf der Funktion myfun1 die y-Werte und stellen die so erhaltenen (x,y)-Koordinaten mit Hilfe der plot-Funktion grafisch dar.

MATLAB's plot-Funktion wird verwendet um 2D Liniengrafiken von Daten zu erstellen, die durch ihre x und y-Koordinaten gegeben sind. Die Funktion erwartet als Eingabe zwei Vektoren derselben Länge, die die x- und y-Koordinaten darstellen. Weiterhin können Formatierungsangaben als optionale Parameter mitgegeben werden, z.B. für die formatierung der Linienfarbe und -stärke, Titel und Legende sowie Beschriftung der Achsen.

Skript	Ausgabe
Funktion-Skript myfun1.m function y = myfun1(x) % Define the function y = x exp(-x^2) % Input: x -- a vector % Ausgabe: y -- a vector (same size as x) y = x .* exp(-x.^2); end Test-Skript myscript1.m x = -5:0.1:5; % Create vector x y = myfun1(x); % Calculate y plot (x, y, '+-'); % Plot y vs. x title('y(x) = x * exp(-x^2)'); xlabel('x'); ylabel('y');

(2) Lokale Funktionen

Funktionen, die nur in einem einzigen Skript verwendet werden, können als lokale Funktionen inline in diesem Skript gespeichert werden. Lokale Funktionen sind nur in dem Skript sichtbar, in dem sie definiert wurden. Wichtig ist, dass sie dann am Ende des Skripts gespeichert werden.

Beispiel:Definiere zwei Funktionen und stelle sie grafisch dar
In diesem Beispiel erstellen wir zwei Funktionen myfun1 und myfun2 lokal in dem Test-Skript "test_inlinefunction.m". Beide Funktionen myfun1 und myfun2 haben einen Vector x als Eingabeparameter, und berechnen die y-Werte für gegebene mathematische Funktionen.

Skript	Ausgabe
% test_inlinefunction.m x = -1:0.1:1; plot(x, myfun1(x), '+-'); hold on plot(x, myfun2(x), '+-'); legend('myfun1','myfun2'); title('Line-plot of two functions'); xlabel('x'); ylabel('y'); function y = myfun1(x) y = sin(x) .* exp(-x.^2); end function y = myfun2(x) y = cos(x) .* exp(-x.^2); end

(3) Anonyme Funktionen

Eine anonyme Funktion ist eine Funktion, die mit einer Variable des Typs type function_handle definiert wird, anstelle in einer Skript-Datei definiert zu werden. Informell kann man eine anonyme Funktion als eine inline-Funktion beschreiben, die in nur einer Zeile definiert und mit dem @-Symbol eingeleitet wird. Anonyme Funktionen werden stets dann verwendet, wenn man kurze Hilfsfunktionen benötigt, die mit einer einzeiligen Anweisung beschrieben werden können.
Die allgemeine Syntax ist <function_name> = @ (<param_list>) ( <computation>).

Beispiel: Anonyme Funktion verwenden
Im folgenden Beispiel werden drei anonyme Funktionen definiert.

• Zeile 1-3: Definiere die Funktion f(x) = sin(2πx) als anonyme Funktion und berechne die Funktionswerte in den Punkten x = 1 und x = 2.
• Zeile 4-8: Definiere das Polynom p(x) = 1 + 2x + x² und berechne die Funktionswerte in den äquidistanten Punkten x = [0, 0.5, 1.0, 1.5, 2.0]. Da bei der Definition der Polynomfunktion der Punkt-Operator verwendet wird, darf ein Vektor als Argument der Funktion verwendet werden.
• Zeile 8-11: Definiere die dreidimensionale Funktion u(x,y) = 25xy, wobei x und y Vektoren derselben Länge sein müssen. Erzeuge dann zwei Vektoren x und y mit Hilfe der Funktion linspace und berechne die Funktionswerte z = u(x, y) mit Hilfe der anonymen Funktion.

 % Beispiel 1: Sinus-Funktion  
 f = @(x) sin(2*pi*x);  
 y1 = f(1); y2 = f(2);  
 % Beispiel 2: Polynom  
 p = @(x) (1 + 2.*x + x.^2);  
 x = 0:0.5:2; % x = [0, 0.5, 1.0, 1.5, 2.0]  
 y = p(x);  
 % Beispiel 3: Funktion mit zwei Variablen  
 u = @(x,y)(25.*x.*y);  
 x = linspace(0,1,10); y = linspace(0,2,10);  
 z = u(x, y);  

Plotting in MATLAB

Bei der numerischen Lösung eines mathematischen Problems wie z.B. einer partiellen Differentialgleichung ist es wichtig, Lösungen und Zwischenergebnisse einfach visualisieren zu können, da dies das intuitive Verständnis des zugrundeliegenden physikalischen Problems erleichtert. MATLAB verfügt über eine Reihe von Funktionen, die die Erstellung von zwei- und dreidimensionalen Grafiken unterstützen. Die wichtigsten Funktionen sind plot, surf, mesh, contour, quiver, diese sehen wir uns im Folgenden genauer an.

MATLAB-Grafiken sind in eigene Fenster eingebettet, die mit Hilfe des figure-Befehls erstellt werden. Ein Grafikfenster wird stets defaultmäßig erstellt, auch wenn der figure-Befehl nicht explizit angegeben wird. Der explizite figure-Befehl ermöglicht es, Optionen für die Erstellung des Grafikfensters anzugeben, z.B. Position und Titel.

2D-Plots mit plot

Die einfachste Grafik ist ein 2D-Linienplot, also eine zweidimensionale Liniengrafik einer Funktion y = f(x), wobei die Funktion plot() eingesetzt wird. Die plot-Funktion hat die allgemeine Syntax plot(X,Y), und erzeugt einen 2D-Linienplot der Daten in Y versus der entsprechenden Koordinaten in X. X und Y müssen Vektoren oder Matrizen derselben Größe sein. Um z.B. einen 2D-Plot der Funktion y = f(x) = x^2 für die Vektoren X = [1,2,3,4,5] und Y = [1,4,9,16,25] zu erstellen, schreibt man

plot([1,2,3,4,5], [1,4,9,16,25])

oder auch einfach

plot([1,4,9,16,25])

Fortgeschrittene Verwendung der plot()-Funktion ermöglicht die Angabe weiterer Eingabeparameter oder auch die Festlegung von Formatierungs-Optionen für die Grafik, die als Schlüssel-Wert-Paare angegeben werden.

Beispiel: 2D-Line-Plot

In diesem Beispiel untersuchen wir einige Optionen der Funktion plot und stellen die Sinus- und Kosinus-Funktion auf demselben Koordinatensystem dar.

• Zeile 2: Erstelle eine Diskretisierung x des Intervalls [-2*pi, 2*pi] mittels eines äquidistanten Vektors mit 51 Datenpunkten.
• Zeile 3 und 4: Berechne die y-Koordinaten für die zu zeichnenden Funktionen.
• Zeile 5: Erstelle eine neue Figur mit Breite 700 und Höhe 500 an der Position(50, 50).
• Zeile 6: Zeichne die sin-Funktion, die durch die Koordinaten x und y1 beschrieben wird.
• Zeile 7: Der Befehl hold on hält Grafiken im aktuellen Achsensystem fest, so dass neue Grafiken hinzugefügt werden können.
• Zeile 8: Zeichne die cos-Funktion, die durch die Koordinaten x1 und y2 beschrieben wird.
• Zeile 9-11: Gebe Titel, Legende und Achsenbeschriftungen an.

Skript	Ausgabe
clear all;clc;format compact; x = linspace(-2*pi, 2*pi, 51); y1 = sin(x); y2 = cos(x); figure('Position', [50,50,700,500]); plot (x, y1, '-s', 'LineWidth',1); hold on plot (x, y2, '-o','LineWidth',1.5); title('Plot of the sin- and cos-function'); legend('y1 = sin(x)', 'y2 = cos(x)'); xlabel('x'); ylabel('y');grid on;

In MATLAB können mit Hilfe der subplot-Funktion mehrere Grafiken in demselben Figurenfenster, jedoch auf unterschiedlichen Achsensysteme gezeichnet werden. Der Befehl subplot(m, n, p) teilt die aktuelle Figur in ein mxn Gitter aus Teilgrafiken, wobei der nächste plot an die Stelle p gesetzt wird.

Beispiel: 2D-Plot mit figure und subplot

Es sollen die Funktionen y1(x) = sin(x)*exp(x) and y2(x) = x*cos(x) auf derselben Funktion dargestellt werden, so dass die zweite Grafik unterhalb der ersten angeordnet ist. Um dies zu erreichen, wird mit dem Befehl subplot(2,1,p) ein Gitter mit zwei Zeilen und einer Spalte erstellt sowie ein Achsensystem an der Position p = 1,2, wie hier im Beispiel.

• Zeile 5: Erstelle subplot für die obere Grafik an Position p = 1
• Zeile 6-9: Erstelle Grafik mit plot die an der Stelle subplot p = 1 eingefügt wird. Linienstärke, Farbe und Marker werden als Schlüssel-Wert-Paare angegeben. Codezeile 6 wird mit Hilfe von Auslassungszeichen (...) geteilt.
• Zeile 10: Erstelle subplot für die untere Grafik an der Position p = 2
• Zeile 11-14: Erstelle Grafik mit plot die an der Stelle subplot p = 2 eingefügt wird.

Skript

Ausgabe

x = linspace(-2*pi, 2*pi, 41); y1 = sin(x).*exp(x); y2 = cos(x).*x; figure('Position', [50,50,700,500]); subplot(2,1,1) plot (x, y1, '-s', 'LineWidth',1.1, 'Color','red', ... 'MarkerEdgeColor','red'); title('y(x) = sin(x)*exp(-x) '); xlabel('x'); ylabel('y');grid on; subplot(2,1,2) plot (x, y2, '-o','LineWidth',1.2, 'Color','black', ... 'MarkerEdgeColor','black'); title('y(x) = cos(x)*x'); xlabel('x'); ylabel('y');grid on;

Oberflächendiagramme mit surf erstellen

Für die Erstellung dreidimensionaler Grafiken einer Funktion z = u(x,y) verwendet man in MATLAB die Funktion surf(). Die surf-Funktion hat die allgemeine Syntax surf(X, Y, Z), und erstellt ein Oberflächendiagramm der Daten in Z versus der Koordinaten in X und Y. Die Parameter X, Y und Z müssen Matrizen mit passenden Dimensionen sein. Die Matrizen X and Y werden aus den Koordinaten-Vektoren x and y mit Hilfe der Funktion meshgrid erzeugt. Falls x eine Vektor mit m Elementen und n ein Vektor mit n Elementen ist, erzeugt meshgrid(x, y) zwei Matrizen X and Y mit jeweils n Zeilen und m Spalten. X repliziert den Vektor x als Zeilenvektor n mal, und Y repliziert y als Spaltenvektor m mal.

Die folgenden Beispiele zeigen die Erstellung der Matrizen X, Y und Z, die als Parameter der Funktion surf benötigt werden, und allgemeiner die Verwendung der Funktionen meshgrid und surf.

Beispiel: 3D-Plot mit surf

In diesem Beispiel erstellen wir ein Oberflächendiagramm der Funktion z = u(x, y) = x^2 - y^2 für gegebene x- und y-Koordinatenvektoren.

• Zeile 1-2: Erstelle Koordinatenvektoren x and y.
• Zeile 1-2: Die Koordinatenvektoren x and y werden als Eingabeparameter der Funktion meshgrid() verwendet um die Matrizen X und Y zu erzeugen.
• Zeile 4: Berechne die 3x4 Matrix Z, die die Funktionswerte enthält.
• Zeile 5: Erstelle Oberflächendiagramm mittels surf.

Skript	Ausgabe
x = [1, 2, 3, 4]; y = [0, 0.5, 1]; [X,Y] = meshgrid(x,y) Z = X.^2 - Y.^2 surf(X, Y, Z) Die Ausgabe im Kommandofenster ist wie abgebildet: Output X, Y from meshgrid: X = 1 2 3 4 1 2 3 4 1 2 3 4 Y = 0 0 0 0 0.5000 0.5000 0.5000 0.5000 1.0000 1.0000 1.0000 1.0000 Function values Z: Z = 1.0000 4.0000 9.0000 16.0000 0.7500 3.7500 8.7500 15.7500 0 3.0000 8.0000 15.0000

Beispiel 2: Gradientenfeld und Kontur-Plot visualisieren

Wir plotten die Funktion u(x,y) = x^2-y^2 über einen rechteckigen Wertebereich [a, b] x [c, d] und ergänzen die Grafik um Titel und Achsenbeschriftungen. Weiterhin zeigen wir die Konturlinien und das durch den Gradienten definierte Vektorfeld mit Hilfe der MATLAB-Funktionen contour and quiver.

• Zeile 1: Definiere u als anonyme Funktion.
• Zeile 2-3: Definiere das Rechteck [a, b] x [c, d] und die Anzahl nx = 10 and ny = 20 der Datenpunkte, die für die Diskretisierung verwendet werden sollen.
• Zeile 4: Erzeuge zwei Vektoren x und y mit äquidistanten Datenpunkten.
• Zeile 5: Erzeuge die Matrizen X, Y aus den äquidistanten x- und y-Koordinaten.
• Zeile 6: Berechne die Matrix Z, die die Funktionswerte enthält.
• Zeile 7: Berechne den Gradienten [px, py] der Funktion u.
• Zeile 9-13: Erstelle das Oberflächendiagramm der Funktion u.
• Zeile 14-20: Erzeuge 2D-plot der Funktion mit Konturlinien und Vektorfeld.

Skript

Ausgabe

u = @(x,y) x.^2 - y.^2; a = -5; b = 5; nx = 10; c = -10; d = 10; ny = 20; x = linspace(a,b,nx+1);y = linspace(c,d,ny+1); [X,Y] = meshgrid(x,y); Z = u(X,Y); [px,py] = gradient(Z); figure('Position', [50,50,700,500]); subplot(2,1,1) surf(X, Y, Z); xlim([a,b]);ylim([c,d]);view(3); title('Function z = u(x,y) = x^2-y^2') xlabel('x');ylabel('y');zlabel('z = u(x,y)'); subplot(2,1,2) contour(X,Y,Z); hold on quiver(X, Y, px, py); title('Contour and gradient') xlabel('x'); ylabel('y'); xlim([a,b]); ylim([c,d]); colorbar;colormap('jet')

Autoren, Tools & Quellen