3.3 Evaluation

1. Der Benutzer gibt eine expression ein.
2. Das Front End übergibt die expression an den Kernel.
3. Der Kernel evaluiert die expression und
4. liefert eine expression als Ergebnis zurück.
5. Das Front End stellt das Ergebnis in geeigneter Form dar.

Eigenschaften der ,,Evaluation Seqence``

Die Evaluation geschieht durch die Anwendung von Definitionen

• explicit definitions
  h[x_]:=x^3; a=7.4; f[1]:=4
• built-in definitions
  5+2 $\rightarrow$ Plus[5, 2] $\rightarrow$ 7; Print["x=",x]

Mathematica ist ein ,,infinite evaluation system``
Das bedeutet, daß es

• alle Definitionen verwendet und zwar
• so lange, bis sich das Ergebnis nicht mehr ändert

Beispiel

In[1]:= x1=x2+7; x2=7
Out[1]= 7

In[2]:= x1
Out[2]= 14
Obwohl x2 erst nach x1 definiert wurde, erhält man das korrekte Ergebnis.

Beispiel

In[3]:= t:=0
Out[3]=

In[4]:= x:=0 /; (t = t+1 ; t > 3)
Out[4]=

In[5]:= x
Out[5]= x
t=1

In[6]:= x
Out[6]= x
t=2

In[7]:= x
Out[7]= x
t=3

In[8]:= x
Out[8]= 0
t=4: Mathematica ist doch kein ,,infinite evaluation system``.

Obwohl (oberflächlich betrachtet) keine Regel geändert wurde, erhält man plötzlich ein anderes Ergebnis. Zugegeben, t wird hochgezählt und ändert damit den Inhalt der Datenbank von Mathematica, an der Definition von x ändert sich aber nichts.

Standard Evaluation Sequence

Wie untersucht Mathematica eine Eingabe, eine expression In[9]:= $h$ [$e_1$, $e_2$,..., $e_n$]
Out[9]=

die dem Kernel vom Front End übergeben wird?

1. Handelt es sich bei der expression um eine raw expression? Eine raw expression ist eine durch Anführungszeichen ("...") begrenzte Zeichenkette oder eine Zahl (Integer oder Real). Ist dies der Fall, so wird die evaluation sequence abgebrochen, da nichts weiter zu tun ist, und die expression unverändert zurückgegeben.

2. Eine raw expression ist auch ein Symbol ohne weitere Regeln. (In Mathematica-Sprech OwnValues genannt.) Folglich gibt es nichts in die Datenbank einzutragen und die expression wird wieder unverändert zurückgegeben.

3. Evaluiere die Regeln des Symbols (OwnValues)
   z.B.: a /; a:=b

4. Hat sich etwas seit der letzten Evaluierung geändert? Falls nicht, wird abgebrochen und die expression zurückgegeben.

5. Evaluiere den Kopf $h$ der expression. Auch der Kopf selbst kann eine expression sein: a[1][A, {1, 2}]

6. Evaluiere jedes Element $e_i$ der expression unter Beachtung der Attribute HoldFirst, HoldRest und HoldAll.

7. Transformiere die expression entsprechen den Attributen von $h$.
   • Flat ($\hat =$ assoziativ): $h$[ $h$[x, y], $h$[z] ] $\to$ $h$[x, y, z]
   • Listable: $h$[{x, y}] $\to$ {$h$[x], $h$[y]}
   • Orderless ($\hat =$ kommutativ): $h$[z, a, y] $\to$ $h$[a, y, z]
   Attribute können mit SetAttributes[$h$, Attribut] gesetzt und mit ClearAttributes[$h$, Attribut] gelöscht werden.

8. Wende UpValues (betreffend die Argumente $e_i$) an, zuerst user-defined, dann built-in. (siehe Kap.6.3 Operator overloading)
   Bsp.: f/: g[f[x_]]^:=gf[x]
   (Diese Definition wird bei f gespeichert, nicht bei g!)

9. Wende DownValues ($h$[.]) und SubValues ($h$[.][.]...) bezüglich $h$ an, zuerst user-defined, dann built-in. DownValues entsprechen den üblichen Transformation Rules.
   Bsp.: f/: f[{a_, b_}]:=a[f[b]]

Beispiel

In[10]:= Clear[f]; Clear[g]
Out[10]=

In[11]:= f[a_]:=a^2
Out[11]=

In[12]:= g:=f
Out[12]=

In[13]:= g[5]
Out[13]= 25
In Schritt 3 wird g durch f ersetzt, die Evaluation Sequence von neuem begonnen und in Schritt 6 das Ergebnis berechnet.

Non-Standard Evaluation Sequence

Assignments

Immediate Assignment: $lhs$ = $rhs$
interne Speicherung: Set[$symbol$, $rhs$]

$lhs$ kann eine beliebige expression oder ein Muster sein. Verschiedene Zuweisungen, die einem bestimmten Symbol zugeordnet sind, werden in der Reihenfolge der Eingabe gespeichert, außer sie ist spezifischer als die vorhergehenden. In diesem Fall wird das Muster vorangestellt. Neue Zuweisungen mit identischer $lhs$ überschreiben alte Einträge.

Ist die Eingabe von der Form In[14]:= $f$[$arg_1$,..., $arg_n$]=$rhs$
Out[14]= $rhs$

so werden die Argumente $arg_1$ bis $arg_n$ ausgewertet. $f$ und $f$[$arg'_1$,..., $arg'_n$] bleiben unverändert im Gegensatz zu $rhs$, das sofort ausgewertet wird.

Delayed Assignment: $lhs$ := $rhs$
interne Speicherung: SetDelayed[$lhs$, $rhs$] mit dem Attribut HoldAll.

Der Unterschied zum Immediate Assignment besteht in der Behandlung von $rhs$. Diese wird beim Delayed Assignment nicht ausgewertet. Sobald im weiteren $lhs$ auftritt, wird es durch $rhs$ ersetzt. Erst dann wird $rhs$ ausgewertet.

In[15]:= $f$[$arg_1$,..., $arg_n$]:=$rhs$
Out[15]=

Analoges gilt in diesem Fall: Alle Argumente $arg_i$ werden evaluiert. $f$ und $f$ [$arg'_1$,..., $arg'_n$] werden nicht weiter ausgewertet. Außerdem bleibt $rhs$ unverändert stehen.

Immediate Assignment		Delayed Assignment
	In[16]:= a:=5
In[17]:= f[x_] = a x		In[17]:= f[x_] := ax
Out[17]= 5x		keine Ausgabe
f/: f[x_] = 5*x	Musterdatenbank	f/: f[x_] := a*x
	In[18]:= a:=9; f[4]
5 $\cdot$ 4 $\to$		a $\cdot$ 4 $\to$ 9 $\cdot$ 4 $\to$
Out[18]= 20		Out[18]= 36