Next: Makros, Previous: Funktionsdefinitionen, Up: Funktionsdefinitionen [Contents][Index]

### 25.1 Funktionen

#### 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.

Next: Makros, Previous: Funktionsdefinitionen, Up: Funktionsdefinitionen [Contents][Index]