Deutsch  English

›  Demo-MAT1: MATLAB Tutorial

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.

  Motivation

Mathematische Entwicklungs­umgebungen wie MATLAB oder Octave bieten Unterstützung für die analytische und numerische Lösung mathematischer Probleme. MATLAB verbirgt Implementierungsdetails und die zugrundeliegende Komplexität der Probleme. Ingenieure können sich auf die Modellierung des Problems konzentrieren und Lösungen erzeugen, sogar wenn das Modell oder die numerische Methode zunächst nicht 100% verstanden worden ist. Sie können sich also auf die Lösung des physikalischen Problems konzentrieren. Da mächtige Solver verfügbar sind, verschiebt sich der Fokus und die Hauptarbeit von der Lösung des Problems hin zur korrekten Modellierung.

Warum MATLAB?

MATLAB bietet mächtige Funktionen zur Lösung numerischer Probleme die gängige technische Aufgabenstellungen modellieren. Als Beispiel: mit den MATLAB ODE (Ordinary Differential Equation) Solvern für gewöhnliche Differential­gleichungen ode45, ode23 kann man eine Vielzahl zeitabhängiger dynamischer Probleme lösen, z.B. Schwingungs­probleme oder Bevölkerungs­dynamik beschreiben. Die PDE (Partial Differential Equation) Toolbox bietet Funktionen zum Lösen partieller Differentialgleichungen, wie zum Beispiel im Bereich der Wärmeleitung oder Wellengleichungen. Die Toolboxen und Funktionen sind gut dokumentiert und es sind viele Beispiele verfügbar, die man als Ausgangspunkt für eigene Skripte verwenden kann.

Warum Octave?

Octave ist eine Entwicklungsumgebung für mathematische und numerische Aufgaben, kostenlos verfügbar, und von der Funktionalität her mit MATLAB vergleichbar. Die Software ist weniger elegant als MATLAB, jedoch kostenlos verfügbar, mit derselben grundlegenden Funktionalität, und kann verwendet werden, um die Grundlagen der MATLAB-Syntax zu erlernen.

  Übersicht

Das Tutorial ist in acht Abschnitte gegliedert, die zunächst die Bedienung der MATLAB-Entwicklungsumgebung erläutern, danach die ersten Codezeilen, die Deklaration von Variablen, Eingabe und Ausgabe, Programm­ablaufsteuerung mit Verzweigungen und Schleifen, Arrays, Matrizen und Funktionen sowie das Erstellen zwei- und dreidimensionaler Grafiken.

  1. MATLAB-Umgebung

  2. Erste Zeilen in MATLAB, Variablen und Datentypen

  3. Eingabe und Ausgabe

  4. Programm­ablaufsteuerung: Verzweigungen und Schleifen

  5. Vektoren

  6. Matrizen

  7. Funktionen

  8. Grafiken erstellen: Plotting in MATLAB

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.

MATLAB kann auf verschiedene Arten verwendet werden:

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, ist es nützlich, einige Befehle zu erlernen, die häufig benötigt werden, um den Workspace und das Kommandofenster überschaulich und konsistent zu halten.

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:

Datentypen

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

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.

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:

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.

Bedingte Verzweigungen (if-else)

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.

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   


Die For-Schleife erlaubt, Anweisungen wiederholt auszuführen, indem sie für sogenannte 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 dass Trennzeichen gesteuert, mit dem die Elemente aufgelistet werden. Zum Beispiel deklariert x = [1, 4, 9] einen Zeilen-Vektor, und x = [1; 4; 9] einen Spaltenvektor. Vektoren können auf unterschiedliche Arten erzeugt werden: durch Aufzählen ihrer Elemente in eckigen Klammern, mit Hilfe von Funktionen, mit Hilfe von Schleifen.
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.

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

Script 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)  


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 auf mehrere Arten definiert werden:

  1. Globale Funktion: Funktion wird in einer eigenen m-Skript-Datei gespeichert.
  2. Lokale Funktionen: Funktion wird inline in dem Skript gespeichert, wo sie auch verwendet wird.
  3. Anonyme Funktion: Funktion wird als anonyme Funktion 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(-x2) 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.

 % 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.

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;

MATLAB line plot

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.

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;

MATLAB line plot


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 nxm Matrizen X and Y: 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.

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

MATLAB surf plot



Autoren, Tools & Quellen

Autor:
 Prof. Dr. Eva Maria Kiss

  1. MATLAB Hilfe: https://de.mathworks.com/help/matlab/
  2. MATLAB Syntax Grundlagen: https://de.mathworks.com/help/matlab/language-fundamentals.html
  3. Octave Software:https://www.gnu.org/software/octave/
  4. Octave Manual:https://octave.org/doc/v6.1.0/