MATLAB - Kurzanleitung - Hochschule · PDF fileMATLAB – Kurzskript WS 2010/2011 Mathematisches Labor I/II FB MN - 2 - Current Directory Das Current Directory ist das aktuelle Arbeitsverzeichnis

Matlab-Kurzskript

WS 2010/2011

Ing. grad. Wilhelm v. Schultz Dipl. Math. (FH) Katharina Zirrgiebel Dipl. Ing. Angelika Niederle

MATLAB – Kurzskript WS 2010/2011 Mathematisches Labor I/II FB MN

- 2 -

1. Allgemeines, Entwicklungsumgebung, Variablenkonzept 1.1 MatLab (= Matrix Laboratory) ist eine Sprache zur direkten oder programmierten Bearbeitung mathematischer Probleme. Matlab ist Matrix-orientiert, d.h., alle Variablen sind Arrays. Die Dimension des Arrays muss vorher allerdings nicht explizit definiert werden. Daher können große Datensätze strukturiert gehandhabt werden, wie z.B. in der Numerik benötigt.

Was kann Matlab? - interaktive Eingabe (Taschenrechnerfunktion) - vorgegebene und selbst geschriebene Programme und Funktionen ausführen

Matlab besteht aus einem Grundpaket (grundlegende Rechenmethoden, Variablenkonzept, elementare Programme und Funktionen) und verschiedenen sogenannten Toolboxen (zusätzliche Funktionen und Programmbibliotheken) für die verschiedensten Anwendungsgebiete (weitere Informationen und Programme im Internet). 1.2 Entwicklungsumgebung - Command Window (Eingabefenster) - Workspace (alle verwendeten Variablen werden angezeigt mit Wert- bzw. Größenangaben) - Command History (alle im Command Window eingegebenen Befehle in umgekehrter Reihenfolge) - Current Directory (aktuelles Arbeitsverzeichnis) - Function Help Browser (zur schnellen Suche von Matlab-Funktionen) - Path Browser (wichtig für Programmaufruf) (File ► Set Path) - M-File-Editor (zum Schreiben eigener Programme) (File ► New ► M-File)

Arbeiten mit dem Command Window

Im Command Window können einzelne Anweisungen über die Tastatur eingegeben werden, deren Ergebnis als direkte Antwort in der nächsten Zeile ausgegeben wird. (= Taschenrechnerfunktion)

- Das Eingabepromt >> zeigt an, dass auf eine Eingabe gewartet wird. - Die Eingabe wird durch die Enter-Taste ↵. abgeschickt. - Falls kein Variablenname für das Ergebnis definiert wurde, wird die vordefinierte Variable ans zum Speichern des

Ergebnisses verwendet. - Durch ein Semikolon am Ende der Eingabe wird die Ausgabe unterdrückt.

Beispiel 1: >> 1+1 ans = 2 >>

Beispiel 2: >> 1+1; >>

- Eingebene Befehle können in umgekehrter Reihenfolge mit der ↑ -Taste wieder ins Command-Window geladen werden smart recall .

- Man kann mehrere Befehle in einer Zeile angeben. Diese werden dann durch ein Komma (mit Ausgabe) oder ein Semikolon (ohne Ausgabe) getrennt.

- Ein Befehl kann auch über mehrere Zeilen gehen. Durch drei Punkte am Zeilenende zeigt man an, daß die Anweisung in der nächsten Zeile fortgesetzt wird.


- 2 -

Current Directory Das Current Directory ist das aktuelle Arbeitsverzeichnis. Hier werden Dateien vorrangig gespeichert und von dort werden primär die Programme (M-Files) aufgerufen. Der Pfad des Current Directory kann unterhalb der Menue-Leiste eingestellt werden. Die Anzeige der aktuell verwendeten Dateien und Ordner teilt sich in der Default-Einstellung von MatLab ein Fenster mit dem Workspace (siehe Abb. Seite 1).

Workspace Hier werden alle aktuell verwendeten (globalen) Variablen und deren Inhalt, Größe etc. angezeigt.

Command History zeigt alle zuletzt verwendeten Befehle in umgekehrter Reihenfolge an. Die Befehle können per Drag & Drop ins Command Window verschoben oder durch Doppelklick ausgeführt werden. 1.3 Grundlegende Befehle - clear oder clear all löscht alle Variablen im Workspace (Löschen einzelner Variablen möglich) - clc löscht Command Window - help # liefert Informationen zum Befehl # - format compact/ loose/ long/ short/ rat /… bestimmt das Ausgabeformat (intern wird unabhängig davon

immer mit double-Genauigkeit gerechnet) - whos x zeigt Informationen über die Variable x an 1.4 Variablendefinition

Variablen werden in Matlab direkt bei der Wertzuweisung erzeugt. Alle Variablen sind Arrays (Zeilen und Spalten), deren Größe zu Beginn nicht festgelegt werden muss.

Variablennamen müssen mit einem Buchstaben beginnen (Klein-/Großbuchstaben werden unterschieden). Zugelassen sind Buchstaben A-Z, Ziffern 0,..,9 sowie der Unterstrich ( _ ). Umlaute (ü, ö,...) und Sonderzeichen sind nicht zulässig. 63 Stellen werden unterschieden.

Es gibt in Matlab bereits vordefinierte Variablen, z. B. pi, eps,inf,-inf,NaN (Vorsicht: Es gibt keine Warnung beim Überschreiben!)

Daten werden in Matlab in Form von Zahlen oder Zeichenketten verarbeitet 1. Der Variablentyp wird bei der Definition automatisch zugewiesen.

1 für symbolische Variablen (Typ sym) siehe Kapitel 6 „Symbolic Math Toolbox“

Zahlen-Datentypen - Variablentyp double - Dezimaldarstellung

Nachkommastellen werden mit Punkt getrennt Bsp: 9.6397238

- Exponentialdarstellung Bsp: 1.60210e-20 oder -1.60210E-20

- komplexe Zahlen können wie reelle Zahlen eingegeben werden (i oder j möglich – intern wird i benutzt), z. B.: z1 = 3 + 4j, z2 = 3 – 3i

Zeichenketten-Konstanten (Strings) - Variablentyp Array aus char-Elementen - Zeichenketten-Konstanten werden durch gerade

Apostrophstriche begrenzt (über #-Taste) Beispiel: a = 'Name'

- Den Apostrophstrich als Teil einer Zeichenkette erhält man durch zwei Apostrophzeichen Beispiel: b = 'Jane''s book'

- String-Variablen gelten in Matlab als Vektoren, daher können sie wie diese konfiguriert werden


- 3 -

1.5 Operatoren Operator Funktion Priorität + Addition niedrig - Subtraktion niedrig * Multiplikation mittel / Division mittel ^ Potenz hoch ( ) Klammer sehr hoch

Zusätzliche Matrix-Operatoren (siehe Kapitel 2) .* ./ .\ .^ elementweise Operatoren

(Punktoperatoren) \ Matrix-links-Division : colon-Operator

Arithmetische VergleichsausdrückeRelationsoperatoren: < <= kleiner, kleiner gleich > >= größer, größer gleich == ~= gleich, ungleich

Verknüpfung logischer Ausdrücke: | logisches ODER & logisches UND ~ logische Negation

1.6 Matlab Help Browser Help ► Product Help oder .F1. - Bietet übersichtliche Hilfe in Kapitelstruktur, inkrementelle Suche und Suche nach Stichwörtern. - Es sind einführende Tutorials sowie Demos verfügbar. - Befehle werden erläutert und an Beispielen verdeutlicht. Der Beispiel-Code kann kopiert und ausgeführt werden. 1.7 Funktionen Matlab stellt viele mathematische Funktionen bereit. Der Aufruf einer Funktion erfolgt durch Angabe des Funktionsnamens und eventuell benötigten Parametern in runden Klammern

Beispiel 3: >> x=cos(0) x = 1 >>

Kurze Informationen über Funktionsweise und Syntax der Funktion * durch Angabe von help * im Command-Window.

Überblick aller Funktionen unter: Help Browser ► MATLAB – Function Reference – Mathematics Alphabetische Liste unter: Help Browser ► MATLAB – Functions: Alphabetical List Elementare Funtionen (elementary math) – genaue Syntax in der Hilfe

Trigonometrische Funktionen sin, asin, sinh, cos, tan, … Exponentialfunktionen exp Exponentialfunktion zur Basis ‰

pow2 Exponentialfunktion zur Basis 2

sqrt Quadrat-Wurzelfunktion (square root) nthroot n-te Wurzel einer Zahl log natürliche Logarithmusfunktion log10 Logarithmus zur Basis 10 sonstige Funktionen abs Betrag gcd größter gemeinsamer Teiler Funktionen für Polynome (polynomials) polyfit Sucht passende Polynomkoeffizienten polyval Berechnet Werte eines Polynoms


- 4 -

2. Vektoren und Matrizen Matlab speichert Daten in der Regel als "array", d.h. als Matrix. Damit sind Vektoren als einzeilige Matrix und Skalare als einkomponentige Vektoren (1x1-Matrix) lediglich Spezialfälle. Dieses Konzept hat für den Benutzer den Vorteil der einfacheren Handhabung von mehrkomponentigen Daten, ohne dass dadurch der Umgang mit skalaren Größen erschwert wird. Zeilenelemente werden durch Leerzeichen oder Kommata, Spaltenelemente durch Semikolon getrennt. Die Indizierung der Vektor- und Matrixelemente beginnt bei 1. Im Workspace unter "Size" kann man die Dimensionen einer Variable überprüfen (oder Befehl whos Variablenname). 2.1 Darstellung x = 1 hat also eine Zeile und eine Spalte. 2.1.1 Vektoren

Zeilenvektoren v = [1,2,3,4] oder v = [1 2 3 4] Vektor v enthält 4 Zeilenelemente

Spaltenvektoren v = [1;2;3;4] Semikolon bedeutet „neue Zeile“ Vektor v enthält 4 Spaltenelemente

Transponieren v = v' (Apostroph auf der #-Taste)

Länge eines Vektors length(v) liefert die Anzahl der Elemente des Vektors v

Colon operator : (Spaltenoperator) siehe help colon v = n:m füllt Vektor v mit Zahlen von n bis m mit Schrittweite 1 (møn Elemente)

Beispiel: v = 1:5 liefert v = 1 2 3 4 5

v = n:x:m füllt Vektor v mit Zahlen von n bis m mit fester Schrittweite x Beispiel: x = 0:0.2:1 liefert x = 0 0.2000 0.4000 0.6000 0.8000 1.0000

bzw. x = 0:0.2:0.9 liefert x = 0 0.2000 0.4000 0.6000 0.8000

Teile eines Vektors ansprechen: v(i) bezeichnet das i-te Element des Vektors v der Index beginnt bei 1!.

Beispiel: x = 0:0.2:1; (x wie im vorigen Beispiel) x(2)

liefert ans = 0.2000 v(i:j) Vektor aus den Elementen i bis j des Vektors v

Beispiel: x(2:4) (x wie im vorigen Beispiel) liefert ans = 0.2000 0.4000 0.6000

v(i:n:j) Vektor aus den Elementen von v, die die Indizes haben, die im Vektor [i:n:j] stehen (Achtung: Nur ganze Zahlen als Indizes möglich!) Beispiel a: x(2:2:4) (x wie im vorigen Beispiel) liefert ans = 0.2000 0.6000 Beispiel b: i = [2 4]; Indexvektor für die Indices 2 und 4

x(i) (x wie im vorigen Beispiel) liefert auch ans = 0.2000 0.6000

2.1.2 Matrizen n x m-Matrix (am Beispiel einer 2 x 3 - Matrix) A = [1,2,3;4,5,6] oder A = [1 2 3;4 5 6] vgl. Workspace Teile einer Matrix ansprechen: A(i,j) bezeichnet das i-te Zeilen- und das j-te Spaltenelement

Beispiel: A(2,2) liefert ans = 5


- 5 -

A(i,:) bezeichnet alle Spaltenelemente der gesamten i-te Zeile Beispiel: A(2,:) liefert ans = 4 5 6

A(:,j) bezeichnet alle Zeilenelemente der gesamten j-te Spalte Beispiel: A(:,3) liefert ans = 3 6

A(i,n:m) bezeichnet die Elemente der n-ten bis zur m-ten Spalte der i-ten Zeile A(:) bezeichnet alle Elemente der Matrix A

Beispiel: A(:)= 1 setzt alle Elemente der Matrix A auf 1 z = A(:) übergibt an z alle Werte der Matrix A in einer einzelnen Spalte Größe einer Matrix size(A) gibt 2-elementigen Vektor zurück, der die Zeilen- und Spaltenanzahl von A angibt Matrix aus Vektoren zusammensetzen Wenn x und y Zeilenvektoren derselben Länge sind, erhält man mit dem Befehl A=[x;y] eine Matrix mit 2 Zeilen, die x und y sind.

Beispiel: x=[1 2 3]; y=[8 7 6]; A=[x;y] liefert A = 1 2 3 8 7 6

Wenn x und y Spaltenvektoren derselben Länge sind, erhält man entsprechend mit dem Befehl A=[x,y] oder A=[x y] eine Matrix mit 2 Spalten, die x und y sind. Auch möglich ist die Verwendung der Befehle vertcat() und horzcat() bzw. cat(1,) und cat(2,). Spezielle Funktionen zum Erzeugen von Matrizen und Vektoren linspace(a,b,n) erzeugt einen Vektor mit n Elementen im Intervall [a,b], ohne Angabe von n ist die Anzahl 100 Beispiel: x=linspace(1,13,4) liefert x = 1 5 9 13 ones(n) ergibt eine nxn-Matrix aus lauter Einsen ones(n,m) ergibt eine nxm-Matrix aus lauter Einsen ones(size(A)) ergibt eine Matrix derselben Größe wie die Matrix A aus lauter Einsen zeros(...) analog = lauter Nullen eye(n) nxn-Einheitsmatrix hilb(n) ergibt eine nxn-Hilbertmatrix rand(n,m) erzeugt eine nxm-Matrix mit Zufallszahlen zwischen 0 und 1 2.2 Rechnen mit Matrizen Elementare Funktionen in MATLAB können nicht nur für einzelne Werte, sondern auch für Vektoren und Matrizen aufgerufen werden: Beispiel: x=[1 2 3 4]; sin(x)

liefert ans = 0.8415 0.9093 0.1411 -0.7568

liefert die elementweise Auswertung von Sinus für alle Elemente von x. Operatoren + Addition - Subtraktion * Matrixmultiplikation

Beispiel: A=[1 2;0 1]; B=[1 2;1 3]; C=A*B liefert C = 3 8

1 3 \ linksseitige Matrixdivision X = A\B ist die Lösung der Gleichung AÿX = B Wenn A und B quadratische Matrizen sind, gilt A\B = A-1 ÿ B Man kann so die Inverse berechnen: A\E = A-1 (mit E := Einheitsmatrix) / rechtsseitige Matrixdivision X = A/B ist die Lösung der Gleichung XÿB = A

wenn A und B quadratische Matrizen sind gilt A/B = AÿB-1

Zusammenhang von \ und / : B/A =(A'\B')' (vgl. transponieren von Produkten) A^b b-fache Matrixmultiplikation von A mit sich selbst


- 6 -

Punktoperator

.* ./ .\ .^ bezeichnen die entsprechenden elementweisen Operationen. Beispiel: A=[1 1;1 1]; B=[1 2;1 3]; C=A.*B vergleiche C=A*B (Matrixmultiplikation) liefert C = 1 2 C = 2 5

1 3 2 5 Lösung eines linearen Gleichungssystems Ein lineares Gleichungssystem M ÿ x = r wird durch die drei folgenden Anweisungen formuliert und gelöst Beispiel:

>> M = [3 2 1; 1 3 2; 1 2 3] M = 3 2 1 1 3 2 1 2 3 >> r = [1;1;1] Spaltenvektor! r = 1 1 1 >> x = M \ r x = 0.1667 0.1667 0.1667

Einige wichtige Funktionen im Überblick det(A) liefert Wert der Determinante der quadratischen Matrix A inv(A) = A-1 Inverse Matrix von A eig(A) liefert Vektor mit Eigenwerten der quadratischen Matrix A norm(v) =|v| liefert den Betrag ("Länge") des Vektors v (euklidische Vektornorm) sum(A) bei Matrizen: Summe der Spaltenelemente bei Vektoren: Summe der Elemente max(A) bei Matrizen: Maximum der Spaltenelemente bei Vektoren: Maximum der Elemente min(A) bei Matrizen: Minimum der Spaltenelemente bei Vektoren: Minimum der Elemente diag(A) falls A ein Vektor der Länge n: gibt eine nxn Matrix zurück mit A in der Hauptdiagonale falls A eine nxn Matrix: gibt die Hauptdiagonalelemente von A in einem Spaltenvektor zurück diag(A,k) falls A ein Vektor der Länge n: gibt eine nxn Matrix zurück mit A in der k-ten Diagonale falls A eine nxn Matrix: gibt die Elemente der k-ten Diagonale in einem Spaltenvektor zurück k = 0 Hauptdiagonale

k < 0 k-te Diagonale unterhalb der Hautdiagonale k > 0 k-te Diagonale oberhalb der Hauptdiagonale

tril(A,k) liefert die linke untere Dreiecksmatrix der Matrix A inkl. der k-ten Diagonale (k=0 ist Standard und kann auch weggelassen werden, d. h. die Hauptdiagonale wird mit ausgegeben)

triu(A,k) liefert die rechte obere Dreiecksmatrix der Matrix A inkl. der k-ten Diagonale In der Hilfe finden Sie unter MATLAB – Function Reference – Mathematics – Arrays and Matrices eine Vielzahl weiterer Funktionen.


- 7 -

3. M-Files, Programmelemente

Für umfangreiche und öfter benutzte Befehlsfolgen ist eine interaktive Eingabe im allgemeinen nicht sinnvoll. Man kann solche Befehlsfolgen in eine Datei schreiben, mit der Endung *.m speichern und dann im Command Window unter Angabe des Namens * aufrufen (siehe 3.2 Skripte).

Matlab stellt einen Editor zur Verfügung, den M-File Editor, der aus der Matlab-Umgebung über den Menü-Punkt: File ► New ► Blank M-file verfügbar ist.

Nachdem die Datei abgespeichert wurde (mit File ► Save As… oder über das Diskettensymbol aus der Toolbar) erscheint in der Kopfzeile des Editors der Dateiname incl. der Pfadangabe. Suchreihenfolge Ruft man zum Ausführen des M-Files im Matlab-Command Window den Dateinamen (ohne Endung .m) auf, prüft Matlab der Reihe nach, ob dieser Name: - zu einer Variablen, - zu einem m-File im aktuellen Arbeitsverzeichnis (Current Directory), - zu einer Standard Funktion (built in function), - zu einem m-File in einem Verzeichnis des Matlab Suchpfades gehört. Das erste Objekt, auf das dies zutrifft, wird genommen und von Matlab ausgeführt. Kommentare werden in Matlab durch vorangestelltes %-Zeichen angegeben und gelten bis zum Zeilenende. Mehrere Zeilen können über die Funktion Comment im Menue "Text" im M-File-Editor auskommentiert werden. Dazu müssen zuvor die entsprechenden Zeilen markiert werden. (Analog kann man eine Kommentierung rückgängig machen über die Funktion Uncomment.) 3.1 Aktuelles Arbeitsverzeichnis Die Bedeutung des aktuellen Verzeichnisses wird in Matlab vor allem durch die Tatsache bestimmt, dass Matlab dort zuerst nach m-Files sucht. Das momentan aktuelle Verzeichnis kann man im Feld Current Directory in der Benutzeroberfläche erkennen und auf das eigene Arbeitsverzeichnis abändern. Im dazugehörenden Fenster werden alle verfügbaren m-Files angezeigt. Stellen Sie am besten das aktuelle Verzeichnis auf Ihren Arbeitsordner um, in dem Sie Ihre m-Files speichern wollen. Verwenden Sie dieses Verzeichnis häufig, empfiehlt es sich, es als Suchpfad in die Suchpfadliste von Matlab mit aufzunehmen (in unseren Praktikumsräumen ist das leider nicht dauerhaft möglich). Dazu öffnen sie im Menü File ► Set Path ... den Knopf Add Folder, wählen Ihr Verzeichnis aus und speichern diese Einstellung ab mit Save. 3.2 Skripte (Befehlsreihenfolge speichern und aufrufen) Ein Skript-File (auch script m-file - kurz Skript) ist eine Aneinanderreihung von Matlab-Befehlen, die in den Texteditor eingegeben und mit der Endung *.m abgespeichert werden. Wird der Dateiname (ohne die Endung .m) im Command Window aufgerufen, so werden die Befehle nacheinander

ausgeführt, als ob man sie einzeln eingegeben hätte. (Man kann auch im M-file-Editor auf das Symbol klicken.)

Globale Variablen Bei seinem Aufruf stehen dem Skript alle im Workspace gespeicherten Variablen zur Verfügung. Umgekehrt sind alle Variablen, die im Skript vorkommen, nach der Ausführung auch im Workspace, also auch global.

Zu Beginn eines Skriptes ist es meist sinnvoll, alle im Workspace vorhandenen Variablen zu löschen (clear) sowie die Ausgaben im Command Window zu entfernen (clc).

Schreibt man in die ersten Zeilen des Skripts *.m einen Kommentar, kann dieser als Hilfe mit help * aufgerufen werden (wie bei den schon in Matlab vorhandenen M-files).

script m-file *.m (beliebiger Name) % Programmbeschreibung für online-Hilfe ausführbare Anweisungen ...


- 8 -

3.3 Functions (Parameter übergeben, Rückgabewerte berechnen) m-Functions sind Erweiterungen der Matlab-Funktionsbibliothek und werden in der Regel in einer separaten Datei abgespeichert. Der Matlab-Editor der Version Matlab R2008b bietet zum Erstellen einer Funktionsdatei unter File ► New ► Function M-File eine Funktionalität an, die Ihnen automatisch eine gültige Struktur vorschlägt.

Sie müssen diesen Vorschlag lediglich an Ihre Anforderungen bezüglich des Funktionsnamens, der Ein- und Rückgabeparameter abändern und Ihre eigene Befehlsfolge eingeben.

input_args bezeichnen stellvertretend die Eingabeparameter, die beim Funktionsaufruf in runden Klammern hinter dem Programmnamen angegeben werden müssen. Stimmt die Zahl der Parameter im Funktionsaufruf nicht mit der geforderten Zahl überein, erfolgt eine Fehlermeldung.

output_args bezeichnen stellvertretend die Rückgabewerte, die in den Anweisungen berechnet und an das aufrufende Programm zurückgegeben werden. Wird nur ein Wert zurückgegeben, können die eckigen Klammern [ ]weggelassen werden. Soll kein Wert zurückgegeben werden, kann auch das Gleichheitszeichen = weggelassen werden.

Lokale Variablen Alle innerhalb der Funktion definierten Variablen (Übergabeparameter, Rückgabewerte und alle neu definierten Variablen) sind lokale Variablen! D.h., sie stehen nach Aufruf der Funktion im Workspace nicht zur Verfügung.

Name der Datei Der Name einer Funktion muss mit dem Namen des M-files übereinstimmen!

ACHTUNG! Ist ein M-file mit dem gleichen Namen schon vorhanden, gibt es keine Fehlermeldung! Um zu überprüfen, ob ein M-file mit dem gewünschten Namen * schon vorhanden ist, bietet Matlab verschieder Varianten an: 1.) help name im Command Window eigegeben zeigt Ihnen die Kommentarzeilen der Funktionsdatei an. Ist der

Dateiname noch nicht vergeben, erscheint hier eine Fehlermeldung. 2.) which name im Command Window eingegeben liefert Ihnen die Pfadangabe unter der die Datei gefunden

wurde. Gesucht wird in den Verzeichnissen die im Path aufgefürt sind und im Current Directory. 3.) exist name im Command Window eingegeben liefert Ihnen eine Ziffer. Gesucht wird in den Verzeichnissen

die im Path aufgefürt sind und im Current Directory. 0 nicht vorhanden 1 Variable aus dem Workspace 2 M-File im Pfad oder im Current Directory . 5 eingebaute Matlab-Funktion . 7 ein Verzeichnisname .

Tipp: Eigene m-File-Namen mit einem Großbuchstaben beginnen! Beispiel 1: r2d.m

function d = r2d(x) % r2d(x) rechnet einen Winkel x von Bogenmaß in Grad um d=x*180/pi;

Aufruf z.B. mit >> r2d(3) ans = 171.8873 >>

oder >> z=r2d(3)

z = 171.8873 >>


- 9 -

x und d sind hier lokale Variablen (vgl. Workspace) Beispiel 2: Funk1.m

function [y1,y2] = Funk1(a,x) % Berechnet die Funktionswerte von f(x)=a*x^2 % und deren Ableitung y1 = a.*x.^2; y2 = 2.*a.*x;

Aufruf z.B. mit >> [a b]=Funk1(2,1) a = 2 b = 4

y1, y2, a und x innerhalb der Funktion sind lokale Variablen (vgl. Workspace) – a und b im Funktionsaufruf sind dagegen im Command Window erzeugte globale Variablen. 3.4 Ablaufstrukturen

MatLab stellt die üblichen Formen der Ablaufsteuerung eines Programms zur Verfügung. Solange man nur mit skalaren Größen arbeitet, unterscheiden sich die in Matlab verfügbaren Sprachelemente zur Ablaufsteuerung nicht von denen anderer Programmiersprachen.

Verzweigungen können mit if, elseif, else und end switch, case, otherwise und end

gebildet werden.

Schleifen können mit for und end while und end

gebildet werden.

Blöcke mit einer solchen Ablaufsteuerung nennt man auch Verbundanweisungen. 3.4.1 Bedingte Anweisungsblöcke (Verzweigungen I)

Ein bedingter Anweisungsblock hat in Matlab die Form:

if Bedingung bedingter Anweisungsblock end

Der Anweisungsblock wird nur dann ausgeführt, wenn die Bedingung wahr ist. Bedingungen können als beliebiger skalarer logischer Ausdruck angegeben werden. Der Anweisungsblock kann beliebig viele Anweisungen enthalten, die auch wieder Verzweigungen oder Schleifen sein dürfen. Verbundanweisungen können also geschachtelt werden. (Falls der Ausdruck keinen skalaren Wert liefert, berechnet Matlab automatisch nach vorgegebenen Regeln einen skalaren Wert. Falls der Wert des Ausdruckes zwar skalar, aber verschieden von 0 (falsch) oder 1 (wahr) ist, ordnet Matlab ihm einen logischen Wert nach bestimmten Regeln zu.) Zwei alternativ auszuführende Anweisungsblöcke werden in Matlab mit Hilfe von else formuliert:

if Bedingung bedingter Anweisungsblock else alternativer Anweisungsblock end

Wenn die Bedingung wahr ist, wird der bedingte Anweisungsblock ausgeführt, anderenfalls der alternative Anweisungsblock.


- 10 -

Mehrere Anweisungsblöcke Man kann auch mehrere Bedingungen abprüfen lassen und jeder Bedingung einen Anweisungsblock zuordnen. Die Reihenfolge, in der die Bedingungen aufgelistet werden, ist dabei von Bedeutung. Sie bestimmt die Reihenfolge in der sie geprüft werden. Sobald eine wahre Bedingung gefunden wird, wird der zugehöhrige Anweisungsblock durchlaufen und die gesamte Verbundanweisung ist damit abgearbeitet. Man formuliert zusätzliche Bedingungen in Matlab mit Hilfe von elseif . elseif-Konstruktionen können mit einer zusätzlichen else-Bedingung abgeschlossen werden, müssen dies aber nicht.

Beispiel: if x > 0

a = a/x; elseif x == 0

a = (a-1)/x; elseif ...

... else

a=0; end

3.4.2 Fallunterscheidungen (Verzweigungen II)

Fallunterscheidungen stellen eine besondere Form der Verzweigung dar, bei der die Anweisungsblöcke einzelnen Werten einer einzigen Prüfvariable zugeordnet werden. Diese Variable kann einen skalaren numerischen Wert haben, sie kann aber auch eine Zeichenkette als Wert haben.

switch Prüfvariable case 'Fall 1' Anweisungsblock 1 case 'Fall 2' Anweisungsblock 2 case ... ... otherwise alternativer Anweisungsblock end Die Prüfvariable wird mit Hilfe von switch benannt. Die unterschiedlichen Werte werden dann mit Hilfe von case als Fälle unterschieden und müssen in Hochkommata gesetzt werden. Eine alternativer Anweisungsblock, der ausgeführt werden soll, wenn keiner der anderen Fälle eintritt, kann durch otherwise angefügt werden.

Beispiel: switch Jahr

case '1988' Tage = 366;

case '1989' Tage = 365;

otherwise Tage = -1;

end 3.4.3 for-Schleifen

Bei for-Schleifen oder Zählschleifen wird ein Anweisungsblock mehrmals durchlaufen, so oft, wie durch die Bereichsangabe definiert ist. Jedem Schleifendurchlauf wird dabei mit Hilfe der Schleifenvariablen ein bestimmter Wert, der Schleifenindex zugeordnet, der in der Schleife auch abgefragt werden kann. for-Schleifen haben in Matlab allgemein die Form:

for Schleifenvariable = Bereichsangabe Anweisungsblock end

Die Bereichsangabe gibt einen Startwert für die Schleifenvariable vor. Dieser Index wird dann in jedem Schleifendurchlauf um eine Schrittweite (standardmäßig um 1) erhöht, bis der Endwert erreicht wird. Für die Bereichsangabe wird üblicherweise der colon-Operator verwendet. Die Bereichsangabe besteht dann aus Anfangswert : Endwert. Der letzte angenommene Wert der Laufvariablen ist gleich dem Endwert. Der Anweisungsblock kann ebenfalls beliebig viele Anweisungen enthalten, die auch wieder Verzweigungen oder Schleifen sein dürfen. Schleifen können also auch beliebig geschachtelt werden.


- 11 -

Beispiel 1 (Standard-Schrittweite 1): sum = 0; for i = 1:10 sum = sum + i; end

So werden durch die Schleife nacheinander alle Zahlen von 1 bis 10 aufsummiert. Die Summe 55 ist nach Durchlauf aller Wiederholungen der Anweisung in der Variable sum gespeichert. Eine andere Schrittweite kann wie bei der Vektordefinition mit dem erweiterten colon-Operator angegeben werden. Die Bereichsangabe besteht dann aus Anfangswert : Schrittweite : Endwert. Die Schrittweite darf dabei alle skalaren Werte (auch nicht ganzzahlige und negative Werte) annehmen.

Bei positiver Schrittweite stoptt der Schleifendurchlauf, sobald die Laufvariable größer als der Endwert ist, d.h. Der letzte angenommene Wert der Laufvariablen ist kleiner oder gleich dem Endwert.

Bei negativer Schrittweite muss der Endwert kleiner als der Anfangswert gewählt werden, sonst wird die Schleife gar nicht durchlaufen. Der letzte angenommene Wert der Laufvariablen ist dann größer oder gleich dem Endwert. Beispiel 2 (geänderte Schrittweite):

for i = 10 : -0.5 : 0 i end

So werden durch die Schleife nacheinander alle Zahlen angefangen bei 10 bis 0 in Schritten von 0.5 im Command-Window ausgegeben:

i = 10 i = 9.5000 usw.

Natürlich können für Anfangs-, Endwert und Schrittweite auch Variablen eingesetzt werden. Diese müssen dann allerdings vor dem ersten Schleifendurchlauf schon definierte Werte aufweisen. 3.4.4 while-Schleifen

Bei einer while-Schleife muß nicht von Anfang an feststehen, wie oft eine Anweisungsblock durchlaufen werden soll. Vor jedem Durchlauf wird eine logische Schleifenbedingung abgeprüft. Ist diese wahr, so wird die Schleife ein weiteres Mal durchlaufen, anderenfalls wird sie abgebrochen. Im Schleifenkörper muss der Wert der Schleifenbedingung also beeinflußt werden, da sie anderenfalls unendlich oft durchlaufen würde. While-Schleifen haben in Matlab die allgemeine Form:

while Schleifenbedingung Anweisungsblock end Bei einer einfachen Schleife wiederholt sich der Ablauf:

1. Schleifenbedingung prüfen 2. Schleifenkörper (Anweisungsblock) abarbeiten

solange, bis die Schleifenbedingung nicht mehr erfüllt ist. Beispiel:

a = 1; while a < 8 b = b + a; a = a + 1; end

a wird in jedem Schleifendurchlauf durch die zweite Anweisung im Schleifenblock um 1 erhöht, so dass für a = 7 die Schleife zum letzten Mal durchlaufen wird. Endlosschleifen können in der Regel mit <STRG> + C beendet werden.


- 12 -

Zusätzliche Abbruchkriterien kann man in einer Schleife mittels if-Abfrage und der break-Anweisung formulieren. Die break-Anweisung beendet dann die Abarbeitung des Schleifenkörpers der innersten Schleife.

Beispiel: a = 1; while a < 8 % Achtung, zusätzliche Abbruchbedingung in Schleife! b = b + a; a = a + 1; if b >10 break % Ende der (inneren) Schleife end end

Durch die if-Abfrage wird die Schleife nun also auch beendet, falls b den Wert 10 überschreitet.

Mit dieser Variante sollte man allerdings sehr sparsam umgehen und sie gut dokumentieren, da hierdurch ein Programmm sehr schnell unübersichtlich werden kann. Meist kann man mit einer um das zweite Abbruchkriterium logisch erweiterten Schleifenbedingung das Problem umgehen. 3.5 Ablaufkontrollen 3.5.1 Debugger Setzen Sie Haltepunkte in Ihrem M-File (mit F12, oder der linken Maustaste, wenn der Cursor am Anfang einer Zeile steht). Die Datei muss vorher abgespeichert worden sein. Wird die Datei gestartet, so stoppt die Abarbeitung am Haltepunkt. Nun können die einzelnen Variablen über das Command Window abgefragt und geändert werden. Mit der Taste F10 wird die Weiterbearbeitung der Datei zeilenweise, mit F11 ohne Unterbrechung, bis zum nächsten Haltepunkt veranlasst. Während des Haltens an einem Haltepunkt erscheint im Command Window das Prompt K>> , erst nach Beendigung des Programms erscheint das Prompt >> . 3.5.2 Evaluate Current Cell Mittels erzeugen Sie ab der Zeile, in der der Cursor steht bis zum Ende der Datei eine Cell. Mit nochmaligem Platzieren in einer der nachfolgenden Zeilen erzeugen Sie erneut eine weitere Cell. Steht der Cursor innerhalb einer Cell, können Sie mittels rechter Maustaste durch wählen des Menupunktes Evaluate Current Cell (oder Strg + Eingabe) diese Zelle ausführen (berechnen) lassen. Variablen, die zu Beginn der Cell noch keinen Wert besitzen erzeugen eine Fehlermeldung im Command Window, es sei denn ihnen wurden explizit Werte im Command Window zugewiesen. Die Abfrage der Variablenwerte funktioniert auch bei lokalen Variablen innerhalb einer Funktionsdefinition.


- 13 -

4 Ein- und Ausgabe

Die Ausgabe im Command Window können Sie mit dem Befehl format verändern, oder durch Einstellungsänderung unter File ► Preferences ► Command Window. Die interne Rechnung im double-Format wird dadurch aber nicht verändert. 4.1 Ausgabe auf dem Bildschirm

Mit dem Befehl disp können Variableninhalte und Zeichenketten auf dem Bildschirm ausgegeben werden.

Beispiel: disp(' Corn Oats Hay') (Ausgabe einer Zeichenkette) disp(rand(5,3)) (Erzeugen einer 5 x 3 Matrix mit Zufallszahlen und deren Ausgabe) Ausgabe im Command Window: Corn Oats Hay 0.2113 0.8474 0.2749 0.0820 0.4524 0.8807 0.7599 0.8075 0.6538 0.0087 0.4832 0.4899 0.8096 0.6135 0.7741 4.2 Eingabe mit der Tastatur

Mit dem Befehl input können Sie auf dem Bildschirm Text ausgeben und mit der Tastatur Variablenwerte einlesen.

Beispiel: a = input('Geben Sie bitte a ein: '); Matlab wartet auf eine Eingabe über die Tastatur. Der numerische Eingabewert wird der Variablen a zugewiesen.

Beispiel: name = input('Geben Sie bitte Ihren Namen ein ','s'); Der Variablen name wird die Eingabe über die Tastatur als String zugewiesen.

4.3. Formatierte Ausgabe

Mit dem Befehl fprintf in der Form fprintf(fid,format,A,...) wird eine formatierte Ausgabe erzeugt.

fid Variable, die eine Kennzahl für die Ausgabedatei enthält (fid=1: Ausgabe im Command Window – muss nicht explizit angegeben werden, da Standard)

format Formatstring, der Ausgabetext und Ausgabeformate sowie Steuerungszeichen enthalten kann A,... Namen der Variablen, deren Inhalt ausgegeben werden soll

Im Formatstring werden der Text mit Steuerzeichen und Platzhalter für die auszugebenden Variablen als Vorlage betrachtet.

Steuerungszeichen \b backspace \f form feed \n Zeilenumbruch (new line) \r carriage return \t Tabulator (horizontal tab) \\ Backslash \'' oder '' Anführungszeichen (single quotation mark) %% Prozentzeichen (percent character)

Die Platzhalter für die Ausgabeformate besteht immer aus einem Prozentzeichen und drei Angaben. Die erste Zahl nach dem %-Zeichen gibt die Mindestzahl der Ausgabestellen an. Die Anzahl der Nachkommastellen wird – durch Punkt getrennt – anschließend angegeben. Der angegebene Buchstabe bestimmt das eigentliche Forrmat der Ausgabe.

Beispiel: %20.8f bedeutet 20 Stellen insgesamt, 8 Nachkommastellen, der Rest wird mit Leerzeichen aufgefüllt, Festpunktformat (wichtig für Tabellenausgaben).

Ausgabeformate %e Exponential notation (using a lowercase e as in 3.1415e+00) %f Fixed-point notation %g The more compact of %e or %f. Insignificant zeros do not print. %c Single character %s String of characters %d oder %i Decimal notation (signed) (weitere Ausgabeformate siehe Matlab-Hilfe)


- 14 -

4.3.1 Formatierte Bildschirmausgabe Beispiel (Ausgabe einer Variablen): fprintf('%12.4e', pi) Ausgabe: 3.1416e+000>>

gibt den Inhalt der Variablen pi mit einer Feldbreite von 12 Zeichen gesamt und 4 Nachkommastellen im Exponentialformat im Command Window aus

Beispiel (Ausgabe einer Variablen und Text): fprintf('Pi = %12.4e', pi) Ausgabe: Pi = 3.1416e+000>>

Der Text wird übernommen und der Platzhalter %12.4e durch den Inhalt der Variablen pi im enstprechenden Format ersetzt.

Beispiel (Ausgabe mehrerer Variablen): Sollen mehrere Variablen im gleichen String ausgegeben werden, benötigt man je Variable einen Platzhalter %. Die Variablen werden dann in der Reihenfolge ersetzt, in der sie hinten angeführt werden. fprintf('Pi = %12.4f und 3*Pi = %12.4f\n', pi, 3*pi) Ausgabe: Pi = 3.1416 und 3*Pi = 9.4248 >>

Das Steuerungszeichen \n im Beispiel fügt einen Zeilenumbruch ein.

Werden mehrere Variablen, aber nur eine Formatierung angegeben, benutzt Matlab den Formatierungsstring auch für die weiteren Variablen. fprintf('%12.4f\n', pi,3*pi)

Ausgabe: 3.1416 9.4248 >>

gibt den Inhalt der Variablen pi im angegebenen Format aus (12 Gesamtstellen, 4 Nachkommastellen, Festpunktformat), beginnt mit einer neuen Zeile, gibt dann 3*pi (gleiches Format) und eine neue Zeile im Command Window aus

Beispiel ("spaltenweise" Ausgabe von Vektoren): Sollen Vektoren gleicher Länge tabellarisch in Spalten angeordnet werden, kann das elementweise realisiert werden – z.B. durch eine for-Schleife. Der Formatstring dient dann als Vorlage für jede Zeile. Ausgabe: x = 0:3; y = sin(x); fprintf(' x | sin(x) \n------------\n') for i = 1:4 fprintf(' %2.0f | %6.4f\n', x(i), y(i)) end

x | sin(x) ------------ 0 | 0.0000 1 | 0.8415 2 | 0.9093 3 | 0.1411

Statt die Vektoren elementweise durch eine Schleife auszugeben, kann man sie auch zu einer Matrix kombinieren. Dabei entspricht jeder Zeile der Matrix dann eine Spalte in der Ausgabe. Eine Formatangabe im Formatstring ist dann gültig für die Elemente der entsprechenden Zeile der Matrix: Ausgabe: x = 0:3; Zeilenvektor y = sin(x); Zeilenvektor A = [x;y] Matrix mit zwei Zeilen fprintf(' x | sin(x) \n------------\n') fprintf(' %2.0f | %6.4f\n', A )

A = 0 1.0000 2.0000 3.0000 0 0.8415 0.9093 0.1411 x | sin(x) ------------ 0 | 0.0000 1 | 0.8415 2 | 0.9093 3 | 0.1411

4.3.2 Formatierte Ausgabe in Datei

Zum Schreiben in eine Datei muss erst eine Kennzahl (Dateikennung / file identifier) erzeugt werden fopen und zum Schreiben freigegeben werden. Nach dem Schreiben muss die Datei wieder geschlossen werden fclose . fid = fopen(Name, Berechtigung) öffnet eine vorhandene Datei Name oder erzeugt diese, wenn noch

nicht vorhanden, mit der angegebenen Schreib- bzw. Leseberechtigung Rückgabewert ist eine Kennzahl für die Ausgabedatei

fclose(fid) Schließt die Datei mit der angegebenen Kennzahl


- 15 -

Berechtigungen 'r' öffnet Datei nur zum Lesen (default). 'w' öffnet Datei oder erzeugt eine neue Datei zum Schreiben, der vorige Inhalt wird gelöscht 'a' öffnet Datei oder erzeugt eine neue Datei zum Schreiben, der neue Inhalt wird ans Dateiende eingefügt 'r+' öffnet Datei oder erzeugt eine neue Datei zum Lesen und Schreiben 'w+' öffnet Datei erzeugt eine neue Datei zum Lesen und Schreiben, der vorige Inhalt wird gelöscht 'a+' öffnet Datei oder erzeugt eine neue Datei zum Lesen und Schreiben, neuer Inhalt wird ans Dateiende eingefügt 't' Zusatz (ab Matlab R2006 b): öffnet Datei im Textmodus. Auch andere Editoren zeigen Inhalte korrekt an

Beispiel: fid = fopen('sico.txt','wt'); x=[-pi:pi/2:pi]; fprintf(fid,' x sinx cosx\n'); fprintf(fid,'%6.2f %8.4f %8.4f\n',[x;sin(x);cos(x)]); fclose(fid);

← Datei wird erzeugt oder geöffnet. Schreiben ist erlaubt, Textmodus ← Die Ausgabe erfolgt in die Datei mit der entsprechenden Kennzahl (fid) ← Datei wird geschlossen

Welche Endung (hier: *.txt) für die Datei vergeben wird, hängt von ihrem Verwendungszweck ab. Mit einem Editor können Sie die Datei lesen.

4.4 Datenmatrix aus Datei einlesen

load filename.* Lädt die Daten aus der Datei filename mit der Endung * in eine Matrix in den Workspace. Die Matrix steht dann unter dem gleichen Namen filename als Variable zur Verfügung.

Beispiel: Es liegt bereits eine Datei namens Daten1.dat mit einem Datensatz vor. Die Endung ( hier *.dat) hängt vom weiteren Verwendungszweck ab und spielt zunächst keine Rolle.

load Daten1.dat x = Daten1(1,:); speichert die erste Zeile der Matrix y = Daten1(2,:); analog ...

Der Befehl load speichert die Einträge aus der Datei unter dem Variablennamen Daten1 als zweizeilige Matrix ab (vgl. Workspace). Diese Matrix steht nun für die weitere Verarbeitung zur Verfügung – hier werden z.B. die Zeilen in separaten Variablen gespeichert.

4.5 Importieren von Daten mit Hilfe des Import Wizards Mit Hilfe des Import Wizards können Daten mit Zeilen oder Spaltenüberschriften als Variablen eingelesen werden. Aufruf unter File ► Import Data Beipiel:

Die Datei sico.txt (s. Beispiel in 4.3.2) steht mit Überschriften zur Verfügung. Öffnen über File ► Import Data. Die Variablen cosx, sinx, x stehen danach im Workspace als Vektoren zur Verfügung. Vor Überschreibung von schon bestehenden Variablen im Workspace wird gewarnt!


- 16 -

4.6 Ein-/Ausgabe in/aus Datei

Mit dem Befehl save können globale Variablen gespeichert, mit load wieder in den Workspace geladen werden. Nach Beendigung einer Matlab-Sitzung steht der Workspace mit den verwendeten globalen Variablen nicht mehr zur Verfügung. Um diese bei der nächsten Sitzung wieder zu laden, gibt es 2 Varianten:

1. Deklarieren der globalen Variablen in einem Skript (s. Kapitel 3 ) 2. Abspeichern der Variablen samt Inhalten mit Hilfe von save in einer Datei und neu laden mit load save speichert alle Variablen im Workspace im Binärformat im Current Directory unter dem

Namen matlab.mat save('filename') wie oben, allerdings kann der Pfad und der Dateiname (filename.mat) angegeben werden save('filename', 'var1', 'var2', ...) speichert nur die angegebenen Variablen in der

angegebenen Datei ab Mit Hilfe des load-Befehls, entweder im Command-Window oder in einem Skript, können die Variablen im Binärformat wieder geladen werden. Beispiel:

x = [1,4]; y = [-7,8]; save xy.mat clear all load xy.mat

Besetzen der Variablen x und y Speichern in der Datei xy im Binärformat Zum Testen löschen des Arbeitsbereichs Laden der Variablen (Kontrolle im Workspace)

Die save-Funktion kann auch benutzt werden, um die Variablen im ASCII-Format (in jedem Editor lesbar) abzuspeichern. Dazu wird der Befehl um eine Format-Angabe erweitert. save('...','format') oder save('filename','...','format') Formatierungsmöglichkeiten (in Auswahl). Sie können z.T. auch kombiniert werden -append Werte werden an die schon existierende Datei am Ende angehängt -ascii 8 Stellen ASCII-Format -ascii –double 16 Stellen ASCII-Format -ascii –tabs getrennt durch Tabs -ascii -double –tabs 16-Digit-ASCII-Format, getrennt durch Tabs Beispiel:

Besetzen der Variablen x und y x=linspace(0,1,11); y=exp(x); save daten2 x y -ascii y2=y.^2; save daten2 y2 -ascii -append

Abspeichern im Text-Format in der Datei daten2 Berechnen von y2 Speichern von y2 im Textformat nach den bestehenden Daten x und y


- 17 -

5 Grafik in Matlab 5.1 2D-Grafik 5.1.1 Grafik mit diskreten Daten

plot(x,y) erzeugt einen 2D-Plot aus den jeweiligen Punktepaaren (xi, yi). x und y sind Vektoren Die Punkte werden in der Regel linear verbunden.

plot(x,y,s) s ist ein String und enthält Angaben über Form und Farbe der Linien siehe Befehl LineSpec (Linienspezifikation) figure(h) erzeugt ein Grafikfenster mit der Kennzahl h (falls ein Fenster mit dieser Kennzahl nicht

existiert) und setzt es über alle existierenden Fenster auf dem Bildschirm (s. Hilfe) close(h) schließt das Grafikfenster mit der Kennzahl h clf löscht den Inhalt des Grafikfensters Beispiel: x = linspace(0,2*pi,8); y = sin(x); plot(x,y);

Es wird ein x-Vektor im Intervall [0, 2π] erzeugt und ein y-Vektor mit zugehörigen Werten sin(x) berechnet. Der plot-Befehl zeichnet dann die Punkte (xi, yi) in einem extra figure-Fenster, mit Linien verbunden. Für einen glatten Kurvenplot sind sehr viele Zwischenpunkte nötig, die Vektoren entsprechend groß. Die beiden Vektoren (hier x und y) müssen gleich viele Elemente besitzen. Der Typ und die Farbe der Ausgabe kann durch Angabe der Linienspezifikation s bestimmt werden. Beispiel: plot(x,y,'ro'); zeichnet die Punkte in rot (r) als kleine Kreise (o) ohne Verbindungslinie Zeichenfarben: r rot g grün b blau c cyan

m magenta y gelb k schwarz w weiß

Markierungspunkte (in Auswahl): Linientypen: + Pluszeichen o Kreis * Sternchen . Punkt x Kreuz

- durchgezogene Linie (default) -- gestrichelte Linie : gepunktete Linie -. Strich-Punkt-Linie

Matlab wählt die Achsenbegrenzungen automatisch, beschriftet die Achsen anhand der vorgegebenen x- und y-Werte. Mit folgenden Befehlen (in Auswahl) kann das Erscheinungsbild der Grafik beeinflusst werden (nach dem plot-Befehl eingeben): grid on erzeugt ein Koordinatengitterlinien axis equal setzt x und y-Achse auf gleiche Einheiten axis([xmin,xmax,ymin,ymax]) setzt den Sichtbereich xlabel ('string1') beschriftet die x-Achse mit dem Text string1 ylabel ('string2') beschriftet die y-Achse mit dem Text string2 text(x,y,'string') fügt den Text string am Punkt (x,y) ein


- 18 -

title('string') versieht die Grafik mit der Überschrift string Beispiel: x = -2*pi:0.01:2*pi; y = sin(x); plot(x,y); axis([-2*pi,2*pi,-1,1]); grid on; title('Sinus-Funktion'); xlabel('x-Achse'); ylabel('y-Achse')

5.1.2 Mehrere Kurven in einem Grafikfenster

Möglichkeit 1: plot(x1,y1,'r:',x2,y2,'b-',x3,y3,'g--') drei 2D-Plots werden in ein Grafikausgabefenster gezeichnet mit 3 verschiedenen Farben- und Linienarten Möglichkeit 2: hold on behält das aktuelle Ausgabefenster bei, weitere Zeichnungen werden der bestehenden Grafik hinzugefügt hold off hebt alle vorangestellten hold on-Befehle wieder auf

plot (x1,y1,'r:') hold on; plot (x2,y2,'b-'); plot (x3,y3,'g—'); hold off;

Zeichnen der ersten Grafik Anhalten des Ausgabefensters nach dem Plot-Befehl Zeichnen der weiteren Grafiken Wiederaufheben (nicht vergessen)

5.1.3 Funktionsplots fplot('fname',limit) zeichnet die Funktion, die im String fname angegeben ist,

im Druckbereich limit

Beispiel: fplot('sin(x)',[-pi,pi])

Dabei sind die automatisch erzeugten Werte für x und y Vektoren (in einer Funktion werden für Bereiche mit großen Änderungen mehr x-Werte eingesetzt); daher muss bei manchen zu zeichnenden Funktionen der Punktoperator eingesetzt werden. Ebenso können mehrere Funktionen gleichzeitig gezeichnet in eine Grafik gezeichnet werden.

Beispiel: fplot('[sin(x).^2, cos(x)]',[-pi,pi]) ezplot(fun,[xmin,xmax]]). Einfacher Funktionsplot, elementweise Operatoren nicht erforderlich,

Achsenbeschriftung und Titel automatisch

Beispiel: ezplot('sin(x)^2',[-2*pi,2*pi]) 5.1.4 Mehrere Grafiken in ein Grafikfenster

subplot(m,n,i) Mit dem Befehl subplot wird das Grafikfenster in m Zeilen und n Spalten aufgeteilt, so dass mxn Felder entstehen. Das i-te Feld (zeilenweise gezählt) wird zur Grafikausgabe ausgewählt.

Beispiel: x=-pi:0.01:pi; subplot(1,2,1); plot(x,sin(x),'r',x,cos(x),'g'); grid on; axis([-pi,pi,-1,1]); legend('Sinus-Funktion','Cosinus-Funktion'); xlabel('x-Achse'); ylabel('y-Achse') subplot(1,2,2); fplot('cos(x).^2',[-pi,pi]'); grid on; legend('Cosinus-Quadrat-Funktion'); xlabel('x-Achse'); ylabel('y-Achse');


- 19 -

5.2 3D-Grafik

5.2.1 Kurven in 3D

Analog zur plot-Funktion in 2D gibt es in 3D die Funktion plot3 . Sie benötigt allerdings statt 2 Vektoren gleicher Länge, 3 Vektoren gleicher Länge, deren Elemente als Koordinaten einer Kurve gezeichnet werden. plot3(x,y,z) zeichnet eine 3D-Kurvengrafik Beispiel A:

x0 1 2 3

1

- 1

y

t = 0:pi/50:10*pi; x = sin(t); y = cos(t); plot3(x,y,t);

Es entsteht eine Kreisspirale (Schraubenlinie). Dabei ist in diesem Fall der Parameter t die "Geschwindigkeit", mit der sich die Kurve hochschraubt. Durch Auswahl der Werkzeugs kann die 3-D-Grafik im Zeichen-Fenster mit Hilfe der Maus gedreht werden. 5.2.2 Flächen in 3Ds

Es soll eine Fläche über der x-y-Ebene gezeichnet werden, die jedem Punkt (x,y) in der Ebene eine "Höhe" z auf der zu zeichnenden Fläche zuordnet – ein sog. Graph. Ein Punkt auf der Fläche wird dann durch (x,y,z) repräsentiert.

In Matlab muss zunächst ein Gitternetz aller zu zeichnenden Punkte in der x-y-Ebene erzeugt werden, z.B. mit dem Befehl meshgrid.. Dieser Befehl erzeugt aus zwei Vektoren, die die x- und y-Koordinaten der Punkte enthalten, zwei Matrizen, die die Grundlage des Gitternetzes darstellen.

Beispiel: x = [0 1 2 3]; Vektor der x-Koordinaten y = [-1 0 1]; Vektor der y-Koordinaten Der Vektor x hat 4 Elemente, y hat 3 Elemente. Der Befehl meshgrid erzeugt daraus zwei Matrizen X und Y: [X,Y] = meshgrid(x,y) X = 0 1 2 3 3 Zeilen mit dem Vektor x

0 1 2 3 ⇒ 3 x 4-Matrix 0 1 2 3 Y = -1 -1 -1 -1 4 Spalten mit dem Vektor y 0 0 0 0 ⇒ 3 x 4-Matrix 1 1 1 1

Legt man beide entstandenen Matrizen übereinander, erhält man alle möglichen Kombinationen der x- und y-Koordinaten – somit repräsentieren die gleichgroßen Matrizen X und Y das benötigte Gitternetz.


- 20 -

Nun kann mit Hilfe des Gitternetzes der x-y-Ebene, das aus den n x m-Matrizen X und Y besteht, eine Matrix – z .B. Z –mit den "Höhenangaben" der Fläche erstellt werden. Z hat die gleichen Dimensionen wie X und Y. Die zusammengehörenden Koordinaten in den entstandenen 3 Matrizen sind dann die x-, y- und z-Komponenten der Punkte auf der Fläche. Die Zeichnung der Fläche entsteht durch gerade Verbindungslinien zwischen den benachbarten Punkten auf der Fläche in beiden Richtungen. Z.B. zeichnet der Befehl mesh nur diese Verbindungslinien, der Befehl surf füllt zusätzlich die enstehenden Zwischenräume farbig auf.

Beispiel B: x = -4:0.25:4; y = -4:0.25:4; [X,Y] = meshgrid(x,y); Gitternetz Z = X.^2 + Y.^2; Höhenmatrix surf(X,Y,Z) zeichne Fläche

Die entstandene Fläche ist ein sog. Paraboloid (parabelartige Fläche in x- und y- Richtung). Ein Punkt auf der Fläche hat dann die Koordinaten (x, y, x2 + y2). Anmerkung: Beim Zeichnen von Kurven (siehe Beispiel A – Linienplots) war t ein Parameter. Beim Zeichnen von Flächen werden zwei Parameter benötigt – hier x und y. Flächenplots sind praktisch zur Visualisierung von Matrizen, die zu groß sind, um numerisch dargestellt zu werden, und zum Zeichnen von Funktionen von zwei Veränderlichen. Will man Flächen in 3D zeichnen, die sich nicht als Graphen ("Höhenfunktion") darstellen lassen – wie z.B. eine Kugeloberfläche – benötigt man eine andere Darstellung der Koordinaten, abhängig von den beiden Parametern.

Beispiel C: Punkte auf einer Kugeloberfläche mit Radius 1 haben die Darstellung

⎟⎟⎟

⎠

⎞

⎜⎜⎜

⎝

⎛

)sin()sin()sin()cos()sin(

θϕθϕθ

πϕπθ20

0<≤≤≤

Die Parameter q und j sind die Winkel der Kugelkoordinaten. Zeichnen in Matlab mit: theta = 0:pi/20:pi; phi = 0:pi/10:2*pi; [T,P] = meshgrid(theta,phi); X = sin(T).*cos(P); Y = sin(T).*sin(P); Z = cos(T); surf(X,Y,Z);

[X,Y]=meshgrid(x,y) erzeugt aus den Vektoren x und y ein Gitternetz bestehend aus den Matrizen X und Y Die Matrix X enthält den Vektor der n Koordinaten von x vervielfacht als Zeilen, und Y enthält vervielfacht den Vektor der m Koordinaten von y als Spalten, so dass alle Kombinationsmöglichkeiten der x- und y-Koordinaten entstehen – n muss nicht gleich m sein.

surf(X,Y,Z) zeichnet eine ausgefüllte Oberfläche der beschriebenen Fläche mesh(X,Y,Z) zeichnet die Verbindungslinien zwischen benachbarten Punkten auf der Fläche

Viele weitere Grafikbefehle in der Hilfe unter MATLAB ►3-D Visualizations .


- 21 -

6. Die Symbolic Math Toolbox Was ist die Symbolic Math Toolbox? Bisher haben wir den Variablen immer einen Wert zugewiesen, bevor wir Rechenoperationen ausgeführt haben; dazu verwendet man sogenannte „numerische Ausdrücke“. Dabei waren die Variablen Speicherplätze wie bei Programmiersprachen. Matlab kann auch mit „symbolischen Ausdrücken“ rechnen. Dazu gibt es die Symbolic Math Toolbox, mit der Variablen nicht mehr Speicherplätze für einen bestimmten Wert sind, sondern Variablen im algebraischen Sinn. Man kann zunächst symbolisch Rechnen und Vereinfachen und die numerischen Zahlenwerte erst später einsetzen. Der maschinelle Hintergrund ist ein eine MATLAB integrierte MuPAD Engine (ein Computer-Algebra-System; ähnlich wie Mathematica). Ein MuPAD Notebook kann durch den Befehl mupad aufgerufen werden. Übe r doc(symengine) ruft man die Hilfe zu MuPAD auf. 6.1 Symbolische Objekte Der neue Variablentyp zum symbolischen Rechnen ist das symbolische Objekt (Kürzel sym im Workspace). Intern ist ein symbolisches Objekt eine Datenstruktur, die das Symbol als String darstellt. Die Symbolic Math Toolbox benutzt symbolische Objekte zur Darstellung von symbolischen Variablen, Ausdrücken und Matrizen. Die symbolischen Berechnungen werden im Hintergrund im Wesentlichen von MuPAD ausgeführt. Beispiel 1: Unterschied von MATLAB-Datentyp (z.B. double) zum entsprechenden symbolischen Datentyp:

a = sqrt(2) liefert eine Fließpunkt-Dezimalzahl a = 1.4142 Im Gegensatz dazu kann man 2 in ein symbolisches Objekt mit dem Befehl sym konvertieren a = sqrt(sym(2)) liefert a = 2^(1/2) MATLAB gibt als Ergebnis also 21/2 in symbolischer Notation für die Quadratwurzel zurück, ohne einen numerischen Wert auszurechnen. MATLAB speichert diesen Ausdruck in einem String, dargestellt als 2^(1/2). Um nun den numerischen Wert eines symbolischen Objekts zu erhalten, kann man immer den Befehl double verwenden: double(a) ans = 1.4142 Bemerkung: Ist das Ergebnis eingerückt, ist der Datentyp double; symbolische Ergebnisse werden nicht eingerückt. (vgl. auch Workspace!) Beispiel 2: Ein Bruch wird als symbolisches Objekt von MATLAB durch Nenner und Zähler dargestellt: sym(2)/sym(5) ans = 2/5 Die Berechnungen mit symbolischen Objekten werden auch anders als mit den gewöhnlichen Datentypen ausgeführt: Beispiel 3: Addiert man zwei Brüche vom Typ double, erhält man das Ergebnis in Dezimaldarstellung: 2/5 + 1/3 ans = 0.7333 Als symbolische Objekte definiert, findet MATLAB den gemeinsamen Nenner und kombiniert die Zahlen zu einer rationalen Darstellung: sym(2)/sym(5) + sym(1)/sym(3)

ans = 11/15

Die Symbolic Math Toolbox liefert eine Vielzahl an Möglichkeiten zum symbolischen Rechnen, z.B. Differenzieren, Integrieren, Grenzwertberechnungen, Taylorreihen, etc. Dazu später mehr.


- 22 -

6.2 Symbolische Variablen und Ausdrücke Mit dem sym-Befehl kann man auch symbolische Variablen und Ausdrücke konstruieren: Beispiel 1: x = sym('x') a = sym('alpha') erzeugt eine symbolische Variable x mit der Bedeutung x und eine symbolische Variable a mit der Bedeutung alpha. Beispiel 2: Angenommen, man möchte eine symbolische Variable erzeugen, die den Goldenen Schnitt repräsentiert: Dazu gibt man in MATLAB ein: rho = sym('(1+sqrt(5))/2') Nun kann man mathematische Operationen mit rho ausführen. Z.B.: f = rho^2 - rho - 1 liefert

f = (1/2+1/2*5^(1/2))^2-3/2-1/2*5^(1/2)

Das Ergebnis kann man vereinfachen mit dem Befehl simplify simplify(f) liefert

ans = 0 als symbolischen Wert. Beispiel 3: Man möchte die quadratische Gleichung untersuchen. Eine Möglichkeit ist, den Befehl f = sym('a*x^2 + b*x + c') einzugeben, der den symbolischen Ausdruck der Variablen f zuordnet. In diesem Fall erzeugt die Symbolic Math Toolbox allerdings keine Variablen für die Ausdrücke a, b, c und x. Um weitere symbolische mathematische Operationen mit f ausführen zu können, muss man die Variablen explizit definieren. Eine bessere Möglichkeit ist also zunächst die Befehle a = sym('a') b = sym('b') c = sym('c') x = sym('x') oder in Kurzform syms a b c x. einzugeben. Danach gibt man dann f = sym('a*x^2 + b*x + c') ein. (vgl. Workspace!) Im Allgemeinen kann man statt sym zum Erzeugen symbolischer Variablen immer syms verwenden. Aber Achtung: Symbolische Konstanten müssen mit sym erzeugt werden! Beispiel: f = sym('5') erzeugt eine symbolische Variable f mit dem Wert 5 f = 5 dagegen erzeugt keinen symbolischen, sondern einen numerischen Ausdruck! (syms 5 erzeugt übrigens eine Fehlermeldung!) Mit sym kann man auch eine Matrix in symbolische Form konvertieren: Beispiel 4: A = hilb(3) erzeugt die Hilbertmatrix A =

1.0000 0.5000 0.3333 0.5000 0.3333 0.2500 0.3333 0.2500 0.2000

A = sym(A) liefert die symbolische (rationale) Darstellung der 3x3-Hilbert-Matrix A = [ 1, 1/2, 1/3] [ 1/2, 1/3, 1/4] [ 1/3, 1/4, 1/5]


- 23 -

Übersicht der Befehle: sym(a) konvertiert numerischen Wert (auch Matrix) a in symbolische Konstante double(a) gibt numerischen Wert der symbolischen Konstante a zurück x = sym('x') erzeugt symbolische Variable x mit dem String (= Bedeutung) 'x' a = sym('alpha') erzeugt symbolische Variable a mit dem String (= Bedeutung) 'alpha' syms x Kurzform für x=sym('x') weitere Befehle syms (ohne Argumente) liefert alle aktuell vereinbarten symbolischen Variablen findsym(f) liefert alle vorhandenen symbolischen Variablen im symbolischen Ausdruck f Löschen von symbolischen Variablen syms f setzt die symbolischen Variable f zurück auf 'f', die Variable wird beibehalten, der

vorherige Inhalt wird überschrieben (in MuPAD wird die Variable auch zurückgesetzt) clear, clear x löscht alle Variablen / die Variable x im MATLAB-Workspace (nicht in MuPAD!) reset(symengine) löscht alle Variablen in MuPAD 6.3 Substitutionen Man kann einen numerischen Wert für eine symbolische Variable in einem symbolischen Ausdruck einsetzen (substituieren). Dazu verwendet man den Befehl subs . Die symbolische Variable im Ausdruck f (Default ist x) wird durch den Wert 2 substituiert, dann f berechnet. Das Ergebnis ist, wenn möglich, numerisch. Beispiel 1: syms x

f = 2*x^2 - 3*x + 1 subs(f,2)

liefert ans = 3 Beinhaltet der symbolische Ausdruck mehr als eine Variable, kann man angeben, für welche Variable die Substitution ausgeführt werden soll: Beispiel 2: syms x y f = x^2*y + 5*x*sqrt(y) Der Befehl subs(f, x, 3) liefert dann ans = 9*y+15*y^(1/2) und andererseits subs(f, y, 3) liefert ans = 3*x^2+5*x*3^(1/2) Will man in einem logischen Ausdruck mehrere Variablen gleichzeitig substituieren, muss man ihnen vorher einen symbolischen oder numerischen Zahlenwert zuordnen: Beispiel 3: syms a b; w = a^2 - 3*b; a = sym(4); oder a=4; dadurch ist a allerdings wieder eine numerische Variable! b = sym(1); oder b=1; dadurch ist b allerdings wieder eine numerische Variable! v = subs(w) liefert v = liefert v = 13 13 (v, a, b sind Typ sym (v, a, b sind nun vom Typ double! und es kann weiter mit Mit ihnen kann numerisch weitergerechnet werden, oder sie

ihnen symbolisch müssen mit sym wieder konvertiert werden.) gerechnet werden.)

Zahlwerte konvertieren: numerisch ↔ symbolisch double(a) liefert den entsprechenden numerischen Wert des symbolischen Werts von a sym(s) liefert den entsprechenden symbolischen Wert des numerischen Werts von s


- 24 -

6.4 Symbolisches Rechnen Umformen von symbolischen Ausdrücken pretty(f) stellt den Ausdruck f in übersichtlicher Form dar factor(f) versucht den Ausdruck f als Produkt von Polynomen zu schreiben expand(f) multipliziert Produkte im Ausdruck f aus horner(f) gibt die HORNER-Darstellung des Ausdrucks f an [z,n]= numden(f) bringt alle Summanden im Ausdruck f auf den gleichen Nenner und gibt Zähler z und

Nenner n getrennt zurück (Zähler = numerator, Nenner = denominator) simplify(f) vereinfacht den symbolischen Ausdruck f simple(f) vereinfacht den symbolischen Ausdruck f zur kürzesten Form (gibt verschiedene

Umformungen aus und entscheidet sich dann für diejenige mit den wenigsten Zeichen) Zeichnen von symbolischen Ausdrücken Mit dem Befehl ezplot(f) wird der Ausdruck f - falls nur eine unabhängige Variable vorhanden ist - auf dem Bildschirm in einem separaten Fenster ausgegeben. Alle Einstellungen erfolgen automatisch. Genaueres siehe dazu in Kapitel 6 – Grafik in MATLAB. Lösen von algebraischen Gleichungen Mit dem Befehl solve kann man mit der Symbolic Math Toolbox algebraische Gleichungen lösen. Beispiel 1: syms x f = -3*x^2+1 solve(f) liefert ans =

-1/3*3^(1/2) 1/3*3^(1/2)

Ist nichts Anderes angegeben, wird die Gleichung f = 0 nach der unabhängigen Variablen x aufgelöst. Gibt es mehrere Lösungen, werden diese in einem Vektor ausgegeben. Hier erhält man zwei Nullstellen. Beispiel 2: syms x y f = -3*x^2+y solve(f,y) liefert ans = 3*x^2 Sind mehrere Variablen im Ausdruck f vorhanden, kann als zusätzlicher Parameter die unabhängige Variable (hier y) angegeben werden. Standardmäßig wird x oder die an x nächstliegende Variable verwendet. Beispiel 3: syms x f = '3*x=2' solve(f) liefert ans = 2/3 Möchte man nicht f = 0, sondern eine andere Gleichung lösen, muss man die Gleichung in Hochkomma '' angeben, da das Gleichheitszeichen sonst falsch interpretiert wird. Achtung: f ist dann keine symbolische Variable, sondern ein String vom Typ char! Man kann auch Gleichungssysteme mit solve lösen: Beispiel 4: g1 = 'x + y + z = 0'; g2 = '4*x + 5*y + z -3 = 0';

g3 = '-2*x + y - 3*z -5 = 0'; [x y z] = solve(g1,g2,g3)

liefert das Ergebnis x = -1 y = 3/2 z = -1/2 Ableitungen bilden diff(f) bildet die Ableitung von f nach der unabhängigen symbolischen Variable in f Beispiel 1: syms x;

diff(cos(x)) liefert ans = -sin(x)


- 25 -

diff(f,n) bildet die n-te Ableitung von f Beispiel 2: syms x;

diff(cos(x),2) liefert ans = -cos(x) diff(f,t) Hat f mehrere unabhängige Variablen (müssen zuvor als symbolisch definiert werden), wird die

partielle Ableitung gebildet: tf ∂∂ /Beispiel 3: syms s t

f = sin(s*t) diff(f,t)

liefert ans = cos(s*t)*s

Integrale berechnen int(f) bildet das Integral von f nach der unabhängigen symbolischen Variable in f Beispiel 1: syms x;

int(log(x)) liefert ans = x*log(x)-x int(f,a,b) bildet das bestimmte Integral von f im Intervall [a, b]. Beispiel 2: int(x^2,0,1) liefert ans = 1/3 Es können auch uneigentliche Integrale berechnet werden. Das Zeichen ¶ wird in MATLAB mit inf eingegeben. Beispiel 3: int(exp(-x),0,inf) liefert ans = 1 int(f,t) Hat f mehrere unabhängige Variablen (müssen zuvor als symbolisch definiert werden), wird das

Integral nach dt gebildet: Beispiel 4: syms x t

int(t*x^3,t) liefert ans =

1/2*t^2*x^3 weitere Möglichkeiten zum symbolischen Rechnen (nur eine Auswahl)

taylor(f,n) berechnet die Reihenglieder der Taylorreihe für den Ausdruck f bis zur n-ten Potenz limit(f,x,a) berechnet den Grenzwert (Limes) von f für die Variable x an der Stelle a limit(f,x,a,'left') berechnet den linksseitigen Grenzwert limit(f,x,a,'right') berechnet den rechtsseitigen Grenzwert finverse(f) gibt den inversen Ausdruck f -1 von f zurück, wenn f nur eine unabhängige Variable besitzt finverse(f,v) gibt den inversen Ausdruck von f zur unabhängigen Variablen v zurück compose(f,g) gibt f ( g (y) ) mit f = f (x) und g = g (y) zurück dsolve(...) ist der Befehl zum Lösen gewöhnlicher Differentialgleichungen (siehe MATLAB-Hilfe)

zum Beispiel: dsolve('Dy+1/5*y=1') Dy bezeichnet dabei die erste Ableitung oder dsolve('Dy+D2y=1') D2y bezeichnet dabei die zweite Ableitung oder dsolve('Dy+1/5*y=1','y(0)=1') mit Anfangsbedingung usw.


- 26 -

7. Graphical User Interfaces (GUIs) 7.1. Standarddialoge Matlab bietet die Möglichkeit, Standarddialoge (Predefined Dialog Boxes) im Programmcode zu benutzen, z. B. den menu-Befehl. choice = menu('mtitle','opt1','opt2',...,'optn') Beschreibung: mtitle: Titel des Menüs, opt1…optn Auswahlmöglichkeiten. Beispiel: in = menu('Welche Farbe?','rot','blau','gruen') Je nach Aktion des Benutzers werden folgende Werte zurückgegeben: in = 0 x ausgewählt (Fenster schließen) in = 1 rot ausgewählt in = 2 blau ausgewählt in = 3 gruen ausgewählt Die Weiterverarbeitung erfolgt im laufenden Programm (z. B. mit switch – case ). Ein weiteres Beispiel ist die Message Box. msgbox(Message,Title,Icon) Beispiel: msgbox('Falsche Eingabe!','Fehler!!!','error') Weitere Standarddialoge sind über die Hilfe verfügbar. 7.2 Benutzerdefinierte Dialoge Um eigene Oberflächen zu erzeugen, zu verwalten und die Eingaben des Benutzers von Tastatur oder Maus zu verarbeiten, wird bei Matlab das Werkzeug GUIDE (Graphical User Interface Design Environment) eingesetzt. GUIDE wird gestartet entweder durch File -> New -> GUI oder durch Eingabe von guide ins Command Window. Im Fenster Karteikarte: Create New GUI - > blank GUI (Default) auswählen und mit OK bestätigen. Es öffnet sich der Layout-Editor.

Beim Speichern (gui1.fig) wird eine Datei mit gleichem Namen, aber mit der Endung .m erzeugt und im Editor geöffnet. Der Aufruf des GUIs erfolgt entweder durch Drücken des grünen Pfeilsymbols oder im Command Window durch Eingabe des GUI-Namens (gui1). Anmerkung: den Namen der .fig – Datei nicht umbenennen, sondern nur unter einem anderen Namen abspeichern. Zum Teil sind die Dateien unterschiedlicher Matlab-Versionen nicht kompatibel. In diesem m-File sind 3 Funktionen (anders als bisher üblich). gui1 Startfunktion, mit der der Anwender das Fenster aufruft gui1_OpeningFcn automatisch aufgerufen direkt vor dem Fensteraufbau gui1_OutputFCn aufgerufen vor der Abfrage des Rückgabewertes Übergabeparamter sind folgende: varargin Argumente, die beim Aufruf des GUIs übergeben werden hObject Kennung für das Fenster eventdata Ereignisdaten für Objekte (wird für das Objekt gui1 nicht verwendet) handles Struktur, die Daten des aktuellen Fensters sowie des Anwenders enthält (eine Art Speicher für

globale Variablen). Die Daten werden mit der Funktion guidata gespeichert. 7.2.1. Property Inspector, Callback-Funktionen und Object Browser (Push-Button)

Run Figure

Object Browser Property Inspector M-file Editor Align Objects

Layout-Bereich Widgets


- 27 -

In diesem ersten einfachen GUI wird ein Push-Button eingefügt. (Entsprechendes Steuerelement anklicken und bei gedrückter linker Maustaste in den Layout-Bereicht schieben). Beim Einfügen eines Steuerelementes (Widget) wird die handle-Struktur automatisch um dieses Objekt erweitert. Jedes neu eingefügte Objekt erhält eine fortlaufende Nummer (z. B. pushbutton1, pushbutton2,….). Um die Eigenschaften eines Objektes zu ändern, gibt es nach vorheriger Markierung zwei Möglichkeiten: 1. Die Verwendung des property-Inspectors,

Aufruf über Menüleiste -> View -> Property Inspector oder rechte Maustaste: Property Inspector wählen oder Drücken des Buttons auf der Symbolleiste

2. Die Verwendung der set-Methode direkt im m-file Zunächst ändern wir die Überschrift im property Inspector. Die Eigenschaft "string" ändern wir von push_button auf "Los". Die gleiche Änderung können wir im m.file in der Funktion gui1_OpeningFcn durch den Befehl set(handles.pushbutton1,'String','Los') vornehmen. Der Name(Tag) des Steuerelementes (hier pushbutton1) kann ebenso verändert werden. Die Funktionsnamen im m-file ändern sich entsprechend. Falls die Eigenschaften eines Objektes über den set-Befehl geändert werden, ist es sinnvoll, die bestehenden Varianten im Property Inspector einzusehen (oder über die Hilfe). Die Namen (Tag) der Objekte können mit Hilfe des Object Browsers ermittelt werden (bisher nur pushbutton1).

Beim Speichern wird in gui1.m für den Push-Button eine sogenannte Callback-Funktion erzeugt (Rückruffunktion) mit Namen pushbutton1_Callback. Diese Funktion wird aufgerufen, wenn der Benutzer beim Ausführen des GUIs auf den Button mit dem Namen (Tag) pushbutton1 drückt. Ein einfaches Beispiel für einen Programmcode (weiße Markierung):

Nach dem Ausführen (grüner Pfeil) wird beim Drücken des push-buttons ein neues Grafikfenster erzeugt und die Sinusfunktion im Bereich 0 und 2*pi gezeichnet.

function pushbutton1_Callback(hObject, eventdata, handles) % hObject handle to pushbutton1 (see GCBO) % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) figure; %Erzeuge neues Grafikfenster fplot('sin(x)',[0,2*pi]); %Zeichnen der Funktion sin(x) im Bereich 0 .. 2pi grid on; %Gitternetz erzeugen


- 28 -

7.2.2 Erweiterung der Handles-Struktur, Stringverarbeitung, Alignment (text-, edit-, axes-widgets) In einem zweiten GUI (gui2) soll die Funktion sin(a*x) gezeichnet werden in einem festen Intervall [-pi,pi]. Der Wert von a soll über ein Edit-Fenster eingegeben werden (standardmäßig ist a = 1); die Ausgabe erfolgt in einem Grafikfenster auf der gleichen graphischen Oberfläche. Benötigt wird ein Text- (text), ein Eingabe- (edit) sowie ein grafisches Ausgabefeld (axes). OptischeAusrichtungen und Abstände werden mit dem Tool Align-Objects eingestellt. Die Namen der Objekte (a_txt,a_edt,grafik_axes) wurden im Property Inspector geändert. Das Besetzen des Textfeldes, des Standardwertes im edit-Feld sowie die Standardausgabe erfolgt in der gui2_OpeningFcn. mit Hilfe dert set-Methode In diesem Beispiel wird zur Bereitstellung der oberen und unteren Grenze die handle-Stuktur um zwei Elemente (handle.o, handle.u) erweitert. Zur Speicherung dient der Befehl guidata(hObject, handles). Jede Funktion kann durch die automatisch eingestellte Parameterübergabe die Daten der Struktur handles benutzen und verändern. Eine Übersicht über die verwendeten handles erhält man durch Eingabe von handles. Über den Object Browser in gui2.fig können die erstellten Objekte eingesehen werden.

a_edt_Callback: beim Speichern von gui2.fig wird der Rumpf der Funktion a_edt_Callback im zugehörigen m-file gui2.m erstellt. Der hinzugefügte Code wird ausgeführt, wenn der Benutzer eine Eingabe im Feld a_edt macht und sie mit der Enter-Taste bestätigt. Dabei werden von der handles-Struktur handles.o und handles.u verwendet.

function gui2_OpeningFcn(hObject, eventdata, handles, varargin) % This function has no output args, see OutputFcn. % hObject handle to figure % eventdata reserved - to be defined in a future version of MATLAB % handles structure with handles and user data (see GUIDATA) % varargin command line arguments to gui2 (see VARARGIN) set(handles.text_a,'string','a'); %in Objekt a_txt a eintragen set(handles.text_a,'FontSize',12); %Schriftgroesse auf 12 setzen set(handles.edit_a,'string','1'); %Standardwert 1 im a_edit Objekt setzen set(handles.edit_a,'FontSize',12); %Schriftgroesse auf 12 setzen handles.u = -pi; %handle-Struktur erweitern um u handles.o = pi; %handle-Struktur erweitern um o x = linspace(handles.u,handles.o,100); y = sin(x); plot(handles.grafik_axes,x,y); %plotten in Objekt grafik_axes grid on; %Gitternetz erzeugen % Choose default command line output for gui2 handles.output = hObject; % Update handles structure guidata(hObject, handles); %handle-Struktur speichern % UIWAIT makes gui2 wait for user response (see UIRESUME) % uiwait(handles.figure1);

function a_edt_Callback(hObject, eventdata, handles)

a = str2double(get(hObject,'String')); if isnan(a) msgbox('Falsche Eingabe','Fehler'); else x = linspace(handles.u,handles.o,1000); y = sin(a*x); plot(handles.axes_grafik,x,y); grid on; end

Da die Eingabe in edit-Feld immer vom Typ string ist, muss sie in eine Zahl umgewandelt werden (str2double), um damit rechnen zu können, bzw. eine Fehlermeldung ausgegeben werden bei falscher Eingabe. Bei einer Ausgabe einer Zahl in einem edit-Feld muss dieser Wert wieder in einen String (num2str) umgewandelt werden. 7.2.3 SelectionChange-Funktionen, Eventdata (Radio Button Group)


- 29 -

Das dritte GUI ähnelt dem zweiten. Die zu zeichnenden Funktionen sollen über eine Button Group ausgewählt werden. Zunächst wird die Button Group ausgewählt und anschließend die einzelnen Elemente eingefügt. Die grafische Anordnung wird über das Align-Objects-Tool angepasst. Zudem wird ein Grafik-Steuerelement (axes) benötigt. In der gui3_OpeningFcn werden die Voreinstellungen mit der set-Funktion gesetzt: 1. Die Überschrift der Gruppe 2. Die Beschriftungen der Button-Group. 3. Die Ausgabe der sin(x)-Funktion in dem axes-widget Standardmäßig ist das erste Element der Gruppe gesetzt und wird auch so angezeigt.

function gui3_OpeningFcn(hObject, eventdata, handles, varargin) %Besetzen der Überschriften set(handles.uipanel1,'Title','Funktion auswählen'); %Titel ändern set(handles.radiobutton1,'String','sin(x)'); set(handles.radiobutton2,'String','cos(x)'); set(handles.radiobutton3,'String','sin(x) * cos(x)'); set(handles.radiobutton4,'String','sin(2*x)'); set(handles.radiobutton5,'String','cos(2*x)'); set(handles.radiobutton1,'Value',1.0); %radiobutton1 ist ausgewählt fplot(handles.axes1,'sin(x)',[-pi,pi]) grid on; handles.output = hObject; % Update handles structure

guidata(hObject, handles); % UIWAIT makes gui3 wait for user response (see UIRESUME)

Eine Aktion soll erfolgen, wenn der Benutzer auf einen Button drückt. Da im m-file keine Callback-Funktion für die Gruppe automatisch erstellt wurde, muss sie per Hand hinzugefügt werden. Dazu wird die Button Group markiert, über die rechte Maustaste View Callbacks und SelectionChangeFcn ausgewählt. In der Übergabevariablen eventdata sind jeweils die alten und die neuen Werte der Gruppe gespeichert. Mit Hilfe der get-Funktion wird der vom Benutzer ausgewählte Name des Objektes eingelesen und anschließend ausgewertet.

function uipanel1_SelectionChangeFcn(hObject, eventdata, handles) x = linspace(-pi,pi,1000); switch get(eventdata.NewValue,'Tag') % Get Tag of selected object. case 'radiobutton1' y = sin(x); case 'radiobutton2' y = cos(x); case 'radiobutton3' y = sin(x).*cos(x); case 'radiobutton4' y = sin(2*x); case 'radiobutton5' y = cos(2*x); otherwise msgbox('nichts ausgewählt','Fehlermeldung'); end plot(handles.axes1,x,y); grid on;


- 30 -

7.2.4 Eigene Funktionen, Ausgabe in ein text- oder edit-Feld Es ist zudem möglich, eigene Funktionen dem m-File hinzuzufügen. Das ist sinnvoll, wenn bei verschiedenen Benutzereingaben immer der gleiche Programmcode ausgeführt werden soll. In gui4 wird, abhängig von den Eingaben der Benutzer, ein Polynom 2. Grades gezeichnet. Die Koeffizienten (a,b,c) sowie das Intervall können eingegeben werden; Standardwerte sollen gesetzt sein. Das Polynom wird in einem Textfeld ausgegeben. Die Eingaben in den edit-Widgets werden auf Gültigkeit geprüft. Nach jeder Eingabe soll das Polynom neu gezeichnet werden. Zuerst wird die grafische Oberfläche mit guide aufgebaut, über das Align-Object-Tool die Ausrichtung festgelegt. und mit Hilfe des Property-Inspectors die Namen (tags) der Objekte geändert. In der Funktion gui4_OpeningFcn werden die Standardwerte gesetzt, die handles-Struktur erweitert um a,b,c,o,u sowie die Funktion polynom(handles) aufgerufen.

function gui4_OpeningFcn(hObject, eventdata, handles, varargin) %Besetzen der Überschriften der Textfelder set(handles.text_a,'string','a'); set(handles.text_b,'string','b'); set(handles.text_c,'string','c'); set(handles.text_Intervall,'string','Intervall'); set(handles.text_u,'string','untere Grenze') ;set(handles.text_o,'string','obere Grenze'); set(handles.text_Funktion,'string',''); %Setzen der Default-Werte in den edit-Feldern set(handles.edit_a,'string','1'); set(handles.edit_b,'string','1'); set(handles.edit_c,'string','1'); set(handles.edit_u,'string','0'); set(handles.edit_o,'string','1'); % Erweitern der handles-Struktur um a,b,c,u,o handles.a = str2double(get(handles.edit_a,'string')); handles.b = str2double(get(handles.edit_b,'string')); handles.c = str2double(get(handles.edit_c,'string')); handles.u = str2double(get(handles.edit_u,'string')); handles.o = str2double(get(handles.edit_o,'string')); Polynom(handles); %Zeichnen des Polynoms handles.output = hObject; % Update handles structure guidata(hObject, handles); % UIWAIT makes gui4 wait for user response (see UIRESUME) % uiwait(handles.figure1);


- 31 -

In den Callback-Funktionen der entsprechenden edit-Widgets erfolgt die Prüfung der Gültigkeit sowie ein Aufruf der Funktion Polynom. Hier als Beispiel die Funktion edit_a_Callback.

In den anderen edit-Callback-Funktionen wird der Code entsprechend angepasst. Die Funktion Polynom wird von jeder edit-Callback aufgerufen zum Zeichnen des Polynoms und der Ausgabe der Funktion in einem Textfeld. Um auf die Eigenschaften der Objekte zugreifen zu können, ist es nötig, die handles als Übergabeparameter zu benutzen. In diesem Beispiel werden die handles nur zur Übergabe der Polynomkoeffizienten, sowie der unteren und oberen Grenze eingesetzt.

function edit_a_Callback(hObject, eventdata, handles)% Hints: get(hObject,'String') returns contents of edit_a as text % str2double(get(hObject,'String')) returns contents of edit_a as a double % Speichere den Inhalt des edit_a-Feldes in der lokalen Variablen a a = str2double(get(handles.edit_a,'string')); if ~isnan(a) %Gültigkeitsprüfung handles.a = a; %Speichern des Wertes in handles.a guidata(hObject, handles); % Update handles structure Polynom(handles); %Aufruf der Funktion Polynom else msgbox('Falsche Eingabe'); %Fehlermeldung end

function Polynom(handles) x = linspace (handles.u,handles.o,1000); % Berechne x-Werte y = handles.a*x.^2 + handles.b*x + handles.c; % Berechne y-Werte plot(handles.axes_Polynom,x,y); % Zeichnen des Polynoms grid on; % Gitternetz an % Erzeugen des Strings für die Ausgabe in das Textfeld Text = strcat('f(x) = ',num2str(handles.a),' x^2 + ', ... num2str(handles.b),'x + ',num2str(handles.c)); % Ausgabe des Polynoms in das Textfeld text_Funktion set(handles.text_Funktion,'string',Text);

Zur Erzeugung des Ausgabetextes müssen die Werte wieder in Strings umgewandelt werden. Dazu wird der Befehl num2str verwendet. Die umgewandelten Werte der handles sowie die nötigen Textzeichen werden mit der Funktion strcat aneinandergehängt und in der Variablen Text abgespeichert. Anschließend erfolgt die Ausgabe in das Text-Feld mit Hilfe des set-Befehls. Wird zur Ausgabe anstelle des Text-Feldes ein edit-Feld benutzt, kann eine Eingabe durch den Benutzer gesperrt werden mit Hilfe der Option enable, z. B. set(handles.edit_output,'enable','off'). ________________________________________________________________________________________________ Literaturhinweis: Susanne Teschl MATLAB – Eine Einführung 2001 Gunther Jäger, Numerische Mathematik FHD 2003 MATLAB R2008b – Product Help Ulrich Stein, Einstieg in das Programmieren mit MATLAB

Documents

MATLAB - Kurzanleitung - Hochschule · PDF fileMATLAB – Kurzskript WS 2010/2011 Mathematisches Labor I/II FB MN - 2 - Current Directory Das Current Directory ist das aktuelle Arbeitsverzeichnis