Funktionen in Matlab

Funktionen in Matlab
Zusammenfassung von Befehlssequenzen als
aufrufbare/wiederverwendbare Funktionen in einem
Programmblock mit festgelegter Schnittstelle (Signatur)
Derartige prozedurale Programmierung erlaubt
Dekomposition komplexer Probleme
Wichtige Unterscheidung
In MATLAB vordefinierte Funktionen, die benutzt werden
können um die Programmierung zu erleichtern
Nutzerdefinierte Funktionen, aus denen sich komplexe
anwendungsspezifische Programme zusammensetzen
lassen
Nutzerdefinierte Funktionen können in .m-Datei
gespeichert werden
Vorteile von Funktionen
Handhabbarkeit der Komplexität: komplexe Probleme
können in überschaubare Teilprobleme zerlegt werden
Wiederverwendbarkeit: derselbe Code kann einmalig
definiert und dann an verschiedenen Stellen benutzt
werden
Gemeinsame Bearbeitung: Zerlegung in separate
Dateien erlaubt es mehreren Programmierern, Ihre
Zuständigkeiten aufzuteilen und nur jeweils an ihren
eigenen Dateien zu arbeiten
Vordefinierte Funktionen zur Ein- und Ausgabe
Zahlreiche vordefinierte Funktionen für
Wichtige Funktionen zur textuellen Ein- und Ausgabe
disp(): einfache Ausgabe einzelner Werte oder Variablen
fprintf(): formatierte Ausgabe zusammengesetzter
Zeichneketten mit Steuerung der Formatierung
input(): einfache Eingabe von Werten
Ausgabe mit disp()
Ausgabe von Werten
» disp(3)
3
» disp(’Hallo!’)
Hallo!
Ausgabe von Variablen
» x = [1,2,3];
» disp(x)
1 2 3
Fügt am Zeilenende automatisch einen Zeilenumbruch ein
Formatierte Ausgabe mit fprintf()
File Print Formatted: Formatiertes Schreiben von Texten
auf Datei oder Bildschirm
fprintf(dateiID,formatString,<werte oder variablen>)
Hier erstmal: Schreiben auf Bildschirm (ohne Angabe von
Datei)
fprintf(formatString,<werte oder variablen>)
Erlaubt einfaches Mischen von Text und Werten durch
Formatierungsplatzhalter
Beispiel:
» str = ’Pfannkuchen’;
» fprintf(’%d %s kosten %4.2f Euro. \n’, 3, str, 1.8);
3 Pfannkuchen kosten 1.80 Euro.
fprintf() definierte Formatierungen
%d oder %i : Ganze Dezimalzahl (Integer)
%s : Zeichenkette (String)
%f : Fließkommazahl (Floating Point Number)
%e : Fließkommazahl in Exponentialschreibweise
%g : Optimierte Exponentialschreibweise
Außerdem konkrete Stellenanzahl möglich, z.B. %4.2f
bedeutet 4 Stellen insgesamt inklusive Komma, 2 Stellen
nach dem Komma
Steuerzeichen wie \n (Zeilenumbruch) oder \t (Tabbing)
erlaubern Textformatierung
Weiterhin wichtig: %% für Prozentzeichen, ’ ’ für
Anführungszeichen und \ \ für ein Backslash
Eingabe mit input()
Eingabe mit einer einfachen Eingabeaufforderung (Prompt)
<variable> = input(<prompt>);
Eingabe für Zeichenketten
<variable> = input(<prompt>,’s’);
Beispiele
x = input(’Bitte x eingeben: ’);
str = input(’Bitte Name eingeben: ’,’s’);
Beispiel: Ein- und Ausgabe
function messwerte()
anzahl = 5;
a = NaN(1,anzahl);
for i = 1:length(a)
fprintf(’a[%i]’,i);
a(i) = input(’=’);
end
fprintf(’Die Messwerte sind: ’);
disp(a);
fprintf(’Der Mittelwert ist: ’);
disp(mean(a));
end
Nutzerdefinierte Funktionen
Nutzerdefinierte Funktionen bestehen aus Sequenzen von
Befehlen (entsprechend imperativem
Programmierparadigma)
Werden durch Verkettung mit Semikolon ; gebildet
Dabei können einzelne Befehle
Definition/Deklaration von Variablen
Ausdrücke (haben immer ein Ergebnis und einen
Ergebnistyp)
Literale Werte
Variablen
Funktionsaufrufe
Komplexe Ausdrücke: Verknüpfung von Teilausdrücken
durch Operatoren
Steueranweisungen (Schleifen, Bedingungen,
Fehlerbehandlung, etc.)
sein
Skripte als Sequenzen in Dateien
Erlauben einfache Befehlssequenzen in .m-Dateien
Beispiel feldinit.m zur Initialisierung von verwendeten
Variablen
feld1
feld2
feld3
feld4
feld5
=
=
=
=
=
[1 2 3];
[1 ; 2 ; 3];
NaN(1,10);
[1:10];
zeros(1,10);
Können über Name der Datei aufgerufen werden
Vergleichbar mit einfachen Funktionen ohne Parameter
und Rückgabewerte
Funktionen: Definition
function <rückgabe> = <funktionsname>(<parameter>)
<befehlssequenz>;
end
Funktionsname: eindeutiger Name zum Aufruf der
Funktion
Rückgabewert: Variable(n), deren Wert von der Funktion
berechnet werden
Parameter: Variablen, die für die Berechnung übergeben
werden
Endemarkierung end (dient allgemein der Kennzeichnung
des Endes eines Programmblocks) ist bei Funktionen nicht
immer notwendig, aber empfohlen
Funktionen: Rückgabewerte
Einzelne Variable
function ergebnis = meineFunktion(x,y,z) ...
Mehrere Variablen als Rückgabe in eckigen Klammern
function [erg1,erg2,erg3] = meineFunktion(x,y,z) ...
Rückgabe ist optional
function meineFunktion(x,y,z) ...
Funktionen: Parameterübergabe
Kommaseparierte Liste von Variablennamen
function ergebnis = meineFunktion(x,y,z) ...
Parameterliste ist optional (Klammern können bei
fehlenden Parametern weggelassen werden)
Matlab verwendet zur Parameterübergabe ausschließlich
Pass by Value: Werte der aufrufenden Variablen werden
in lokale Variablen kopiert
Beispiel: Mittelwert (als zwei Dateien)
Datei mittelwert.m
function m = mittelwert(a,b)
m = (a+b)/2;
end
Datei mittelwertmain.m
x = input(’x = ’);
y = input(’y = ’);
z = mittelwert(x,y);
fprintf(’Mittelwert: %f \n’,z);
Funktionen und Dateien
Funktionen sollten Funktionsname als Dateiname haben
In einer Datei können auch mehrere Funktionen definiert
werden
Nur die erste Funktion (Hauptfunktion) im Quelltext kann
von von außen aufgerufen werden (im Beispiel
geradeoderungerade())
Folgende Funktionen werden als lokale Funktionen
bezeichnet, die direkt oder indirekt von der Hauptfunktion
aufgerufen werden können
Funktionen können (im Gegensatz zu vorgehenden
Beispielen, z.B. mittelwert()) auch ohne
Rückgabewert definiert werden
Beispiel: Funktionen in einer Datei
function geradeoderungerade()
x = input(’x = ’);
gerade(x);
end
function gerade(x)
if (mod (x,2) == 0)
disp(’Gerade!’);
else
ungerade(x);
end
end
function ungerade(x)
if ( mod(x,2) != 0)
disp(’Ungerade!’);
else
gerade(x);
end
end
Funktionen: Rekursion
In der Programmierung: Funktionen können direkt oder
indirekt (über eine weitere Funktion) sich selbst aufrufen
Zum Beispiel
int fakultaet(int i) {
if (i<=1) return 1;
else return i*fakultaet(i-1);
}
berechnet
n! = 1 ∗ 2 ∗ 3 ∗ 4 ∗ · · · ∗ n =
n
Y
i=1
i
Funktionen: Rekursion
Anwendbar für viele Aufgaben: Berechnungsmöglichkeiten
äquivalent zu Schleifen
Rekursion kann Schleifen immer ersetzen bzw. von diesen
ersetzt werden
Vorteile:
Oft einfache, elegante Lösungen möglich
Praktisch zum Beispiel bei komplexeren Datenstrukturen
(z.B. wenn diese rekursiv definiert sind: Hierarchien,
Bäume), Optimierung, etc.
Nachteile:
Funktionsaufrufe verursachen erhöhten Aufwand bei der
Programmausführung → Performance
Führt mitunter zu komplexeren Programmstrukturen, die
schwerer verständlich bzw. deren Korrektheit schwerer
verifizierbar ist
Rekursion: Beispiel Fakultätsberechnung
Mathematische Funktion für natürlich Zahlen n
n! = 1 ∗ 2 ∗ 3 ∗ 4 ∗ · · · ∗ n =
n
Y
i
i=1
Kann so als Schleife (Zählschleife mit Produktbildung)
umgesetzt werden
Aber auch rekursive Definition möglich:
(
1
n=0
n! =
n ∗ (n − 1)! n > 0
Umsetzbar als rekursive Funktion
Rekursion: Beispiel - Ablauf
Ergebnis:
4*6=24
Aufruf
fakultaet(4)
Aufruf
Ergebnis:
3*2=6
fakultaet(3)
Aufruf
Ergebnis:
2*1=2
fakultaet(2)
Aufruf
Ergebnis: 1
fakultaet(1)
Beispiel: Rekursion
function f=fakultaet(i)
if (i <= 1)
f=1;
else
f=i*fakultaet(i-1);
end
end
Kommentare
Natürlichsprachliche Beschreibung/Erklärung des
Quelltextes oft hilfreich und erforderlich
Werden vom Compiler bei der Übersetzung vollständig
ignoriert
Einzeilige Kommentare
x=x+1; % Kommentar bis zum Zeilenende
Mehrzeilige Kommentare
%{
x = x+1;
y = x+2;
z = mittelwert(x,y)
%}
Zusammenfassung: Funktionen
Funktionen als wiederverwendbare, zusammenhängende
Folge von Anweisungen zur Strukturierung des Quelltextes
Definition einer Funktion mit Rückgabewert, Name,
Parameter sowie eigentlicher Implementierung als
Programmblock
Rekursion als spezielles Programmierparadigma für
Funktionen erlaubt direkten oder indirekten Aufruf der
Methode durch sich selbst