Selbstdefinierte Funktionen

Copyright

Copyright 1994,  Claudia Funke und Markus Herold
TU-Berlin, FB 13, Fachgebiet Ökonometrie und Statistik
Dieses Notebook darf ausschließlich als Unterrichtsmaterial und für private Zwecke verwendet und nicht ohne Zustimmung der Autoren verändert werden.

Definition einer einfachen Funktion

Mathematica ermöglicht es, den bereits vorhandenen Funktionen 
eigene Funktionen hinzuzufügen. Ein einfaches Beispiel: Es soll eine Funktion geschrieben werden, die bei gegebenen Katheten die 
Hypothenuse eines Dreiecks berechnet. Die Funktion soll   hypo  
heißen. Um sicher zu sein, daß nicht schon eine Funktion mit gleichem 
Namen existiert, wird zuvor   Clear[hypo]  aufgerufen.

Clear[hypo]

hypo[x, y] := Sqrt[x^2 + y^2]

hypo[x, y]

hypo[a, b]

Man beachte, daß die Funktion nur für die Werte x und y das gewünschte Resultat liefert. Für andere Argumente wertet 
Mathematica die Funktion nicht aus.

Clear[hypo]

hypo[x_, y_] := Sqrt[x^2 + y^2]

Durch das Hinzufügen des Unterstrichs nach den beiden Variablen bei der Funktionsdefinition wird Mathematica dazu veranlaßt, den 
Argumenten der Funktion die Namen  (und nicht die Werte)  x und y   
zuordnen.

hypo[a, b]

hypo[3, 4]

Der allgemeine Aufbau einer Funktionsdefinition lautet somit

f[ Arg1_, Arg2_, ... ] := Funktionskörper

f  ist dabei der Name der Funktion. 

Der Funktionskörper kann auch aus mehreren Ausdrücken bestehen, 
wie folgendes Beispiel zeigt:

Clear[polarTransform]

polarTransform[r_, theta_] := (

   x = r Cos[theta];
   y = r Sin[theta];
   {x, y}
)

polarTransform[1, Pi/4]

Überprüfung des Typs eines Funktionsarguments

Die Notation   f[arg_type]   erlaubt es, den Typ eines Funktions-
arguments zu definieren. Die Funktion wird nur dann ausgeführt, wenn 
das Argument vom Typ arg ist, da Mathematica vor Ausführung prüft, 
ob   Head[arg] === type   ist. (Die Abfrage   ===   gibt nur ein TRUE 
zurück, wenn die rechte und linke Gleichungsseite identisch sind.)

Als Beispiel sei eine Funktion  pascal  definiert, die nur ausgewertet 
wird, wenn das Argument vom Typ Integer ist. Die Mathematica-interne Funktion  Binomial[n,i]  berechnet den Binomialkoeffizient n über i.

pascal[n_Integer] := Table[Binomial[n, i], {i, 0, n}]

pascal[5]

pascal[5.5]

Die Notation   f[arg_type]   kann jedoch nicht überprüfen, ob z.B. ein 
Argument ein Polynom oder positiv ist. Dies leistet aber die Notation 
f[arg_?type]. Die Funktion wird nur dann ausgeführt, wenn  test[x] 
den Wert  TRUE  zurückgibt.

Die Funktion  half[ ]  soll nur für gerade Integerwerte definiert sein.

Clear[half]

half[x_?EvenQ] := x/2

half[4]

half[5]

Bei der Abfrage des Typs können für verschiedene Argument-Typen 
verschiedene Regeln definiert werden. Die unten definierte  
signum-Funktion ist 1, wenn das Argument positiv und -1, 
wenn das Argument negativ ist.

Clear[signum]

signum[x_?Positive] := 1

signum[x_?Negative] := -1

signum[-8]

signum[7]

Die Reihenfolge der Auswertung von Regeln

Man kann in Mathematica für eine Funktion eine oder mehrere Regeln definieren. Dabei wertet Mathematica spezielle vor allgemeineren 
Regeln aus.

Clear[f]

f[x] := x^2

f[x_Integer] := x

f[2] := 16

Für die Fehlersuche in einer selbstdefinierten Funktion ist es oft 
hilfreich, sich mit dem ? - Operator die Reihenfolge der Auswertung anzusehen - die Funktion hier ist aber o.k.:

?f

f[2]

f[4]

Dokumentation von selbstdefinierten Funktionen

Wenn man den   ?-Operator   auf eine selbstdefinierte Funktion 
anwendet, gibt Mathematica die Definition der Funktion zurück.  
Erläuterungen zu dieser Funktion können mit      usage = "statements" 
angegeben werden.

function::usage = "Funktionsname[Arg1, Arg2, ...] gibt irgendetwas zurück"

?pascal

pascal::usage = "pascal[n] gibt die n-te Zeile des Pascalschen Dreiecks zurück."

?pascal

??pascal

Attribute von Funktionen

Funktionen können verschiedene Attribute zugewiesen werden. Ein 
mögliches Attribut ist  Listable  .  Eine Funktion, die das Attribut 
Listable besitzt, kann als Argument auch eine Liste verarbeiten. Beispielsweise wird  f[{a,b,c}]  umgeformt zu   {f[a], f[b], f[c]}.

Um Attribute von Funktionen zu verändern oder anzulisten, gibt es 
die Befehle:

Attributes[ f ]

= Anlisten der Attribute

Attributes[ f ] = {Attrib1, Attrib2, ... }

= Setzen von Attributen

Attributes[ f ] = { }

= Löschen aller Attribute

SetAttributes[ f, Attrib ]

= Setzen eines Attributes

ClearAttributes[ f, Attrib ]

= Löschen eines Attributes.