2.7 MATLAB-Skripts und MATLAB-Funktionen

MATLAB kennt zwei Typen von Programmeinheiten, Skripts und Funktionen, die im Detail im Abschnitt 7 besprochen werden.

MATLAB-Skripts sind Programme, die im MATLAB-Arbeitsbereich (Workspace) ablaufen und keine Übergabeparameter kennen. Ihnen sind alle definierten Variablen im Workspace (who) bekannt, zwei unterschiedliche Skripts können also wechselseitig Variablen benutzen oder überschreiben. Das kann einerseits praktisch sein, birgt aber andererseits auch große Gefahren unerwünschter Beeinflussung. Will man sicher sein, dass Skripts in einem ''reinen'' Workspace ablaufen, muss man den Befehl clear all verwenden.

MATLAB-Funktionen 7.1 hingegen werden in einem eigenen Arbeitsbereich abgearbeitet. Hier gibt es also keine unerwünschten Querverbindungen. Ihre Kommunikation mit Skripts (oder anderen Funktionen) erfolgt durch sogenannte Übergabeparameter,

  function [out1,out2,out3] = test(in1,in2,in3)

wobei die Position innerhalb der Klammern die Zuordnung bestimmt. Ein Aufruf der Funktion test in folgender Art,

  [a,b,c] = test(x,y,z)

führt innerhalb der Funktion dazu, dass in1 den Wert von x, in2 den Wert von y und in3 den Wert von z zugewiesen bekommt.

Nach Ablauf aller Programmschritte innerhalb der Funktion test, wobei die Werte für out1, out2 und out3 berechnet werden müssen, bekommt ausserhalb der Funktion die Variablen a den Wert von out1, b den Wert von out2 und c den Wert von out3.

Der lokale Arbeitsbereich einer Funktion ist bei jedem Aufruf leer. Nach dem Aufruf sind also nur die Input-Parameter bekannt. In Funktionen können natürlich genauso wie in Skripts alle MATLAB-Befehle und eigene Programme verwendet werden.

Zwei Regeln müssen bei Funktionen unbedingt eingehalten werden. Erstens, die Funktion muss in einem gleichnamigen MATLAB-File abgespeichert werden, d.h., die Funktion test muss im File test.m gespeichert werden und steht dann unter dem Namen test zur Verfügung. Dabei soll man keinesfalls existierende MATLAB Funktionsnamen (exist) verwenden, da sonst deren Zugänglichkeit blockiert ist. Zweitens, muss die Funktion eine sogenannte Deklarationszeile enthalten, die den Funktionsnamen und die Namen (und somit die Anzahl) der Übergabeparameter enthält. Diese Zeile muss mit function beginnen (siehe oben).

2.7.1 Einfache Beispiele

Zur Einführung werden hier zwei einfache Beispiele gezeigt, wobei man weiterführende Beispiele im Abschnitt 7.1.10 findet.

Eine einfache Funktion mit zwei Input- und zwei Output-Parametern könnte so aussehen:

  function [a,b] = test_fun1(x,y)
  % TEST_FUN1 - Test Function
  %   Syntax:   [a,b] = test_fun1(x,y)
  %   Input:    x,y - Array (same size)
  %   Output:   a,b - Array (same size as x and y)
  %             a = sqrt(x.^2 + y.^2);
  %             b = exp(-a.^2)
  a = x.^2 + y.^2;  % ist eigentlich a.^2
  b = exp(-a);
  a = sqrt(a);

Sie besteht aus einer Deklarationszeile, einer Reihe von Kommentarzeilen, die mit dem Befehl help angezeigt werden können, und drei Programmzeilen zur Berechnung der Output-Parameter. Beachten Sie bitte die Verwendung des Operators .^, da es sich bei den Übergabegrößen um Felder handeln kann (elementweise Berechnung).

Das entsprechende Skript zum Aufruf der Funktion könnte so aussehen:

  % Test-Skript for test_fun1.m
  % Winfried Kernbichler 08.03.2004
  z_max = 1; z_n   = 101;  % Prepare input
  z_1 = linspace(-z_max, z_max, z_n);
  [d, e] = test_fun1(z_1, -z_1);  % Call function
  figure(1); % Plot output
  plot(z_1,d,'r',z_1,e,'b:');
  xlabel('z_1'); ylabel('f(z_1,-z_1)');
  legend('Distance','Exponent');
  title('Result of test_fun1');

Im aufrufenden Skript werden typischerweise die Input-Parameter vorbereitet und die Ergebnisse dargestellt. Man trennt damit das ''Umfeld'' von der eigentlichen Berechnung.

Will man mit dem Benutzer des Programmes kommunizieren, kann man zur Eingabe von z_max und z_n auch den Befehl input eventuell in folgender Form verwenden:

  z_max = input('Bitte geben Sie z_max ein: ');

Manchmal möchte man eine Funktion auch für die Erledigung unterschiedlicher Aufgaben verwenden. Dazu bietet sich die Verwendung der Steuerstruktur switch an. Bei dieser Steuerstruktur wird eine Schaltvariable switch benutzt. Für verschiedene Werte dieser Schaltvariablen können dann Fälle (case) und entsprechende Aktionen programmiert werden.

  function [a,b] = test_fun2(typ,x,y)
  % TEST_FUN2 - Test Function
  %   Syntax:   [a,b] = test_fun2(typ,x,y)
  %   Input:    typ - String
  %             x,y - Array (same size)
  %   Output:   a,b - Array (same size as x and y)
  %             a = sqrt(x.^2 + y.^2);
  %             b = exp(-a.^2)  [typ: 'exp']
  %             b = sech(-a.^2) [typ: 'sech']
  a = x.^2 + y.^2;
  switch typ
   case 'exp'
    b = exp(-a);
   case 'sech'
    b = sech(-a);
   otherwise
    error('Case not defined!')
  end
  a = sqrt(a);

Je nach Wert der der Variablen typ kann die Funktion nun zwei verschiedene Aufgaben erledigen. Eine genaue Beschreibung von Steuerstrukturen finden Sie im Abschnitt 6, Details zum Befehl switch finden Sie im Abschnitt 6.2.2.

Der Aufruf schaut nun ein wenig anders aus (typ):

  % Test-Skript for test_fun2.m
  % Winfried Kernbichler 08.03.2004
  z_max = 1; z_n   = 101;  % Prepare input
  typ   = 'exp';  % oder 'sech'
  z_1 = linspace(-z_max, z_max, z_n);
  [d, e] = test_fun2(typ,z_1, -z_1);  % Call function

  figure(1); % Plot output
  plot(z_1,d,'r',z_1,e,'b:');
  xlabel('z_1'); ylabel('f(z_1,-z_1)');
  legend('Distance',typ);
  title('Result of test_fun2');

Anmerkung: Will man mit der Funktion input den Wert der Variablen typ abfragen, empfiehlt es sich, sie in dieser Form

  typ = input('Bitte geben Sie den Typ ein: ','s')

zu verwenden. Damit kann man einfach exp anstelle von 'exp' eingeben und MATLAB erkennt trotzdem, dass es sich um einen String handelt.

Anmerkung: Will man die Eingabe des Typs noch weiter erleichtern (Groß- oder Kleinschreibung, nur Anfangsbuchstabe(n), kann man die switch-Konstruktion verbessern. Man kann z.B. alle Zeichenketten mit dem Befehl lower in Kleinbuchstaben verwandeln. Details zur Verwendung von Zeichenketten findet man im Abschnitt 9. Die Konstruktion

  switch lower(typ)
   case 'exp'
    ...
  end

würde nun auch mit Werten wie Exp oder EXP funktionieren. Will man nur den Anfangsbuchstaben der Zeichenkette auswerten, kann man mit Hilfe der Indizierung auf den ersten Buchstaben zugreifen. Dies könnte so aussehen:

  switch lower(typ(1))
   case 'e'
    ...
  end