25.1.1 Gewöhnliche Funktionen

Eine Maxima-Funktion wird mit dem Operator := oder der Funktion define definiert. Im folgenden wird die Funktion f mit dem Operator := definiert:

f(x) := sin(x)

Funktionen, die mit der Funktion lambda definiert werden, sind anonyme Funktionen, die keinen Namen haben. Diese werden auch lambda-Ausdrücke genannt:

lambda ([i, j], ...)

Anonyme Funktionen können überall dort verwendet werden, wo eine Funktion als Argument erwartet wird. Das folgende Beispiel gibt eine Liste zurück, bei der jedes Element der Liste L mit 1 addiert wird:

map (lambda ([i], i+1), L)

Ist das letzte oder einzige Argument einer Funktion eine Liste mit einem Element, kann eine variable Anzahl an Argumenten an die Funktion übergeben werden:

(%i1) f ([u]) := u;
(%o1)                      f([u]) := u
(%i2) f (1, 2, 3, 4);
(%o2)                     [1, 2, 3, 4]
(%i3) f (a, b, [u]) := [a, b, u];
(%o3)               f(a, b, [u]) := [a, b, u]
(%i4) f (1, 2, 3, 4, 5, 6);
(%o4)                 [1, 2, [3, 4, 5, 6]]

Die rechte Seite einer Funktionsdefinition ist ein Ausdruck. Mehrere Ausdrücke werden durch Kommata getrennt und mit Klammern umgeben. Das Ergebnis der Funktion ist der Wert des letzten Ausdrucks exprn:

f(x) := (expr1, expr2, ...., exprn);

Ein Rücksprung mit der Anweisung return aus einer Funktion ist möglich, wenn die Definition der Funktion in einen Block eingefügt wird. Ein Block wird mit der block-Anweisung definiert. Das folgende Beispiel hat entweder den Wert a oder den Wert des Ausdrucks exprn als Ergebnis:

block ([], expr1, ..., if (a > 10) then return(a), ..., exprn)

Das erste paar Klammern [] in einem Block enthält die Definition von lokalen Variablen wie zum Beispiel [a: 3, b, c: []]. Die Variablen sind außerhalb des Blocks nicht sichtbar. Die Werte von globalen Variablen werden von den lokalen Werten überschrieben. Außerhalb des Blocks haben die Variablen, wenn vorhanden, wieder ihre alten Werte. Die Zuweisung der Werte an die lokalen Variablen wird parallel ausgeführt.

Im folgenden Beispiel wird der Wert der globalen Variablen a der lokalen Variablen a zugewiesen. Änderungen von a im Block wirken sich nicht auf den globalen Wert der Variablen aus.

block ([a: a], expr1, ... a: a+3, ..., exprn)

Die Anweisung block ([x], ...) bewirkt, dass x als lokale Variable ohne einen Wert verwendet werden kann.

Die Argumente einer Funktion werden in gleicher Weise wie lokal definierte Variable behandelt. Die folgende Definition

f(x) := (expr1, ..., exprn);

mit

f(1);

hat denselben Effekt wie der folgende Block:

block ([x: 1], expr1, ..., exprn)

Soll die rechte Seite einer Funktionsdefinition ausgewertet werden, kann die Funktionen define für die Definition der Funktion verwendet werden. Mit der Funktion buildq kann die Definition einer Funktion konstruiert werden, wobei die Auswertung gezielt kontrolliert werden kann.

25.1.2 Array-Funktionen

Eine Array-Funktion speichert bei dem ersten Aufruf den Funktionswert zu dem Argument. Wird die Array-Funktion mit demselben Argument aufgerufen, wird der gespeicherte Wert zurückgeben, ohne diesen neu zu berechnen. Dies wird auch Memoisation genannt.

Beispiel:

Das folgende Beispiel zeigt die Definition einer Array-Funktion f, die die Fakultät einer Zahl faktorisiert. Im ersten Aufruf der Funktion mit dem Argument 25000 wird eine Rechenzeit von etwa 24 Sekunden benötigt. Der zweite Aufruf mit demselben Argument gibt sofort den abgespeicherten Wert zurück.

(%i1) f[x]:=factor(x!);
(%o1)                   f  := factor(x!)
                         x
(%i2) showtime:true;
Evaluation took 0.0000 seconds (0.0000 elapsed) using 0 bytes.
(%o2)                         true
(%i3) f[25000]$
Evaluation took 23.9250 seconds (26.0790 elapsed) using 3829.778 MB.
(%i4) f[25000]$
Evaluation took 0.0000 seconds (0.0000 elapsed) using 0 bytes. 

Die Namen der Array-Funktionen werden in die Informationsliste arrays und nicht in die Liste functions eingetragen. arrayinfo gibt eine Liste der Argumente zurück, für die Werte gespeichert sind und listarray gibt die Werte zurück. Die Funktionen dispfun und fundef geben die Definition der Array-Funktion zurück.

Beispiele:

Mit dem obigen Beispiel werden die folgenden Ergebnisse ausgegeben.

(%i5) arrays;
(%o5)                          [f]
(%i6) arrayinfo(f);
(%o6)                 [hashed, 1, [25000]]
(%i7) dispfun(f);
(%t7)                   f  := factor(x!)
                         x
(%o7)                         [%t7]

arraymake erzeugt den Aufruf einer Array-Funktion. Dies ist analog zu der Funktion funmake für gewöhnliche Funktionen. arrayapply wendet eine Array-Funktion auf die Argumente an. Dies entspricht der Funktion apply für gewöhnliche Funktionen. Die Funktion map hat keine Entsprechung für Array-Funktionen. Vergleichbare Konstruktionen sind map(lambda([x], a[x]), L) oder makelist(a[x], x, L), wobei L eine Liste ist.

remarray entfernt die Definition einer Array-Funktion einschließlich der gespeicherten Werte. Dies entspricht remfunction für gewöhnliche Funktionen.

kill(a[x]) entfernt den für das Argument x gespeicherten Wert einer Array-Funktion a. Beim nächsten Aufruf von a mit dem Argument x wird der Funktionswert neu berechnet. Es gibt keine Möglichkeit, alle gespeicherten Werte zu löschen, ohne dass die Definition der Funktion entfernt wird. Die Kommandos kill(a) und remarray(a) löschen alle Werte einschließlich der Definition der Funktion.