4.3 Pure Functions

Pure Functions sind Funktionen, die keinen eigenen Namen besitzen. Ihre Definition ist ihre einzige Bezeichnung. In der formalen Logik und in LISP bezeichnet man sie als $\lambda$-Ausdrücke oder anonyme Funktionen. Wenn eine Funktion nur an einer einzigen bestimmten Stelle gebraucht wird, erspart man sich dadurch eine separate Funktionsdefinition und das Suchen eines geeigneten Namens.

Beispiel

In[1]:= sq[x_]:=x^2
Out[1]=
als Pure Function: (#^2)&

In[2]:= sq /@ {a,b}
Out[2]= {a^2, b^2}

In[3]:= (#^2)& /@ {a,b}
Out[3]= {a^2, b^2}

Bei funktionalen Operatoren (Map, Apply, Fold, ...) muß immer eine Funktion angeben werden:

In[4]:= Nest[f, x, 3]
Out[4]= f[f[f[0]]]

Ist die Funktion in der Form f[x_]:=defintionbody definiert, so ensteht ein Defintions-Overhead, sowohl syntaktisch als auch semantisch.

Pointe: Die Definition einer Pure Function ist gleichzeitig ihr Name.

• Function[$x$, $body$] ... mit nur einem Argument
• $body$ & (# für das Argument)
• Function[{$x_1$, $x_2$, $x_3$,..., $x_n$ }, $body$ ]
• $body$ & (#1, #2, #n für das erste, zweite, nte Argument)

Anwendung:

• Function[$x$, $body$][$arg$]
• Function [{$x_1$, $x_2$, $x_3$,..., $x_n$ }, $body$ ] [$arg_1$,..., $arg_n$]
• $body$ & [$arg_1$,..., $arg_n$]

Evaluierung: An jeder Stelle in $body$, an der $x_i$ vorkommt, wird der Wert von $arg_i$ buchstäblich ersetzt (,,replaced``), es erfolgt keine vorherige Evaluierung von $body$ und $x_i$.

Function[$x$, $body$][$arg$] $\equiv$ $body$ /. $x$ -> $arg$ ($\lambda$-Conversion)
$body$ und $x$ werden in letzterem Fall nicht evaluiert, sondern bleiben bestehen, d.h. der eigentliche Mathematica-Ausdruck lautet:

(Hold[$body$] /. HoldPattern[$x$] -> $arg$) // ReleaseHold

Function[$x$, $body$] $\equiv$ Function [$y$, $body$] ($\alpha$-Conversion)
Function[$x$, $h$[$x$]] $\equiv$ $h$[$x$]] ($\eta$-Conversion)

Beispiel

In[5]:= Clear[x]
Out[5]=

In[6]:= Function[x, x/2][4]
Out[6]= 2

In[7]:= Function[x, x/2][4, 6]
Out[7]= 2

In[8]:= Function[x, x/2][x]
Out[8]= x/2

In[9]:= x=2; Function[x, x/2][x]
Out[9]= 1

In[10]:= #/2 & [4]
Out[10]= 2

In[11]:= #/2 & 6
Out[11]= 6 (#1/2 &)

Eine Funktion, die eine Funktion zurückliefert: In[12]:= pow[n_Integer] := Function[x, x^n]
Out[12]=

In[13]:= pow[2]
Out[13]= Function[x$, x$^2]

In[14]:= % [4]
Out[14]= 16

In[15]:= pow[3][3]
Out[15]= 27

Redundanz: In[16]:= f[#]& /@ {a, b, c}
Out[16]= {f[a], f[b], f[c]}
kürzer: f /@ {a, b, c}