Docstoc

Einführung in MATLAB

Document Sample
Einführung in MATLAB Powered By Docstoc
					Einführung in MATLAB


Ein Skript zur Vorlesung/Übung Modellierung von Bioprozessen des Lehrstuhls für
Bioprozesstechnik der Otto-von-Guericke-Universität Magdeburg (Fakultät für
Verfahrens- und Systemtechnik, Institut für Verfahrenstechnik)




Inhaltsverzeichnis

     1. ... Start von MATLAB ....................................................................... 2
     2. ... Arbeiten im interaktiven Modus .................................................... 2
     3. ... Variablen in MATLAB .................................................................. 3
     4. ... Vektoren und Matrizen .................................................................. 5
     5. ... Operationen mit Feldern ................................................................ 8
     6. ... Elementare mathematische Funktionen ......................................... 9
     7. ... Algebra und Symbolische Berechnungen .................................... 10
     8. ... Einfache Datenanalyse ................................................................ 13
     9. ... Laden und Speichern der Arbeitsumgebung ................................ 14
     10. . Grafische Darstellung und Beschriftung ...................................... 15
     11. . Einführung in MATLAB Programme .......................................... 17
     12. . Selbstdefinierte Funktionen ......................................................... 20
     13. . Programmflusssteuerung.............................................................. 21
     14. . Strings (Zeichenketten) ................................................................ 23
     15. . Zu guter Letzt ............................................................................... 23




                                                                Lehrstuhl für Bioprozesstechnik, Lars Voges
1. Start von MATLAB

Starten Sie das Programm MATLAB durch Doppelklick auf das MATLAB-Symbol. Das
Kommandofenster (Command Window) wird geöffnet, aus dem heraus mit dem
MATLAB-Interpreter kommuniziert werden kann.


2. Arbeiten im interaktiven Modus

Der Interpreter meldet mit einem Prompt >>, dass Sie jetzt beliebige mathematische
Ausdrücke eingeben können, die umgehend berechnet werden (interaktiver Modus), wenn
man die Eingabe mit der Enter-Taste abschließt. Drei einfache Eingaben sollen die ersten
Versuche darstellen:

       >> 2+2

       ans = 4

       >> 2*sin (pi/4)

       ans = 1,4142

       >> ans ^ 2

       ans = 2.000

Die Variable pi = 3,1415... ist in MATLAB enthalten. Man sollte dieser Variablen keinen
anderen Wert zuweisen. Nach jeder eingegebenen Zeile speichert MATLAB die Antwort
in einer Variablen ans für answer zwischen, die Ihnen dann auch angezeigt wird. Mit
dieser Variablen können Sie im nächsten Schritt weiter rechnen. Als Standard werden die
Ergebnisse mit vier Stellen nach dem Komma ausgegeben. In MATLAB müssen Sie jede
mathematische Operation mit eingeben. 2 pi z.B. wird nicht als 2 * pi interpretiert. Die
meisten Fehlermeldungen resultieren aus dieser Falscheingabe.

Sie können Ausdrücke mit Hilfe der üblichen arithmetischen Operatoren bilden. Die
Klammern werden dann eingesetzt, wenn die Reihenfolge der Operationen gesteuert
werden soll (oder aber auch, wenn Ihnen der Ablauf der Reihenfolge unklar ist).


Arithmetische Operatoren:

       +         Addition
       -         Subtraktion
       *         Multiplikation
       /         rechte Division
       \         linke Division
       ^         Potenzieren

Die linke und rechte Division liefern folgende Ergebnisse: 3 / 4 = 0,75 und 3 \ 4 = 1,333.
Vertauscht man bei Skalaren die Reihenfolge und die Art der Division, so ergibt z.B. 1 / 4


                                            2
und 4 \ 1 jeweils denselben Wert, also =0,25. Bei Matrizen sind die Ergebnisse bei
Umstellung verschieden.


3. Variablen in MATLAB

Sie können dadurch, dass Sie Berechnungen einer Variable, die verschieden von ans ist,
zuweisen, dieses Ergebnis der Rechnung für spätere Operationen speichern. Zum Beispiel

       >> x = pi/7

ergibt die Antwort

       x = 0.4488

Das Format der Anzeige können Sie mit dem Befehl format wählen. Durch den Befehl
format short e wird der Wert der Variablen x in einem anderen Format dargestellt. Es
genügt, anschließend x einzugeben und die Eingabe mit Enter abzuschließen:

       >> format short e

       >> x

       x = 4.4880e-001

Über alle Operatoren und Befehle (oder Funktionen) kann man kurze Angaben mit dem
Befehl help erhalten. So liefert

       >> help format

eine kurze Beschreibung aller erhältlichen Formate. Im interaktiven Modus können Sie so
durch Experimentieren die Formate kennenlernen.
Weiß man den Namen des Befehls nicht genau, kann einem die Eingabe lookfor Name
weiterhelfen. Die Eingabe

       >>lookfor exponential

       EXP            Exponential.
       EXPM           Matrix exponential.
       EXPM1          Matrix exponential via Pade approximation.
       EXPM2          Matrix exponential via Taylor series.
       EXPM3          Matrix exponential via eigenvalues and eigenvectors.
       EXPINT         Exponential integral function, E1(x).
       EXPME          Used by LINSIM to calculate matrix exponentials.

liefert Ihnen alle Befehle, die mit dem Begriff exponential zu tun haben.
Anschließend können Sie sich dann mit help Befehl die genaue Funktionsweise des in
Betracht kommenden Befehls erklären lassen.
Noch weiterführende Hilfe bekommen Sie mit dem Befehl helpwin aus dem Menü Hilfe,
der Ihnen ein Fenster öffnet, in dem Sie sich durch eine Liste aller Befehle blättern können,
und der Befehl helpdesk ein HTML Interface zum Hilfesystem.

                                             3
Wird am Ende der Eingabezeile ein Semikolon (;) mit eingegeben, z.B.

       >> y = sin (x) ^ 2 + cos (x) ^ 2;

so können Sie dadurch die Anzeige des Wertes von y unterdrücken. In diesem Fall wird
nur die Variable y erzeugt und ihr der entsprechende Wert zugewiesen. Das können Sie
durch Eingabe von >> y (ohne Semikolon!) und Enter überprüfen.

Auf diese Weise können Sie in einem Programm die Anzeige von Zwischenergebnissen
unterdrücken, indem die entsprechende Zeile mit einem Semikolon abgeschlossen wird.
Beim Testen von Programmen können dann auch gezielt Zwischenergebnisse angezeigt
werden, wenn in der entsprechenden Zeile das Semikolon weggelassen wird. Die Ausgabe
(gerade von größeren Feldern oder Matrizen) kann durch die Tastenkombination Strg-C
beendet werden.

Generell müssen die Variablennamen mit einem alphabetischen Zeichen beginnen und
dürfen nicht länger als 19 Zeichen sein. Weiterhin unterscheidet MATLAB zwischen
Groß- und Kleinschreibung. Die Variablen

       >> spannung = ... ;    und die Variable >> Spannung = ...;

sind zwei unterschiedliche Variablen. Diese Unterscheidung kann jedoch mit dem Befehl
casesen off aus- und mit casesen on wieder eingeschaltet werden (case sensitiv).
Die MATLAB Schlüsselworte, wie z.B. die Namen der Funktionen (sin, cos, sqrt,...)
müssen klein geschrieben werden.

Die Befehle who und whos listen alle Variablen auf, die bisher erzeugt worden sind und
im Speicher noch zur Verfügung stehen. Es können alle Variablen auf einen Schlag mit
dem Befehl clear all gelöscht werden oder gezielt durch Eingabe von z.B. clear x.
Generell sollte man sich angewöhnen, zu Beginn einer neuen Berechnung oder eines
Programms zunächst alle Variablen zu löschen, weil ansonsten residente Variablen zu
eigentümlichen Ergebnissen führen können. Weiterhin ist es sinnvoll, wenn größere Felder
oder Matrizen nicht mehr gebraucht werden und Platz im Speicher freigemacht werden
soll.

Wenn eine Zeile für einen Ausdruck oder ein Kommando nicht reicht, kann diese mit drei
(oder mehreren) Punkten beendet und in der nächsten Zeile weitergeschrieben werden:

       y1 =   2 * sin (pi * 2) + ...
              10.e-4 * cos (5.7 + 2);

In einer Zeile können auch mehrere Kommandos oder Ausdrücke eingegeben werden. Um
die Anzeige zu unterdrücken, werden sie durch Semikolons getrennt. Sollen die
berechneten Werte angezeigt werden, müssen Sie die Ausdrücke mit Kommas voneinander
trennen: In der Zeile

       >> y2 = y1 + 2.3e-3; x = 7.5 * exp (3), y3 = 3.5 * pi;

wird also nur das Ergebnis der Variable x angezeigt (es sind also auch Kombinationen von
Eingaben, die angezeigt werden mit nicht angezeigten möglich).

                                             4
Praktisch ist, dass die letzten eingegebenen Befehle mit der Pfeil-nach-oben Taste des
Cursorblocks wieder aufgerufen und anschließend verändert werden können. So kann man
sich (unter Umständen lästige) Schreibarbeit ersparen.

Ebenso wie die Zahl pi ist die Wurzel aus –1 in MATLAB vordefiniert. Ihr sind die zwei
Variablen i und j zugewiesen. Man sollte diese Variablen nicht für andere Zwecke (z.B. für
Schleifensteuerungen!!!) verwenden. Sollten Sie diesen Variablen aus Versehen doch ein
anderer Wert zugewiesen haben, so kann man diese Verletzung durch Zuweisen von

           >> j = sqrt (-1);

wieder rückgängig machen.

Komplexe Zahlen bestehen immer aus zwei Teilen und werden auch so angezeigt. Mit der
Eingabe

           >> i

und Enter (Achtung: Kein Semikolon am Ende der Zeile) bekommt man das Ergebnis in
der Form

           >> ans = 0+ 1.000 i

angezeigt. (Wer wie oben format short e eingegeben hat, erhält die Anzeige
ans = 0+ 1.000e+000i               Wie ist das zu verstehen? 1)

Komplexe Zahlen können folgendermaßen erzeugt werden:

           >> z1 = 1.2 + i * 2.8;                z2 = 1.23e-4 + j * 5.6e-2;

Diese komplexen Variablen kann man in gewohnter Weise addieren, subtrahieren,
multiplizieren, dividieren und potenzieren. Dabei werden die Regeln der Rechnung mit
komplexen Zahlen eingehalten.


4. Vektoren und Matrizen

MATLAB ist darauf getrimmt, Operationen mit Matrizen optimal durchzuführen (daher
auch der Name: MATrixLABoratory). Eine Matrix ist ein zweidimensionales Feld, das aus
Zeilen und Spalten besteht. Als Beispiel soll die (3 x 4)-Matrix A (aus drei Zeilen und 4
Spalten) mit beliebigen Werten für die Elemente dienen:

                    2.1      3        5.4        -7.1
           A=       -1       0        4.6        0.45
                    -3       2.9      10.2        5.7

In MATLAB wird die Matrixvariable A mit folgender Syntax gebildet:

           >> A = [2.1, 3, 5.4, -7.1; -1, 0, 4.6, 0.45; -3, 2.9, 10.2, 5.7];

1
    Auf „deutsch“: ans = 0 + 1.000 * 10000 * i

                                                         5
Das Komma trennt Elemente derselben Zeile, das Semikolon die Zeilen voneinander. Statt
der Kommas können auch Leerstellen, statt der Semikolons auch Zeilenvorschübe (Enter-
Taste) stehen. Eine zweite Matrix B könnte also auch folgendermaßen definiert werden:

       >> B = [ -1 1 -1
       1 –1 1
       -1 1 –1]

und liefert folgende Anzeige:

       B=
              -1        1       -1
              1         -1      1
              -1        1       -1

Auf die Elemente einer Matrix kann mit Hilfe von Indizes zugegriffen werden. So ergibt
z.B.

       >>A(2, 3)
       ans = 4.6000

weil das Element der zweiten Spalte und dritten Zeile diesen Wert besitzt. Ein Vektor ist in
MATLAB eine Matrix mit nur einer Zeile oder nur einer Spalte (entsprechend Zeilen- oder
Spaltenvektor), ein Skalar eine punktförmige Matrix.
Generell können die Elemente der Vektoren oder Matrizen auch Ausdrücke sein, wie z.B.
im Zeilenvektor X:

       >> X = [-1.3, sqrt(3), (1+2+3)*4/5];

Auch hier greift man auf die einzelnen Elemente über Indizes zu. Alle Indizes beginnen
mit 1 (nicht mit 0), deshalb ist X (1, 3) = 4.8, was auch durch die Eingabe von X (3)
erreicht werden kann. Neue Komponenten können direkt über einen entsprechenden Index
hinzugefügt werden, wie z.B. durch X (4) = 2.4. Durch Eingabe von

       >> Y = [1, X];

entsteht ein neuer Zeilenvektor mit 5 Elementen, wobei das erste Element 1 ist und die
anderen Elemente vom Vektor X stammen. Spaltenvektoren werden durch Eingabe von
Semikolons statt der Kommas erzeugt (z.B. Y = [2; 3; 4; 5]) der Zugriff auf die einzelnen
Elemente kann auch hier wieder mit einem oder zwei Indizes erfolgen (so liefert Y (4, 1)
oder Y (4) das gleiche Ergebnis, den Wert 5). Die Größe einer Matrixvariablen kann mit
der Funktion size ermittelt werden. Die Antwort auf

       >> size (A)

       ans = 3 4

zeigt, dass die Matrix A (aus dem oberen Beispiel) aus drei Zeilen und vier Spalten
besteht. Die Länge eines Vektors kann man auch mit dem Befehl length erhalten.


                                              6
Es ist dringend zu beachten, dass Funktionen oder komplexe Zahlen innerhalb einer Matrix
oder eines Vektors keine Leerzeichen enthalten dürfen, da das Leerzeichen von MATLAB
als Trennzeichen zwischen zwei Elementen der Matrix interpretiert wird!!!

Die Transponierte einer Matrix (Vertauschung der Indizes, aus Spalten werden Zeilen und
umgekehrt), erhält man durch

       >> Z = X'

Auf diese einfache Art kann man aus Zeilenvektoren Spaltenverktoren erstellen und
umgekehrt.

Einfache Vektoren können in MATLAB mit Hilfe des Doppelpunkts erzeugt werden. Als
Beispiel erhält man mit der Anweisung

       >> x = 1: 2: 7

einen Zeilenvektor mit den Werten von 1 bis 7 und einem Inkrement von 2

       x=1 3 5 7

Mit Inkrement mit negativem Vorzeichen (also Dekrement) liefert die Anweisung

       >>y = 5: -1: -2

den Vektor

       y = 5 4 3 2 1 0 -1 -2

Als Inkrement bzw. Dekrement können auch rationale Zahlen eingesetzt werden. Es lassen
sich so beliebige Sequenzen generieren. Der letzte Wert des Vektors wird kleiner oder
gleich dem Wert sein, der in der Anweisung an letzter Stelle angegeben ist. Die Anweisung

       >> z = 0: 1.5: 5

wird folgenden Zeilenvektor generieren:

       z=0    1.5000      3.000   4.5000

Lässt man das Inkrement fort, so wird es automatisch auf 1 gesetzt. Die Anweisung

       >> u = 1: 6

generiert dann den Zeilenvektor

       u=1 2 3 4 5 6

Matrizen können addiert und subtrahiert werden, wenn sie die gleiche Größe besitzen,
multipliziert und dividiert werden, wenn die Anzahl der Spalten der ersten Matrix gleich
der Anzahl der Zeilen der zweiten Matrix entspricht. Sollen Matrizen elementweise
miteinander multipliziert werden, so geschieht dies in der Form

                                           7
       >> z = x .* y

für Multiplikation, bzw. ./ für Division, .^ 2 für elementweises Quadrieren (also jeweils mit
. vor dem Operationszeichen).
Auf weitere Matrizenmanipulationen soll an dieser Stelle nicht eingegangen werden.


5. Operationen mit Feldern

Es gibt 6 Vergleichsoperatoren, die man beim Vergleich von zwei Feldern oder Matrizen
einsetzen kann. MATLAB vergleicht die Paare der entsprechenden Elemente und liefert
eine Matrix mit Einsen und Nullen, so dass die Einsen das Erfüllen (true) und die Nullen
das Nichterfüllen (false) der Vergleichsoperation darstellen.

Vergleichsoperatoren

<       kleiner als
>       größer als
==      gleich
<=      kleiner oder gleich
>=      größer oder gleich
~=      nicht gleich


Logische Operationen

Es gibt drei logische Operatoren, die bei Feldern Element-zu-Element wirken. Durch C =
A&B; erhält man eine Matrix, die Einsen an den Stellen enthält, an denen die Elemente
von A und B verschieden von Null sind und Nullen an den Stellen, an denen mindestens
eins der entsprechenden Elemente Null ist.
Ähnlich ergibt C = A|B; eine Matrix, deren Elemente Eins sind, wenn mindestens eins der
entsprechenden Elemente verschieden von Null ist, oder genau dann Null sind, wenn die
Matrizen an beiden Stellen Nullwerte enthalten.
Wird eine Matrix durch C = ~A definiert, so hat sie Einsen an den Stellen, an denen A
Nullwerte besitzt und Nullwerte dort, wo die Elemente von A verschieden von Null sind.
Die Funktionen any und all sind sehr nützlich in Verbindung mit logischen Operatoren.
Mit der Funktion any (X) erhält man einen Zeilenvektor, der an der Stelle eine Eins
enthält, an der mindestens ein Element der jeweiligen Spalte der Matrix verschieden von 0
ist, ansonsten ergibt sie eine Null. Die Funktion all (X) liefert dann eine Eins, wenn alle
Elemente der Spalte verschieden von Null sind. (Siehe dazu auch Kapitel 8!). Gerade in
Zusammenhang mit der if-Funktion sind diese Befehle sehr nützlich, z.B.

       if all (X < 1.5)
                irgendwelche Befehle
       end;

Die if-Befehle benötigen eine einzige Bedingung in bezug auf einen Skalarwert. Der
Ausdruck (X < 1.5) liefert eine Matrix ans, die an den Stellen, an denen die Bedingung
erfüllt ist, Einsen enthält und ansonsten Nullwerte besitzt. Mit all (ans) erhält man einen


                                             8
Skalarwert gleich Eins (true), wenn alle Elemente der Matrix ans verschieden von Null
sind und somit die Möglichkeit, das Ergebnis für die if-Anweisung zu verwenden.


Weitere Vergleichs- und logische Funktionen

      any           logische Bedingung
      all           logische Bedingung
      find          findet Indizes der Matritzen, die logische Bedingungen erfüllen
      exist         testet, ob eine Variable existiert
      isnan         detektiert die Not-a-Number Elemente
      isinf         detektiert unendliche Elemente
      finite        testet, ob Elemente begrenzt sind
      isemty        detektiert leere Matrizen ([ ])
      isstr         detektiert Zeichenvariablen (String)
      isglobal      detektiert globale Variablen


6. Elementare mathematische Funktionen

Es gibt einen Satz von elementaren mathematischen Funktionen, die für elementweise
Operationen eingesetzt werden können. Die meisten mathematischen Funktionen, die in
einem guten wissenschaftlichen Taschenrechner vorhanden sind, findet man auch in
MATLAB. Einfache Experimente und die Beschreibungen, die mit der help-Funktion
erhältlich sind, klären die Funktionsweise dieser Befehle und Funktionen:


Trigonometrische Funktionen

      sin     Sinus
      cos     Cosinus
      tan     Tangens
      asin    Arc-Sinus
      acos    Arc-Cosinus
      atan    Arc-Tangens
      sinh    Sinushyperbolicus
      cosh    Cosinushyperbolicus
      tanh    Tangenshyperbolicus
      asinh   Arcussinushyperbolicus
      acosh   Arcuscosinushyperbolicus
      atanh   Arcustangenshyperbolicus


Mathematische Funktionen

      sqrt    Quadratwurzel
      exp     Exponential zur Basis e
      log     natürlicher Logarithmus (ln)
      log10   Logarithmus zur Basis 10
      log2    Logarithmus zur Basis 2
      round   Runden (gegen ganze Zahlen)

                                             9
       fix     Runden gegen Null
       floor   Runden gegen - Unendlich
       ceil    Runden gegen + Unendlich
       abs     Betrag (komplexe Variable)
       angle   Winkel (komplexe Variable)
       real    Realteil
       imag    Imaginärteil
       conj    Konjugierte
       sign    Signum Funktion
       rem     Rest nach Division


7. Algebra und Symbolische Berechnungen

In MATLAB können Sie auch symbolische Berechnungen vornehmen, wenn dazu die
notwendige Toolbox auf Ihrem Rechner installiert ist. Testen können Sie dies durch
Eingabe von >> help symbolic.
Als erstes müssen dann die Variablen, die Sie benutzen wollen, als symbolische Variablen
definiert werden:

       >> syms x y
       >> (x + y) * (x + y) ^ 2

       ans = (x + y) ^ 3

       >> expand (ans)

       ans = x ^ 3 + 3 * x ^ 2 * y + 3 * x * y ^ 2 + y ^ 3

       >> factor (ans)

       ans = (x + y) ^ 3


Mit dem Befehl expand können Sie also Klammerausdrücke ausmultiplizieren, factor
bewirkt genau das Gegenteil. Beachten Sie dabei, dass Ihnen numerische Lösungen
eingerückt präsentiert werden, symbolische hingegen linksbündig.
Hilfreich ist auch der Befehl

       >> simplify ((x ^ 2 – y ^ 2) / (x – y))

       ans = x + y

der versucht einen Ausdruck so einfach wie möglich darzustellen.

Statt mit pi als Variable zu rechnen, können Sie MATLAB auch anweisen, die
symbolische Konstante  zu benutzen. Geben Sie dazu folgendes Beispiel ein:

       >> sin (pi)

ans = 1.2246 e-16

                                                 10
Die Ungenauigkeit rührt daher, dass MATLAB auf 15 Stellen hinter dem Komma genau
rechnet und nicht mit dem exakten Wert von . Für die exakte Lösung müssen Sie also die
symbolische Variable  kreieren, indem Sie sym('pi') eingeben (die Hochkommas, die über
die Taste # zu erhalten sind!). Die Eingabe von

       >> sin ( sym('pi'))

       ans = 0

liefert das erwartete Ergebnis. Die Hochkommas verwandeln die Fließkommazahl pi in
eine Zeichenkette, der Befehl sym konvertiert die Zeichenkette in einen symbolischen
Ausdruck. Die Befehle sym und syms sind eng miteinander verwandt: So liefert syms x
und x = sym('x') dasselbe Ergebnis. Beachten Sie dabei, dass der Befehl syms permanent
ist, während sym nur einen temporären Effekt hat (solange man das Ergebnis nicht wie in x
= sym ('x') einer Variable zuweist!).

Hilfreich im Umgang mit Fließkommazahlen ist der Befehl vpa. Um z.B. die Wurzel aus 2
auf 50 Stellen hinter dem Komma genau zu berechnen, geben Sie Den Befehl

       >> vpa ('sqrt (2) ', 50)

       ans = 1.4142135623730950488016887242096980785696718753769

ein.

Für die Darstellung von symbolischen Variablen gibt es eine Funktion, mit der sich leicht
Grafiken erzeugen lassen. So erhält man mit

       >> syms x
       >> ezplot (x ^ 2, [-2, 2])

auf einfache Weise eine Darstellung der Normalparabel im Bereich von –2 bis 2.
Weiterhin können Sie algebraische Gleichungen lösen lassen (Nullstellensuche).

       >> solve (‘x ^ 2 + 2 * x – 4 =0’)

       ans =
                 [ 5 ^ (1 / 2) –1]
                 [-1 – 5 ^ (1 / 2)]

Sie erhalten also die symbolischen Lösungen  1  5 , da der Befehl solve Element der
symbolischen Toolbox ist. Um numerische Lösungen zu bekommen, geben Sie double
(ans) ein, was Ihnen das Ergebnis als Fließkommazahl darstellt.
Der Befehl solve kann auch Polynome höheren Grades lösen sowie verschiedene andere
Arten von Gleichungen. Geben Sie z. B.

       >> solve('x + log (y) = 3', 'y')

ein, um die genannte Gleichung für y in Abhängigkeit von x zu lösen.


                                           11
Manchmal gibt es mehr als eine Lösung und das Ergebnis wird einem nicht wie erwartet
präsentiert: Die Berechnung von

       >> solve ('exp(-x) = sin (x) ')

liefert als Ergebnis nur die komplexe Zahl

       ans =
-2.0127756629315111633360706990971+2.7030745115909622139316148044265*i

obwohl verschiedene reelle Lösungen existieren. (Stellen Sie beide Graphen für –1  x 
10 dar, dann sehen Sie die Schnittpunkte!) Numerische Lösungen für dieses Problem
können Sie mit dem Befehl

       >> fzero ('exp(-x) – sin(x) ', 0.5)

in der Nähe von x = 0,5 finden. Für die nächste Lösung ersetzen Sie 0,5 durch 3 usw.

In MATLAB können Sie auf einfache Weise Funktionen erstellen, mit denen Sie im
Anschluss Rechenoperationen ausführen können:

       >> f = inline ('x^2', 'x')

       f=
                 inline function:
                 f(x) = x^2

Das erste Argument in inline ist eine Zeichenkette, die den Ausdruck, der die Funktion
beschreibt, enthält. Die zweite Zeichenkette erklärt die unabhängige Variable, in diesem
Fall x. Berechnungen mit dieser „neuen“ Funktion können Sie wie folgt durchführen:

       >> f(4)

       ans =
                 16

Um eine Funktion zu erzeugen, die Ihnen auch für Vektoren gültige Ergebnisse liefert,
müssen Sie die vectorize Funktion benutzen:

       >> f = inline (vectorize ('x^2'), 'x')

       f=
                 inline function:
                 f(x) = x.^2

Jetzt können Sie f auch auf einen Vektor anwenden:

       >> f (1 : 5)

       ans =
                 1 4 9 16 25

                                                12
Darüber hinaus können Sie inline auch dazu verwenden, Funktionen mit mehreren
Variablen zu definieren:

       >> g = inline (vektorize ('x^2 + y^2'), 'x', 'y')
       >> g (1, 2)

       ans =
               5


8. Einfache Datenanalyse

Wie bereits erwähnt sind Matrizen oder Felder sehr gut geeignet, Daten zu speichern und
sie dann als Variablen zur Verfügung zu stellen (die Spalten einer Matrix stellen dann die
Werte je einer Variablen dar, d.h. alle Elemente einer Spalte werden je einer Variablen
zugeordnet). Dadurch enthält eine (m x n)-Matrix die m Werte (mit m gleich Anzahl der
Zeilen) von n Variablen (mit n als Anzahl der Spalten). Als Beispiel soll die Matrix A mit
10 Zeilen und 6 Spalten dienen:

       >> A = 10 * randn (10,6)

Die einfache Funktion max(A) liefert einen Zeilenvektor mit den Höchstwerten der
einzelnen Spalten. Mit cumsum(A) werden die Werte der Spalten aufakkumuliert. Das
Ergebnis ist eine Matrix mit gleicher Anzahl von Spalten und Zeilen wie A (Annäherung
der Integration entlang der Spalten.) Analog dazu ergibt die Funktion diff eine Annäherung
der Ableitung.

Mit cov(A) (für den Fall, dass A immer noch eine Matrix ist) erhält man die
Kovarianzmatrix der Variablen, die in den Spalten enthalten sind. Für die gezeigte Matrix
A mit 6 Spalten (bzw. mit 6 Variablen) ergibt sich eine symmetrische 6 * 6 Matrix, die in
der Diagonale die Varianzen der Variablen enthält.


Spaltenweise Datenanalyse-Funktionen

       max            Maximalwert
       mean           Mittelwert
       median         Medianwert
       sort           Sortieren
       cumsum         kumulative Summe
       prod           Produkt der Werte
       diff           Differenzen der Werte
       hist           Histogramm (Häufigkeitsverteilung)
       cov            Kovarianz-Matrix
       min            Minimalwert
       std            Standardabweichung
       sum            Summe der Werte
       cumprod        kumulatives Produkt
       corrcoef       Korrelationskoeffizient


                                               13
Die Funktion std(A) liefert die Standardabweichungen der Daten in den Spalten. Die
Quadratwerte der Standardabweichungen

>> std(A).^2

sind die Varianzen, die auch in der Matrix cov(A) enthalten sind.

Wenn A ein Zeilenvektor ist, dann arbeiten die Funktionen, als hätte A diesen Vektor als
Spalte. Zum Beispiel wird für

       >> x = [1 2 3 4 5 6 7 8 9 10]

die Anfrage max(x) die Antwort 10 ergeben (min liefert 1). Diese Erweiterung ist nützlich,
wenn Signale als Zeilenvektoren bearbeitet werden.

Die Funktion hist liefert die Häufigkeitsverteilung in einer beliebigen Anzahl von
Intervallen. Für eine normal verteilte Sequenz, z.B. bestehend aus 4000 Zufallswerten, die
im Zeilenvektor x enthalten sind

       >> x = randn(1, 4000)

ergibt der Befehl

       >> hist(x, 20);

die Darstellung der Häufigkeiten der Werte aus x, deren Bereich in 20 Intervalle zwischen
max(x) und min(x) unterteilt wurde. Mit einem Aufruf

       >> [H, ix] = hist(x, 20);

werden die Ergebnisse geliefert (in H die Werte der Häufigkeiten und in ix die Werte der
ermittelten Intervalle), die Darstellung wird unterdrückt. Sie kann mithilfe von leicht
verständlichen Befehlen selbst gestaltet werden (sie werden im übernächsten Kapitel
genauer erklärt).

       >> bar (ix, H);
       >> title (' Haufigkeitsverteilung ')


9. Laden und Speichern der Arbeitsumgebung

Die Arbeitssitzung im interaktiven Modus, z.B. bei einer Übung, kann mit dem Befehl
diary Dateiname.txt in einer Datei gespeichert werden. Alle Anweisungen und Befehle,
die im Anschluss (also nach Aufruf des Befehls diary...) über die Tastatur eingegeben
werden und die Ergebnisse (ohne Darstellungen), werden im ASCII-Format in der Datei
gespeichert. Mit diary on bzw. diary off kann das Tagebuch ein- und ausgeschaltet
werden. Anschließend können Sie sich alle Operationen, die im aktiven Modus des
Tagebuches eingegeben worden sind, mit einem Editor ansehen.


Laden und Speichern von Messdaten und Ergebnissen

                                              14
Meistens genügt bereits die Speicherung der Variablen: Um alle Variablen zu speichern,
reicht es aus den Befehl

       >> save Dateiname

einzugeben. Die Datei wird dann in der Form Dateiname.mat im aktuellen
Arbeitsverzeichnis angelegt. Sollen nur bestimmte Variablen gespeichert werden, ist es
nötig, sie am Ende der oben genannten Zeile aufzuführen:

       >> save Dateiname x, y, z

Wichtig ist, dass beim Speichern die Werte der Variablen nicht aus dem Hauptspeicher
gelöscht werden. (D. h. sie müssen nach wie vor mit clear, bzw. clear x gelöscht werden,
wenn man im gleichen Atemzug den Speicher wieder freigeben möchte).
Um in der nächsten Sitzung die Variablen wieder zu laden, geben Sie den Befehl

       >> load Dateiname

ein. Es stehen Ihnen dann wieder alle Variablen zur Verfügung, die Sie wie oben
beschrieben gespeichert haben.


10. Graphische Darstellung und Beschriftung

Die Daten, die in MATLAB in Form von Vektoren- oder Matrizenvariablen abgespeichert
sind, können vielfältig dargestellt werden.

Funktionen für die graphische Darstellung

       plot          lineare x-y Darstellung
       loglog        beide Achsen logarithmisch
       semilogx      x-Achse logarithmisch
       semilogy      y-Achse logarithmisch
       mesh          3-D-Darstellung (Gitter)
       surf          3-D-Darstellung (Gitter mit Farbflächen)
       contour       Konturdarstellung
       hist          Histogramm
       stairs        Treppendarstellung
       stem          Linien
       polar         polare Darstellung
       bar           Balkendiagramm

Die Beschreibung der Befehle kann über help aufgerufen werden.

Sobald eine graphische Darstellung erzeugt wurde, kann sie mit zusätzlichen
Beschriftungen versehen werden.


Beschriftungen:


                                            15
       title            Titel (Überschrift) der Graphik
       xlable           x-Achsenbeschriftung
       ylable           y-Achsenbeschriftung
       zlable           z-Achsenbeschriftung
       text             positionierter Text
       gtext            mit der Maus positionierter Text
       legend           fügt eine Legende in die Graphik ein
       grid             Gitter

Es gibt auch einige Befehle, mit deren Hilfe die Graphiken von MATLAB zusätzlich
gesteuert werden können.


Graphik-Steuerbefehle

       axis             manuelle Einstellungen der Bereiche der x- und y- Achse
       hold             „Einfrieren“ der Darstellung (Überlappen der Graphiken)
       clf              Löschen des laufenden Bildes
       subplot          Unterteilung des Bildes
       ginput           Positionieren von Text mit der Maus


Die Grundform des Plotbefehls

Wenn y ein Vektor ist, ergibt plot (y) eine Darstellung der Elemente in Abhängigkeit von
ihren Indizes, die mit einer Linie verbunden werden. In der Grundform plot (x, y), wenn x
und y zwei Vektoren derselben Art (Zeilen- oder Spaltenvektoren) und derselben Größe
sind, bildet der erste Vektor die Koordinaten entlang der Abszisse und der zweite Vektor
die Koordinaten entlang der Ordinate. Als Beipiel ergeben die Befehle

       >> t = 0:10e-3:1000e-3;
       >> y1 = 2.5 * sin (2 * pi * 5 * t);
       >> plot (t, y1);

eine Darstellung des sinusförmigen Signals y1. Wenn zusätzlich

       >> y2 = sign (cos (2 * pi * 10 * t));

definiert wird, dann können beide Signale mit

       >> plot (t, y1, t, y2);

dargestellt werden. Außerdem kann für jedes Variablenpaar (oder Funktionen) noch die
Farbe, der Typ der Linien und die Art der Markierung der Punkte gewählt werden:

       >> plot (t, y1, 'k:+ ', t, y2, 'r:o');

Die zur Verfügung stehenden Farben sind: 'c' (cyan), 'm' (magenta), 'y' (yellow), 'r' (red), 'g'
(green), 'b' (blue), 'w' (white), 'k' (black) und 'i' (invisible). Die Linientypen sind '-' für
solid, '--' für dashed, ':' für dotted, '-.' für dash-dot und ' ' für keine Linie. Die Markierungen
sind '.' (dot), '+' (plus), 'o' (circle), 'x' (x-mark) und '*' (star).

                                                16
Die Funktion plot öffnet automatisch ein Bild-Fenster, wenn noch keines vorliegt. Existiert
schon ein Fenster, dann wir dieses benutzt, der vorhergehende Graph gelöscht. Soll der
neue Graph dem alten Bild hinzugefügt werden, so kann die Darstellung mit hold on
„eingefroren“ werden, mit hold off wird wieder zum normalen Betrieb zurückgeschaltet.
Um ein neues Bildfenster zu öffnen benutzt man die Anweisung figure bzw. figure (n),
wobei n die laufende Nummer des zu öffnenden Fensters ist. Da der plot Befehl auch
Matrizen verarbeiten kann, kann man y1 und y2 auch zu einer Matrix zusammenfügen und
damit den oben benutzten Befehl vereinfachen:

       >> plot (t, [y1, y2]);

Es werden also alle Spalten der Matrix als Funktionen von x dargestellt. Der Befehl

       >> plot ([y1, y2], t);

ergibt eine Darstellung, die gegenüber der vorherigen Graphik um 90° gedreht ist.
Die Grenzen, zwischen denen die Darstellungen stattfinden, werden i. A. automatisch von
MATLAB bestimmt. Um sie zu ändern wird der Befehl axis benutzt. Mit

       >> Ko = axis

werden dem Vektor Ko (beliebiger Name) 4 Elemente geliefert, die die benutzten Grenzen
in der Form [xmin, xmax, ymin, ymax] zeigen. Durch die Anweisung

       >> axis ([Ko(1), 10, -2, Ko(4)]);

wird die Grenze von xmax auf 10 und die Grenze von ymin auf –2 verschoben. Die
restlichen Werte (Ko(1) und Ko(4)) werden unverändert übernommen. Es gibt noch eine
weitere Möglichkeit, eine teilweise automatische Wahl der Grenzen zu erzwingen:

       >> axis ([-inf, 5, 2, 2.5]);

weist MATLAB an, die xmin Grenze entsprechend der anderen Grenzen automatisch zu
wählen. Weitere Optionen sind über den Befehl help axis zu erhalten.

Als Beschriftung der x-Achsen liefert die Eingabe von

       >> xlabel (' t = 0 bis 100 s ')

den Text, der zwischen den Hochkommas eingegeben ist. Griechische Buchstaben können
über TEX bzw. LATEX Steuerbefehle eingegeben werden. So erreicht man durch

       >> xlabel (\phi = 0 bis 2\pi);

die Beschriftung  = 0 bis 2. Direkt positioniert werden kann Text mit

       >> text (2.5, sin (2 * pi *2.5), 'Spannung U');




                                             17
Über die Anweisung gtext kann interaktiv Text in den Plot eingebunden werden. Taucht
im Programm dieser Befehl auf, so wird erwartet, dass Sie die Stelle, wo der Text
eingefügt werden soll, anklicken.

Mit dem Befehl subplot (m, n, p) ist es möglich, das Graphikfenster zu unterteilen. Die
drei Dezimalzahlen geben dabei an, das das Fenster in m Zeilen und n Spalten unterteilt ist;
mit p kann eines der Elemente ausgewählt werden.
So kann ein Fenster zur Betrachtung von Ein- und Ausgangssignal idealerweise in zwei
Subplots eingeteilt werden.

Über die Funktion meshgrid erhält man Matrizen in 3-D-Darstellung. Mit den Befehlen

       >> x = -10 : 2 : 10;        y = -5 : 1 : 5;
       >> [X, Y] = meshgrid (x, y)

erhält man eine Matrix für ein zweidimensionales Koordinatensystem: Alle Zeilen der
Matrix X sind gleich dem Vektor x, die Spalten der Matrix Y sind gleich dem Vektor y.
Beide Matrizen übereinander gelegt ergeben dann die Koordinaten, die für die
dreidimensionale Darstellung notwendig sind. Durch

       >> Z = 1 ./ (1 + X .^ 2 + Y .^ 2);            mesh (X, Y, Z);

erhält man eine Gitter-Darstellung der Funktion z = 1 / (1 + x² + y²) im Bereich zwischen –
10 und 10 für die Variable x, und –5 bis 5 für die Variable y. Mit kleineren Schrittweiten
wird auch das Gitternetz feiner und man bekommt eine annähernd kontinuierliche
Darstellung. Jedem Knoten des Gitters entspricht ein Paar von Werten der Variablen aus X
und Y und ein Wert der Funktion Z.

Verwenden Sie an dieser Stelle auch die Funktionen surf und contour.


11. Einführung in MATLAB Programme

Bisher haben wir Befehle und Anweisungen im interaktiven Modus benutzt. In diesem
Kapitel sollen Sie nun selbst eigene Programme und Funktionen schreiben (und testen!).
Ein MATLAB Programm besteht aus Anweisungen oder Befehlen und aus Ausdrücken,
die im Allgemeinen Matrizen oder Felder manipulieren. Das Programm selbst kann im
MATLAB Editor oder einem einfachen Texteditor geschrieben und muss in einer Datei mit
der Endung m (daher der Name m-file) abgespeichert werden. Als Beispiel sollen Sie
zunächst ein Programm schreiben, dass einige statistische Eigenschaften der Daten, die in
den Spalten der Matrix A gespeichert sind, berechnet:

       % Programm zur Ermittlung der Maximal- und Minimalwerte, der
       % Mittelwerte und der Standardabweichungen der Daten aus A

       max_wert = max (A);           min_wert = min (A);
       mittel_wert = mean (A);       std_abw = std (A);

Mit den %-Zeichen können Kommentare in das Programm aufgenommen werden. Damit
MATLAB auf die Datei zugreifen kann, muss sie sich in demselben Verzeichnis befinden,
in dem auch MATLAB gespeichert ist (im Normalfall ...\matlab). Besser jedoch ist es ein

                                            18
extra Verzeichnis für Projekte anzulegen und MATLAB den Pfad zu den Projekten
mitzuteilen. Haben Sie z.B. ein Verzeichnis C:\...\MATLAB\work\Projekte (das können
Sie entweder im Explorer erledigen oder durch Eingabe des Befehls >> mkdir Projekte,
wenn Ihr aktuelles Arbeitsverzeichnis ...\work ist) angelegt, so können Sie mit der Eingabe
von

       >> chdir C:\...\MATLAB\work\Projekte

in dieses Verzeichnis wechseln oder mit

       >> addpath C:\...\MATLAB\work\Projekte

diesen Pfad der Pfadliste hinzufügen. MATLAB kann nur Dateien finden, die sich
entweder im aktuellen Arbeitsverzeichnis befinden oder das Verzeichnis Bestandteil der
Pfadliste ist. Welche Dateien sich im aktuellen Arbeitsverzeichnis befinden, bekommen
Sie mit der Eingabe dir (oder ls) im Programmfenster heraus. Möchten Sie nur die m-
Dateien, geben Sie what ein. Welches das aktuelle Verzeichnis ist, erhalten Sie durch den
Befehl cd. Die komplette Pfadliste wird Ihnen mit dem Befehl path angezeigt.

Speichern Sie die o.g. Programmzeilen, die Sie im Editor erstellt haben unter dem Namen
eigensch.m im oben beschriebenen Verzeichnis ab. Um die korrekte Arbeitsweise des
Programms zu testen, erzeugen Sie zunächst eine Matrix mit gleichverteilten Zufallszahlen
>> A = rand (10, 5). Anschließend können Sie mit der Eingabe von eigensch Ihr
Programm eingensch.m aufrufen, das jetzt den dort definierten Variablen die
entsprechenden Werte zuweist. Mit

       >> max_wert, min_wert, mittel_wert, std_abw

erhalten Sie den Inhalt der Variablen, den Sie sich auch direkt anzeigen lassen können,
indem Sie im m-file die Seminkolons hinter den Zeilen zur Berechnung fortlassen.
Ungünstig ist, dass nur Matrixvariablen mit dem Namen A untersucht werden können und
Ihnen das Ergebnis der Berechnungen in fest definierte Variablen gespeichert wird.
Geschickter ist es also, eine neue Funktion zu erzeugen, die Matrizen mit beliebigen
Namen untersuchen kann und die Ergebnisse in Variablen speichert, die je nach Bedarf
benannt werden können.

M-Dateien stehen Ihnen nicht nur für das Erzeugen von Funktionen zur Verfügung,
sondern auch als sogenannte Skript-Dateien. Statt im interaktiven Modus sollten Sie sich
angewöhnen, die Befehle und Operationen, die Sie berechnen lassen wollen, im Editor zu
erstellen und anschließend als m-Datei zu speichern (in Ihrem entsprechenden Verzeichnis,
s.o.).
Erstellen Sie in einem Editor z.B. folgende Zeilen:

       clear all
       format long
       x = [0.1, 0.01, 0.001]
       y = log (x) * x

Speichern Sie die Datei unter dem Namen Problem1.m ab. MATLAB wird dieses Skript
ausführen, wenn Sie im Programmfenster Problem1 eingeben. Auf diese Weise steht Ihnen
eine Sequenz später zur Verfügung, wenn Sie die Berechnung mit veränderten Werten

                                            19
noch einmal durchführen wollen, oder Sie können leicht Fehler korrigieren, ohne alle
Befehle erneut eingeben zu müssen. Beachten Sie dabei, dass sich alle Befehle so
auswirken, als wären sie direkt im Programmfenster eingegeben worden: Es werden also
alle weiteren Berechnungen mit 14 Stellen nach dem Komma ausgeben (so lange bis Sie
den Befehl format short eingeben). Die Befehle selbst hingegen werden nicht automatisch
im Programmfenster ausgegeben. Ist die Anzeige gewünscht, erreichen Sie dies durch den
Befehl echo on.

       echo on
       clear all
       format long
       x = [0.1, 0.01, 0.001]
       y = log (x) * x
       echo off

Zur Dokumentation können Sie wie in den m-Dateien auch hier Kommentare einfügen:

       echo on
       % alte Variablen entfernen
       clear all
       % Anzeige von 14 Nachkommastellen
       format long
       % Definition eines Vektors mit Werten für die unabhängige Variable
       x = [0.1, 0.01, 0.001]
       % Berechnung der Werte
       y = log (x) * x
       % Diese Werte zeigen, dass der Grenzwert von log (x) * x für x gegen
       % null ebenfalls null ist.
       echo off


12. Selbstdefinierte Funktionen

Eine neue Funktion wird mit dem Schlüsselwort function in der ersten Zeile eines
Programms definiert. Es folgen dann die zurückgelieferten Variablen in eckigen Klammern
mit Kommas oder Leerzeichen voneinander getrennt und daran anschließend – durch ein
Gleichheitszeichen verbunden – der Name für die Funktion. Dieser sollte auch der Name
für die Datei sein (m-file) unter der die Funktion abgespeichert und aufgerufen werden
kann. Nach dem Namen folgen in runden Klammern die Eingangsvariablen.
Die Variablen, die als Ergebnisse geliefert werden (max_wert, min_wert, ...) müssen im
Rumpf der Funktion definiert werden und Werte zugewiesen bekommen. Unsere Datei
eigensch.m als Funktion umgeschrieben sieht dann wie folgt aus:

       function [max_wert, min_wert, mittel_wert, std_abw] = eigensch (A)
       % Funktion zur Berechnung der Maximal- und Minimalwerte, der
       % Mittelwerte und der Standardabweichungen der Spalten in A
       % Testaufruf:
       % [maxi, mini, mitl, stda] = eigensch (rand (100, 5))

       max_wert = max (A);         min_wert = min (A);
       mittel_wert = mean (A);     std_abw = std (A);

                                          20
Nach dem Speichern kann diese Funktion einfach mit den verschiedensten laufenden
Parametern (oder Argumenten) aufgerufen werden:

       >> A = pascal (3, 1),       B = magic (6);
       >> [a_max, a_min, a_mitt, a_std] = eigensch (A);
       >> [b_max, b_min, b_mitt, b_std] = eigensch (B);

Die Kommentarzeilen (%-Zeichen), die zwischen der Zeile zur Definition der Funktion bis
zur ersten ausführbaren Anweisung geschrieben worden sind, werden beim Aufruf von
help eigensch angezeigt. Wie oben gezeigt, geben Sie dem Anwender hiermit die
Möglichkeit, Informationen über die Funktion und ihrer Parameter zu erhalten, deshalb
sollten sie sorgfältig gestaltet werden. Innerhalb der eckigen Klammern geben Sie die
Variablennamen an, in denen Ihnen die Funktion die Ergebnisse der Berechnungen
zurückliefern soll, hinter dem Namen der Funktion (in den runden Klammern) steht die
Variable, die der Funktion beim Aufruf übergeben wird.
Je nach Definition der Funktion können ihr auch mehrere Variablen beim Aufruf
übergeben werden.


13. Programmflusssteuerung

Wie in den meisten Computersprachen sind auch in MATLAB Befehle zur Steuerung des
Befehlsablaufes zu finden. Die Wiederholung von Befehlsabläufen können Sie mit der for
und while Schleife durchführen. Logische Bedingungen werden mit if Befehlen geprüft.
Außerdem steht Ihnen der Befehl switch mit der Bedingung case zur Verfügung.

Die for Schleife erlaubt, eine oder mehrere Anweisungen gesteuert zu wiederholen. Als
Beispiel soll die Schleife

       for k = 1 : 1 : n
              x(k) = 2.5 * sin (2 * pi * k / 25);
              y(k) = 7.5 * cos (2 * pi * k / 25);
       end;

dienen. Die Elemente der Vektoren x und y mit den Indizes von 1 bis n werden mit einer
sinus- bzw. cosinusförmigen Sequenz aufgefüllt. Die Schleife wird durchlaufen, solange k
kleiner oder gleich mit n ist. Bei der Schrittweite 1 für die Steuervariable k wird die
Schleife also genau n mal durchlaufen. Wenn n kleiner als 1 ist, wird zwar kein Fehler
gemeldet, es passiert aber auch nichts. Sie erhalten nur dann eine Fehlermeldung, wenn n
nicht definiert ist. (Ist n als reelle Zahl definiert, wird der ganze Teil der Zahl benutzt, ist n
komplex, wird die ganze Zahl des reellen Teils verwendet.)
Zwischen den Schlüsselworten for und end können beliebige Befehle vorkommen,
inklusive anderer for Schleifen, die dann ihre eigene end Anweisung besitzen müssen. Sie
sollten deshalb Schleifen entsprechend der Hierarchie eingerückt programmieren.

Die Steuervariablen der Schleifen kann man auch in umgekehrter Richtung laufen lassen,
die Schrittweite muss ebenfalls nicht unbedingt 1 entsprechen (beachten Sie jedoch, dass
bei rationalen Zahlen nur der ganzzahlige Teil berücksichtigt wird!).

       for k = 100 : -2 : 1

                                               21
               y(k) = x(100-k+1);
       end;

Die Ausführung der for Schleife können Sie beschleunigen, indem Sie Vektoren- oder
Matrixvariablen vorher initialisieren. Der MATLAB Interpreter muss dann nicht bei jedem
Durchlauf der Schleife die Matrixgröße neu einstellen. Folgendes Programmsegment soll
Ihnen verdeutlichen, was damit gemeint ist:

       y = zeros (1 : 100); % Die Initialisierung
       for k = 1 : 100
              y(k) = (1e-12 + sin (pi * (k –50) / 20)) / (pi * (k-50) / 20+1e-12);
       end;

MATLAB besitzt auch eine eigene Version der while Schleife, die die Wiederholung eines
(oder mehrerer) Befehls unter der Kontrolle einer logischen Bedingung ermöglicht. Ein
Programm, das die erste ganze Zahl n ermittelt, für die n! (Fakultät) einen Wert größer 100
erreicht, soll Ihnen die while Schleife verdeutlichen:

       n = 1;
       while prod (1 : n) < 100
              n = n + 1;
       end;

Die Anweisungen in der Schleife werden solange wiederholt, wie die skalare Bedingung
erfüllt ist, also den Wert 1 (true) liefert. Wenn Sie eine Bedingung über eine Matrix stellen
möchten, können die Funktionen any oder all zu einem Skalar führen. Achten Sie darauf,
dass keine unendliche Schleife entsteht, die nicht unterbrochen werden kann (falls Sie z.B.
while prod (1 : n) ~= 100 schreiben, da keine Fakultät genau den Wert 100 liefert).
Mit break können Sie die while oder for Schleife verlassen; mit return kehren Sie in die
MATLAB Kommandoumgebung zurück oder aus einer Funktion an die Stelle des
Programms zurück, aus der die Funktion aufgerufen wurde. Die oben genannte Schleife
könnte dann auch folgendermaßen aussehen:

       while 1
       ....
              if n = = 100, return;
              end;
       n = n + 1;
       end;


Die if Anweisung

Mit der if Anweisung können Sie skalare Bedingungen prüfen und die Ausführung des
Programms steuern. Das folgende Programm zeigt, wie abhängig vom Vorzeichen und
davon, ob n gerade oder ungerade ist, zunächst eine Meldung ausgegeben wird und
anschließend unterschiedliche Operationen mit der vorher definierten Matrix A
durchgeführt werden:

n = input ('Geben Sie einen Wert für n ein ');
if n < 0,                 disp ('n ist negativ!');   A = -A

                                              22
elseif rem(n,2) == 0,     disp ('n ist gerade!');     A = A./2
else,                     disp ('n ist ungerade!');   A = A./n
end;

Der Befehl input ermöglicht, Werte von der Tastatur einzugeben.


14. Strings (Zeichenketten)

Textstrings werden in MATLAB zwischen Hochkommas eingegeben, wie z.B. in s =
'Hello';. Der Text ist in einem Vektor abgespeichert mit je einem Element für ein Zeichen.
Die Größe von s können Sie mit size (s) ermitteln und liefert das Ergebnis ans = 1, 5 (also
ein Zeilenvektor mit 5 Elementen).

Die Funktion disp zeigt auf dem Bildschirm den Text ihres Arguments und die Funktion
isstr und strcmp detektieren bzw. vergleichen Zeichenketten. Textvariablen kann man
auch Werte der Parameter, die für eine bestimmte Darstellung relevant sind, in den Text
einbeziehen:

       sigma = 2,5;
       ueberschrift = ['Rauschsignal (Std = ',num2str(sigma), ')'];
       plot (sqrt (sigma)*randn(1,100));
       title(ueberschrift);

Der Befehl num2str (Numeric-to-string) wandelt den numerischen Wert sigma in einen
String um, der das zweite Element des String-Vektors aus den eckigen Klammern bildet.
Mit int2str und sprintf können numerische Werte in Zeichenketten umgewandelt werden.
Der sprintf Befehl ermöglicht, formatierte Daten in Zeichenketten zu schreiben. Durch :

       sprintf ('Das Feld ist %d mal %d gross', 2, 3)

Wird der Text D

       Das Feld ist 2 mal 3 groß

angezeigt. Dieser Befehl ist dann z.B. sehr nützlich, wenn Tabellen auf dem Bildschirm
auszugeben sind.


15. Zu guter Letzt

Die wichtigsten MATLAB Befehle haben Sie nun kennengelernt. Für das Erstellen Ihrer
m-Dateien möchte ich Ihnen noch ein paar Tipps mit auf den Weg geben:

   Schließen Sie genügend Kommentare mit in Ihr Programm ein. Die ersten Zeilen kann
    sich der Benutzer als Erklärung mit dem Befehl help anzeigen lassen (gerade bei
    Funktionen kann hier gezeigt werden, in welcher Form Variablen übergeben werden
    müssen).
   Die ersten Befehle sollten sein: clear all und close all.
   Benutzten Sie gerade in den ersten Probeläufen Ihrer m-Dateien den Befehl echo on,
    um Auslöser und Wirkung zu sehen.

                                             23
   Wenn Sie mit Grafiken arbeiten, überlegen Sie sich gut, an welcher Stelle der Befehl
    hold on oder hold off eingesetzt werden kann.
   Halten Sie an geeigneten Stellen (so auch nach einer Grafikdarstellung) den
    Programmablauf mit dem pause Befehl an.
   Als weiterer interaktiver Befehl steht Ihnen keyboard zur Verfügung. Wenn
    MATLAB auf diesen Befehl stößt, meldet sich MATLAB mit einem neuen Prompt, der
    mit dem Buchstaben K beginnt (K>>). An dieser Stelle können Sie einen beliebigen
    MATLAB Befehl eingeben (z.B. um gezielt den Wert von Variablen anzeigen zu
    lassen, oder um deren Wert zurückzusetzen). Der Befehl return (Buchstaben und
    Enter-Taste) setzt die Ausführung des Programms fort.
   Eine laufende m-Datei können Sie mit Strg + C abbrechen.



                                             Lehrstuhl für Bioprozesstechnik, Lars Voges




                                           24

				
DOCUMENT INFO
Shared By:
Categories:
Stats:
views:3379
posted:3/6/2010
language:German
pages:24