| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 25.1 Funktionen | ||
| 25.2 Makros | ||
| 25.3 Funktionen und Variablen für Funktionsdefinitionen |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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.
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Die Variablen der Liste L werden in den Ausdruck expr substituiert. Die Substitution wird parallel ausgeführt. Das Ergebnis der Substitution wird vereinfacht, aber nicht ausgewertet.
Die Elemente der Liste L sind Symbole oder Zuweisungen der Form
symbol: value. Die Zuweisungen werden parallel ausgewertet.
Der Wert einer Variablen auf der rechten Seite einer Zuweisung ist der globale
Wert in dem Kontext in dem buildq aufgerufen wird und nicht der lokale
Wert einer vorhergehenden Zuweisung. Erhält eine Variable keinen Wert, dann
behält die Variable den globalen Wert.
Dann werden die in der Liste L enthaltenen Variablen parallel in den Ausdruck expr substituiert.
Enthält expr Ausdrücke der Form splice(x), muss die
Variable x eine Liste sein. Die Liste wird in den Ausdruck eingefügt.
Siehe auch splice.
Variablen in in dem Ausdruck expr, die nicht in L enthalten sind, werden nicht durch einen Wert ersetzt, auch wenn es eine globale Variable mit demselben Namen gibt, da der Ausdruck nicht ausgewertet wird.
Beispiele:
Der Variablen a wird der Wert zugewiesen. Die Variable b erhält
den globalen Wert. Die Variable c hat keinen Wert. Das Ergebnis ist
ein nicht ausgewerteter Ausdruck. Die Auswertung wird mit dem
Quote-Quote-Operator
'' erzwungen.
(%i1) (a: 17, b: 29, c: 1729)$ (%i2) buildq ([a: x, b], a + b + c); (%o2) x + c + 29 (%i3) ''%; (%o3) x + 1758
e ist eine Liste, die einmal als Argument der Funktion foo
vorliegt und zum anderen in die Argumentliste der Funktion bar
eingefügt wird.
(%i1) buildq ([e: [a, b, c]], foo (x, e, y)); (%o1) foo(x, [a, b, c], y) (%i2) buildq ([e: [a, b, c]], bar (x, splice (e), y)); (%o2) bar(x, a, b, c, y)
Das Ergebnis wird nach der Substitution vereinfacht, ansonsten hätten die beiden folgenden Beispiele dasselbe Ergebnis.
(%i1) buildq ([e: [a, b, c]], splice (e) + splice (e)); (%o1) 2 c + 2 b + 2 a (%i2) buildq ([e: [a, b, c]], 2 * splice (e)); (%o2) 2 a b c
Die Variablen der Liste L erhalten ihren Wert parallel, ansonsten wäre
das erste Ergebnis foo(b,b). Substitutionen werden parallel
ausgeführt. Im Gegensatz dazu werden die Substitutionen mit der Funktion
subst
nacheinander ausgeführt.
(%i1) buildq ([a: b, b: a], foo (a, b));
(%o1) foo(b, a)
(%i2) buildq ([u: v, v: w, w: x, x: y, y: z, z: u],
bar (u, v, w, x, y, z));
(%o2) bar(v, w, x, y, z, u)
(%i3) subst ([u=v, v=w, w=x, x=y, y=z, z=u],
bar (u, v, w, x, y, z));
(%o3) bar(u, u, u, u, u, u)
Konstruktion einer Liste mit Gleichungen mit Variablen oder Ausdrücken auf
der linken Seite und deren Werten auf der rechten Seite. Die Funktion
macroexpand
expandiert das Makro show_values.
(%i1) show_values ([L]) ::= buildq ([L], map ("=", 'L, L))$
(%i2) (a: 17, b: 29, c: 1729)$
(%i3) show_values (a, b, c - a - b);
(%o3) [a = 17, b = 29, c - b - a = 1683]
(%i4) macroexpand (show_values (a, b, c - a - b));
(%o4) map(=, '([a, b, c - b - a]), [a, b, c - b - a])
Konstruktion einer Funktion.
(%i1) curry (f, [a]) :=
buildq ([f, a], lambda ([[x]], apply (f, append (a, x))))$
(%i2) by3 : curry ("*", 3);
(%o2) lambda([[x]], apply(*, append([3], x)))
(%i3) by3 (a + b);
(%o3) 3 (b + a)
Ist das Argument expr ein Makro, wird das Makro expandiert, ohne dass es ausgewertet wird. Ansonsten wird expr zurückgegeben.
Ist die Expansion des Makros selbst ein Makro, wird dieses Makro wiederholt expandiert.
macroexpand wertet das Argument expr nicht aus. Hat die Expansion
des Makros Seiteneffekte, dann werden diese ausgeführt.
Siehe auch ::=
und macroexpand1.
Beispiele:
(%i1) g (x) ::= x / 99;
x
(%o1) g(x) ::= --
99
(%i2) h (x) ::= buildq ([x], g (x - a));
(%o2) h(x) ::= buildq([x], g(x - a))
(%i3) a: 1234;
(%o3) 1234
(%i4) macroexpand (h (y));
y - a
(%o4) -----
99
(%i5) h (y);
y - 1234
(%o5) --------
99
Gibt die Makro-Expansion von expr zurück, ohne das Ergebnis auszuwerten.
Ist expr keine Makro-Funktion gibt macroexpand1 das Argument
expr zurück.
macroexpand1 wertet das Argument nicht aus. Hat die Expansion des Makros
Seiteneffekte, dann werden diese ausgeführt.
Enthält die Expansion expr wiederum Makros, werden diese im Unterschied
zur Funktion macroexpand nicht expandiert.
Siehe auch ::=
und macroexpand.
Beispiele:
(%i1) g (x) ::= x / 99;
x
(%o1) g(x) ::= --
99
(%i2) h (x) ::= buildq ([x], g (x - a))$
(%i3) a: 1234;
(%o3) 1234
(%i4) macroexpand1 (h (y));
(%o4) g(y - a)
(%i5) h (y);
y - 1234
(%o5) --------
99
Standardwert: false
macroexpansion kontrolliert die Expansion von Makros.
falseDie Expansion des Makros wird nicht für die aufrufende Funktion ersetzt.
expandWird die Makro-Funktion das erste Mal ausgewertet, wird die Expansion des Makros gespeichert. Weitere Aufrufe werten das Makro nicht erneut aus. Seiteneffekte, wie Zuweisungen an globale Variablen, werden nur bei der ersten Auswertung wirksam. Die Expansion des Makros beeinflusst nicht andere Ausdrücke, die das Makro ebenfalls aufrufen.
displaceWird die Makro-Funktion das erste mal ausgewertet, wird die Expansion des Makros in den aufrufenden Ausdruck eingesetzt. Weitere Aufrufe werten das Makro nicht erneut aus. Seiteneffekte, wie Zuweisungen an globale Variablen, werden nur bei der ersten Auswertung wirksam. Die Expansion des Makros beeinflusst nicht andere Ausdrücke, die das Makro ebenfalls aufrufen.
Beispiele:
Hat macroexpansion den Wert false, wird eine Makro-Funktion
jedes mal aufgerufen, wenn der aufrufende Ausdruck ausgewertet wird. Der
aufrufende Ausdruck wird nicht modifiziert.
(%i1) f (x) := h (x) / g (x);
h(x)
(%o1) f(x) := ----
g(x)
(%i2) g (x) ::= block (print ("x + 99 is equal to", x),
return (x + 99));
(%o2) g(x) ::= block(print("x + 99 is equal to", x),
return(x + 99))
(%i3) h (x) ::= block (print ("x - 99 is equal to", x),
return (x - 99));
(%o3) h(x) ::= block(print("x - 99 is equal to", x),
return(x - 99))
(%i4) macroexpansion: false;
(%o4) false
(%i5) f (a * b);
x - 99 is equal to x
x + 99 is equal to x
a b - 99
(%o5) --------
a b + 99
(%i6) dispfun (f);
h(x)
(%t6) f(x) := ----
g(x)
(%o6) done
(%i7) f (a * b);
x - 99 is equal to x
x + 99 is equal to x
a b - 99
(%o7) --------
a b + 99
Hat macroexpansion den Wert expand, wird eine Makro-Funktion nur
einmal aufgerufen. Der aufrufende Ausdruck wird nicht modifiziert.
(%i1) f (x) := h (x) / g (x);
h(x)
(%o1) f(x) := ----
g(x)
(%i2) g (x) ::= block (print ("x + 99 is equal to", x),
return (x + 99));
(%o2) g(x) ::= block(print("x + 99 is equal to", x),
return(x + 99))
(%i3) h (x) ::= block (print ("x - 99 is equal to", x),
return (x - 99));
(%o3) h(x) ::= block(print("x - 99 is equal to", x),
return(x - 99))
(%i4) macroexpansion: expand;
(%o4) expand
(%i5) f (a * b);
x - 99 is equal to x
x + 99 is equal to x
a b - 99
(%o5) --------
a b + 99
(%i6) dispfun (f);
h(x)
(%t6) f(x) := ----
g(x)
(%o6) done
(%i7) f (a * b);
a b - 99
(%o7) --------
a b + 99
Hat macroexpansion den Wert displace, wird eine Makro-Funktion
nur einmal aufgerufen. Der aufrufende Ausdruck wird modifiziert.
(%i1) f (x) := h (x) / g (x);
h(x)
(%o1) f(x) := ----
g(x)
(%i2) g (x) ::= block (print ("x + 99 is equal to", x),
return (x + 99));
(%o2) g(x) ::= block(print("x + 99 is equal to", x),
return(x + 99))
(%i3) h (x) ::= block (print ("x - 99 is equal to", x),
return (x - 99));
(%o3) h(x) ::= block(print("x - 99 is equal to", x),
return(x - 99))
(%i4) macroexpansion: displace;
(%o4) displace
(%i5) f (a * b);
x - 99 is equal to x
x + 99 is equal to x
a b - 99
(%o5) --------
a b + 99
(%i6) dispfun (f);
x - 99
(%t6) f(x) := ------
x + 99
(%o6) done
(%i7) f (a * b);
a b - 99
(%o7) --------
a b + 99
Standardwert: []
Die Systemvariable macros ist eine Informationsliste, die die vom Nutzer
mit dem Operator ::=
definierten Makros enthält. Wird das Makro mit
einer der Funktionen kill,
remove
oder remfunction
gelöscht, wird der Eintrag aus der Informationsliste entfernt. Siehe auch die
Systemvariable infolists.
Die Funktion splice kann nur im Zusammenhang mit der Funktion
buildq
verwendet werden. Das Argument a bezeichnet eine Liste, die
an Stelle von splice(a) in einen Ausdruck eingefügt wird. a kann
nicht selbst eine Liste oder ein Ausdruck sein, der zu einer Liste auswertet.
Beispiele:
(%i1) buildq ([x: [1, %pi, z - y]], foo (splice (x)) / length (x));
foo(1, %pi, z - y)
(%o1) -----------------------
length([1, %pi, z - y])
(%i2) buildq ([x: [1, %pi]], "/" (splice (x)));
1
(%o2) ---
%pi
(%i3) matchfix ("<>", "<>");
(%o3) <>
(%i4) buildq ([x: [1, %pi, z - y]], "<>" (splice (x)));
(%o4) <>1, %pi, z - y<>
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
Konstruiert den Ausdruck F(arg_1, ..., arg_n) und
wertet diesen aus.
apply versucht nicht Array-Funktionen von gewöhnlichen Funktionen zu
unterscheiden. Ist F der Name eine Array-Funktion, wertet apply
den Ausdruck F(...) aus. arrayapply
entspricht der
Funktion apply, wenn F eine Array-Funktion ist.
Beispiele:
apply wertet die Argumente aus. In diesem Beispiel wird die Funktion
min
auf die Liste L angewendet.
(%i1) L : [1, 5, -10.2, 4, 3]; (%o1) [1, 5, - 10.2, 4, 3] (%i2) apply (min, L); (%o2) - 10.2
apply wertet die Argumente auch dann aus, wenn die Funktion F
die Auswertung ihrer Argumente unterdrückt.
(%i1) F (x) := x / 1729;
x
(%o1) F(x) := ----
1729
(%i2) fname : F;
(%o2) F
(%i3) dispfun (F);
x
(%t3) F(x) := ----
1729
(%o3) [%t3]
(%i4) dispfun (fname);
fname is not the name of a user function.
-- an error. Quitting. To debug this try debugmode(true);
(%i5) apply (dispfun, [fname]);
x
(%t5) F(x) := ----
1729
(%o5) [%t5]
apply wertet den Namen der Funktion F aus. Mit dem
Quote-Operator
' wird die Auswertung unterdrückt.
demoivre
ist der Name einer globalen Optionsvariable und einer Funktion.
(%i1) demoivre;
(%o1) false
(%i2) demoivre (exp (%i * x));
(%o2) %i sin(x) + cos(x)
(%i3) apply (demoivre, [exp (%i * x)]);
demoivre evaluates to false
Improper name or value in functional position.
-- an error. Quitting. To debug this try debugmode(true);
(%i4) apply ('demoivre, [exp (%i * x)]);
(%o4) %i sin(x) + cos(x)
Definiert eine Funktion mit dem Namen f und den Argumenten x1,
…, x_n und der Funktionsdefinition expr. define
wertet das zweite Argument immer aus.
Ist das letzte oder einzige Argument x_n eine Liste mit einem Element, dann akzeptiert die Funktion eine variable Anzahl an Argumenten. Die Argumente der Funktion werden nacheinander den Variablen x_1, …, x_(n-1) zugewiesen. Sind weitere Argumente vorhanden, werden diese als Liste der Variablen x_n zugewiesen.
Ist das erste Argument der Funktion define ein Ausdruck der Form
f(x_1, ..., x_n) oder f[x_1, ...,
x_n] werden die Argumente der Funktion ausgewertet, aber nicht die
Funktion f selbst. f wird auch dann nicht ausgewertet, wenn es
bereits eine Funktion mit dem Namen f gibt.
Das erste Argument wird dann ausgewertet, wenn es ein Ausdruck mit den
Funktionen funmake,
arraymake
oder ev
ist.
Alle Funktionsdefinitionen treten in demselben Namensraum auf. Die Definition
einer Funktion g innerhalb einer Funktion f führt nicht
automatisch zu einer lokalen Definition. Um eine lokale Funktion zu erhalten,
kann lokal(g) innerhalb der Funktion f ausgeführt werden.
Siehe auch local.
Ist eines der Argumente x_k nach der Auswertung ein quotiertes Symbol,
wertet die mit define definierte Funktion das Argument nicht aus.
Alle weiteren Argumente der Funktion werden ausgewertet.
Beispiele:
define wertet das zweite Argument aus.
(%i1) expr : cos(y) - sin(x); (%o1) cos(y) - sin(x) (%i2) define (F1 (x, y), expr); (%o2) F1(x, y) := cos(y) - sin(x) (%i3) F1 (a, b); (%o3) cos(b) - sin(a) (%i4) F2 (x, y) := expr; (%o4) F2(x, y) := expr (%i5) F2 (a, b); (%o5) cos(y) - sin(x)
Mit define können gewöhnliche Maxima-Funktionen und Array-Funktionen
definiert werden.
(%i1) define (G1 (x, y), x.y - y.x);
(%o1) G1(x, y) := x . y - y . x
(%i2) define (G2 [x, y], x.y - y.x);
(%o2) G2 := x . y - y . x
x, y
Ist das letzte oder einzige Argument x_n eine Liste mit einem Element,
akzeptiert die mit define definierte Funktion eine variable Anzahl an
Argumenten.
(%i1) define (H ([L]), '(apply ("+", L)));
(%o1) H([L]) := apply("+", L)
(%i2) H (a, b, c);
(%o2) c + b + a
Ist das erste Argument ein Ausdruck mit den Funktionen funmake,
arraymake oder ev wird das Argument ausgewertet.
(%i1) [F : I, u : x];
(%o1) [I, x]
(%i2) funmake (F, [u]);
(%o2) I(x)
(%i3) define (funmake (F, [u]), cos(u) + 1);
(%o3) I(x) := cos(x) + 1
(%i4) define (arraymake (F, [u]), cos(u) + 1);
(%o4) I := cos(x) + 1
x
(%i5) define (foo (x, y), bar (y, x));
(%o5) foo(x, y) := bar(y, x)
(%i6) define (ev (foo (x, y)), sin(x) - cos(y));
(%o6) bar(y, x) := sin(x) - cos(y)
Definiert eine globale Variable in der Maxima-Umgebung. define_variable
ist nützlich für das Schreiben von Paketen, die häufig übersetzt oder
kompiliert werden. define_variable führt die folgenden Schritte aus:
mode_declare(name, mode) deklariert den Typ der Variablen
name für den Übersetzer. Siehe mode_declare
für eine Liste
der möglichen Typen.
declare(name, special) deklariert die Variable als Special.
Einer mit define_variable definierten Variablen, die einen anderen Typ
als any erhalten hat, kann die Eigenschaft value_check zugewiesen
werden. Die value_check-Eigenschaft ist eine Aussagefunktion mit einer
Variablen oder ein Lambda-Ausdruck, die aufgerufen werden, wenn der Variablen
ein Wert zugewiesen werden soll. Das Argument der value_check-Funktion
ist der Wert, den die Variable erhalten soll.
define_variable wertet default_value aus. Die Argumente
name und mode werden nicht ausgewertet. define_variable
gibt den aktuellen Wert der Variable name zurück. Dieser ist
default_value, wenn der Variablen bisher kein Wert zugewiesen wurde.
Beispiele:
foo ist eine boolesche Variable mit dem Wert true.
(%i1) define_variable (foo, true, boolean); (%o1) true (%i2) foo; (%o2) true (%i3) foo: false; (%o3) false (%i4) foo: %pi; Error: foo was declared mode boolean, has value: %pi -- an error. Quitting. To debug this try debugmode(true); (%i5) foo; (%o5) false
bar ist eine Variable mit dem Typ einer ganzen Zahl, die eine Primzahl
sein muss.
(%i1) define_variable (bar, 2, integer);
(%o1) 2
(%i2) qput (bar, prime_test, value_check);
(%o2) prime_test
(%i3) prime_test (y) := if not primep(y) then
error (y, "is not prime.");
(%o3) prime_test(y) := if not primep(y)
then error(y, "is not prime.")
(%i4) bar: 1439;
(%o4) 1439
(%i5) bar: 1440;
1440 is not prime.
#0: prime_test(y=1440)
-- an error. Quitting. To debug this try debugmode(true);
(%i6) bar;
(%o6) 1439
baz_quux ist eine Variable, der kein Wert zugewiesen werden kann. Der
Typ any_check ist vergleichbar mit any. Aber any_check
ruft im Gegensatz zu any den value_check-Mechanismus auf.
(%i1) define_variable (baz_quux, 'baz_quux, any_check);
(%o1) baz_quux
(%i2) F: lambda ([y], if y # 'baz_quux then
error ("Cannot assign to `baz_quux'."));
(%o2) lambda([y], if y # 'baz_quux
then error(Cannot assign to `baz_quux'.))
(%i3) qput (baz_quux, ''F, value_check);
(%o3) lambda([y], if y # 'baz_quux
then error(Cannot assign to `baz_quux'.))
(%i4) baz_quux: 'baz_quux;
(%o4) baz_quux
(%i5) baz_quux: sqrt(2);
Cannot assign to `baz_quux'.
#0: lambda([y],if y # 'baz_quux then
error("Cannot assign to `baz_quux'."))(y=sqrt(2))
-- an error. Quitting. To debug this try debugmode(true);
(%i6) baz_quux;
(%o6) baz_quux
Zeigt die Definitionen der nutzerdefinierten Funktionen f_1, …, f_n an. Die Argumente können gewöhnliche Funktionen, Makros, Array-Funktionen oder indizierte Funktionen sein.
dispfun(all) zeigt die Definitionen aller nutzerdefinierten Funktionen
an, die in den Informationslisten functions,
arrays
oder
macros
enthalten sind.
dispfun erzeugt Zwischenmarken %t für jede einzelne anzuzeigende
Funktion und weist die Funktionsdefinitionen den Zwischenmarken zu. Im
Gegensatz dazu, zeigt die Funktion fundef
die Funktionsdefinition ohne
Zwischenmarken an.
dispfun wertet die Argumente nicht aus. dispfun gibt eine Liste
mit den Zwischenmarken zurück, die zu den angezeigten Funktionen gehören.
Beispiele:
(%i1) m(x, y) ::= x^(-y);
- y
(%o1) m(x, y) ::= x
(%i2) f(x, y) := x^(-y);
- y
(%o2) f(x, y) := x
(%i3) g[x, y] := x^(-y);
- y
(%o3) g := x
x, y
(%i4) h[x](y) := x^(-y);
- y
(%o4) h (y) := x
x
(%i5) i[8](y) := 8^(-y);
- y
(%o5) i (y) := 8
8
(%i6) dispfun (m, f, g, h, h[5], h[10], i[8]);
- y
(%t6) m(x, y) ::= x
- y
(%t7) f(x, y) := x
- y
(%t8) g := x
x, y
- y
(%t9) h (y) := x
x
1
(%t10) h (y) := --
5 y
5
1
(%t11) h (y) := ---
10 y
10
- y
(%t12) i (y) := 8
8
(%o12) [%t6, %t7, %t8, %t9, %t10, %t11, %t12]
(%i12) ''%;
- y - y - y
(%o12) [m(x, y) ::= x , f(x, y) := x , g := x ,
x, y
- y 1 1 - y
h (y) := x , h (y) := --, h (y) := ---, i (y) := 8 ]
x 5 y 10 y 8
5 10
Die Funktion fullmap ist vergleichbar mit der Funktion map.
Im Unterschied zu der Funktion map kann fullmap auf
verschachtelte Ausdrücke angewendet werden.
Intern wird fullmap von Maxima für die Vereinfachung von Matrizen
aufgerufen. Daher können bei der Vereinfachung von Matrizen Fehlermeldungen
im Zusammenhang mit fullmap auftreten, ohne dass die Funktion direkt
aufgerufen wurde.
Beispiele:
(%i1) a + b * c; (%o1) b c + a (%i2) fullmap (g, %); (%o2) g(b) g(c) + g(a) (%i3) map (g, %th(2)); (%o3) g(b c) + g(a)
Die Funktion fullmapl ist vergleichbar mit fullmap.
fullmapl kann jedoch nur auf Matrizen und Listen angewendet werden kann.
Beispiele:
(%i1) fullmapl ("+", [3, [4, 5]], [[a, 1], [0, -1.5]]);
(%o1) [[a + 3, 4], [4, 3.5]]
Standardwert: []
functions ist eine Informationsliste, die die vom Nutzer mit dem
Operator :=
oder der Funktion define
definierten Funktionen
enthält. Siehe auch die Systemvariable infolists.
Array-Funktionen und indizierte Funktionen werden nicht in die Informationsliste
functions,
sondern in die Informationsliste arrays
eingetragen.
Beispiele:
(%i1) F_1 (x) := x - 100;
(%o1) F_1(x) := x - 100
(%i2) F_2 (x, y) := x / y;
x
(%o2) F_2(x, y) := -
y
(%i3) define (F_3 (x), sqrt (x));
(%o3) F_3(x) := sqrt(x)
(%i4) G_1 [x] := x - 100;
(%o4) G_1 := x - 100
x
(%i5) G_2 [x, y] := x / y;
x
(%o5) G_2 := -
x, y y
(%i6) define (G_3 [x], sqrt (x));
(%o6) G_3 := sqrt(x)
x
(%i7) H_1 [x] (y) := x^y;
y
(%o7) H_1 (y) := x
x
(%i8) functions;
(%o8) [F_1(x), F_2(x, y), F_3(x)]
(%i9) arrays;
(%o9) [G_1, G_2, G_3, H_1]
Gibt die Definition der Funktion f zurück.
Das Argument f kann eine gewöhnliche Funktion, eine Makro-Funktion, eine Array-Funktion oder eine indizierte Funktion sein.
fundef wertet das Argument aus. Siehe auch dispfun.
Gibt den Ausdruck F(arg_1, ..., arg_n) zurück. Die
Rückgabe wird vereinfacht, aber nicht ausgewertet. Die Funktion F wird
also nicht aufgerufen, auch wenn diese existiert.
funmake versucht nicht, Array-Funktionen von gewöhnlichen Funktionen zu
unterscheiden. Ist F der Name einer Array-Funktion, dann gibt
funmake einen Ausdruck der Form F(...) zurück.
Für Array-Funktionen kann die Funktion arraymake
verwendet werden.
funmake wertet die Argumente aus.
Beispiele:
funmake angewendet auf eine gewöhnliche Funktion.
(%i1) F (x, y) := y^2 - x^2;
2 2
(%o1) F(x, y) := y - x
(%i2) funmake (F, [a + 1, b + 1]);
(%o2) F(a + 1, b + 1)
(%i3) ''%;
2 2
(%o3) (b + 1) - (a + 1)
funmake angewendet auf ein Makro.
(%i1) G (x) ::= (x - 1)/2;
x - 1
(%o1) G(x) ::= -----
2
(%i2) funmake (G, [u]);
(%o2) G(u)
(%i3) ''%;
u - 1
(%o3) -----
2
funmake angewendet auf eine indizierte Funktion.
(%i1) H [a] (x) := (x - 1)^a;
a
(%o1) H (x) := (x - 1)
a
(%i2) funmake (H [n], [%e]);
n
(%o2) lambda([x], (x - 1) )(%e)
(%i3) ''%;
n
(%o3) (%e - 1)
(%i4) funmake ('(H [n]), [%e]);
(%o4) H (%e)
n
(%i5) ''%;
n
(%o5) (%e - 1)
funmake angewendet auf ein Symbol, welches keine Funktion
repräsentiert.
(%i1) funmake (A, [u]); (%o1) A(u) (%i2) ''%; (%o2) A(u)
funmake wertet die Argumente, aber nicht die Rückgabe aus.
(%i1) det(a,b,c) := b^2 -4*a*c;
2
(%o1) det(a, b, c) := b - 4 a c
(%i2) (x : 8, y : 10, z : 12);
(%o2) 12
(%i3) f : det;
(%o3) det
(%i4) funmake (f, [x, y, z]);
(%o4) det(8, 10, 12)
(%i5) ''%;
(%o5) - 284
Maxima vereinfacht den Rückgabewert der Funktion funmake.
(%i1) funmake (sin, [%pi / 2]); (%o1) 1
Definiert einen Lambda-Ausdruck, der auch als anonyme Funktion bezeichnet wird, und gibt diesen zurück. Die Funktion kann Argumente x_1, …, x_m und optionale Argumente L haben. Die Rückgabe der Funktion ist das Ergebnis des Ausdrucks exprn. Ein Lambda-Ausdruck kann einer Variablen zugewiesen werden und wertet wie eine gewöhnliche Funktion aus. Ein Lambda-Ausdruck kann an solchen Stellen verwendet werden, wo der Name einer Funktion erwartet wird.
Wird der Lambda-Ausdruck ausgewertet, werden lokale Variablen x_1,
…, x_m erzeugt. lambda kann innerhalb von Blöcken oder
anderen Lambda-Ausdrücken verwendet werden. Mit jeder block-Anweisung
oder jedem Lambda-Ausdruck werden erneut lokale Variablen erzeugt. Die lokalen
Variablen sind jeweils global zu jeder eingeschlossenen block-Anweisung
oder zu jedem eingeschlossenen Lambda-Ausdruck. Ist eine Variable innerhalb von
block oder lambda nicht lokal, hat sie den Wert der
nächst höheren Anweisung, die ihr einen Wert gibt oder den globalen Wert der
Maxima-Umgebung.
Nachdem die lokalen Variablen erzeugt sind, werden die Ausdrücke expr_1,
…, expr_n nacheinander ausgewertet. Die Systemvariable %%,
welche das Ergebnis eines vorhergehendes Ausdrucks enthält, kann verwendet
werden. In einem Lambda-Ausdruck können die Anweisungen catch
und
throw
verwendet werden.
Die return
-Anweisung kann in einem Lambda-Ausdruck nur verwendet werden,
wenn sie von einer block-Anweisung eingeschlossen wird. Die
return-Anweisung definiert jedoch den Rückgabewert des Blocks und nicht
des Lambda-Ausdrucks. Auch die go
-Anweisung kann in einem
Lambda-Ausdrucks nur in einem Block verwendet werden.
lambda wertet die Argumente nicht aus.
Beispiele:
Ein Lambda-Ausdruck kann einer Variablen zugewiesen werden und wie eine gewöhnliche Funktion ausgewertet werden.
(%i1) f: lambda ([x], x^2);
2
(%o1) lambda([x], x )
(%i2) f(a);
2
(%o2) a
Ein Lamda-Ausdruck kann an Stellen verwendet werden, wo der Name einer Funktion erwartet wird.
(%i3) lambda ([x], x^2) (a);
2
(%o3) a
(%i4) apply (lambda ([x], x^2), [a]);
2
(%o4) a
(%i5) map (lambda ([x], x^2), [a, b, c, d, e]);
2 2 2 2 2
(%o5) [a , b , c , d , e ]
Die Argumente sind lokale Variablen. Andere Variablen sind globale Variablen. Globale Variablen werden zu dem Zeitpunkt ausgewertet, wenn der Lambda-Ausdruck ausgewertet wird.
(%i6) a: %pi$
(%i7) b: %e$
(%i8) g: lambda ([a], a*b);
(%o8) lambda([a], a b)
(%i9) b: %gamma$
(%i10) g(1/2);
%gamma
(%o10) ------
2
(%i11) g2: lambda ([a], a*''b);
(%o11) lambda([a], a %gamma)
(%i12) b: %e$
(%i13) g2(1/2);
%gamma
(%o13) ------
2
Lambda-Ausdrücke können verschachtelt werden. Lokale Variablen eines äußeren Lambda-Ausdrucks sind global zu den enthaltenen Lambda-Ausdrücken, außer diese werden wieder als lokal erklärt.
(%i14) h: lambda ([a, b], h2: lambda ([a], a*b), h2(1/2));
1
(%o14) lambda([a, b], h2 : lambda([a], a b), h2(-))
2
(%i15) h(%pi, %gamma);
%gamma
(%o15) ------
2
Da lambda die Argumente nicht auswertet, definiert der unten angegebene
Ausdruck i keine Funktion "multipliziere mit a". Solch eine
Funktion kann mit Hilfe der Funktion buildq
definiert werden.
(%i16) i: lambda ([a], lambda ([x], a*x));
(%o16) lambda([a], lambda([x], a x))
(%i17) i(1/2);
(%o17) lambda([x], a x)
(%i18) i2: lambda([a], buildq([a: a], lambda([x], a*x)));
(%o18) lambda([a], buildq([a : a], lambda([x], a x)))
(%i19) i2(1/2);
x
(%o19) lambda([x], -)
2
(%i20) i2(1/2)(%pi);
%pi
(%o20) ---
2
Ein Lambda-Ausdruck kann eine variable Anzahl an Argumenten haben, wenn das letzte Argument eine Liste mit einem Element ist.
(%i1) f : lambda ([aa, bb, [cc]], aa * cc + bb);
(%o1) lambda([aa, bb, [cc]], aa cc + bb)
(%i2) f (foo, %i, 17, 29, 256);
(%o2) [17 foo + %i, 29 foo + %i, 256 foo + %i]
(%i3) g : lambda ([[aa]], apply ("+", aa));
(%o3) lambda([[aa]], apply(+, aa))
(%i4) g (17, 29, x, y, z, %e);
(%o4) z + y + x + %e + 46
Gibt einen Ausdruck zurück, dessen Hauptoperator derselbe ist, wie der der Argumente expr_1, …, expr_n aber dessen Operanden das Ergebnis der Anwendung des Operators f auf die Teilausdrücke des Ausdrucks sind. f ist entweder der Name einer Funktion mit n Argumenten oder ein Lambda-Ausdruck mit n Argumenten.
Hat maperror
den Wert false, wird die Anwendung der Funktion
f gestoppt, (1) wenn die Anwendung auf den kürzesten Ausdruck
expr_i beendet ist und die Ausdrücke nicht alle dieselbe Länge haben
oder (2) wenn die Ausdrücke expr_i einen verschiedenen Typ haben. Hat
maperror den Wert true wird in den obigen Fällen eine
Fehlermeldung ausgegeben.
Beispiele:
(%i1) map(f,x+a*y+b*z);
(%o1) f(b z) + f(a y) + f(x)
(%i2) map(lambda([u],partfrac(u,x)),x+1/(x^3+4*x^2+5*x+2));
1 1 1
(%o2) ----- - ----- + -------- + x
x + 2 x + 1 2
(x + 1)
(%i3) map(ratsimp, x/(x^2+x)+(y^2+y)/y);
1
(%o3) y + ----- + 1
x + 1
(%i4) map("=",[a,b],[-0.5,3]);
(%o4) [a = - 0.5, b = 3]
Gibt den Wert true zurück, wenn der Ausdruck expr von Funktionen
die auf Argumente angewendete werden, als ein Atom betrachtet wird. Als Atome
werden Zahlen, einschließlich rationaler Zahlen und großer
Gleitkommazahlen, Symbole und indizierte Symbole betrachtet.
Standardwert: true
Hat maperror den Wert false, wird die Anwendung der Funktion
f gestoppt, (1) wenn die Anwendung auf den kürzesten Ausdruck
expr_i beendet ist und die Ausdrücke nicht alle dieselbe Länge haben
oder (2) wenn die Ausdrücke expr_i einen verschiedenen Typ haben. Hat
maperror den Wert true wird in den obigen Fällen eine
Fehlermeldung ausgegeben.
Standardwert: true
Hat mapprint den Wert true, werden verschiedene Informationen von
den Funktionen map,
maplist
und fullmap
ausgegeben.
Dies ist der Fall, wenn die Funktion map die Funktion apply
aufruft oder wenn für die Funktion map die Argumente eine verschiedene
Länge haben.
Hat mapprint den Wert false, werden diese Meldungen unterdrückt.
Wendet die Funktion f auf die Ausdrücke expr_1, …, expr_n an und gibt das Ergebnis als eine Liste zurück. f ist der Name einer Funktion oder ein lambda-Ausdruck.
Im Unterschied zu maplist gibt die Funktion map
einen Ausdruck
zurück, der denselben Hauptoperator wie die Ausdrücke expr_i hat.
Wendet die Funktion f auf jedes Element des äußeren Produktes der
Argumente a_1 x a_2 x … x a_n an.
f ist der Name einer Funktion mit n Argumenten oder ein Lambda-Ausdruck mit n Argumenten. Jedes Argument a_k kann eine Liste oder verschachtelte Liste, eine Matrix oder irgendein anderer Ausdruck sein.
outermap wertet die Argumente aus.
Siehe auch map,
maplist
und apply.
Beispiele:
Einfaches Beispiel für outermap. Die Funktion F ist
undefiniert.
(%i1) outermap(F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
[F(c, 1), F(c, 2), F(c, 3)]]
(%i2) outermap(F, matrix([a, b],[c, d]), matrix([1, 2],[3, 4]));
[ [ F(a, 1) F(a, 2) ] [ F(b, 1) F(b, 2) ] ]
[ [ ] [ ] ]
[ [ F(a, 3) F(a, 4) ] [ F(b, 3) F(b, 4) ] ]
(%o2) [ ]
[ [ F(c, 1) F(c, 2) ] [ F(d, 1) F(d, 2) ] ]
[ [ ] [ ] ]
[ [ F(c, 3) F(c, 4) ] [ F(d, 3) F(d, 4) ] ]
(%i3) outermap (F, [a, b], x, matrix ([1, 2], [3, 4]));
[ F(a, x, 1) F(a, x, 2) ] [ F(b, x, 1) F(b, x, 2) ]
(%o3) [[ ], [ ]]
[ F(a, x, 3) F(a, x, 4) ] [ F(b, x, 3) F(b, x, 4) ]
(%i4) outermap (F, [a, b], matrix ([1, 2]), matrix ([x], [y]));
[ [ F(a, 1, x) ] [ F(a, 2, x) ] ]
(%o4) [[ [ ] [ ] ],
[ [ F(a, 1, y) ] [ F(a, 2, y) ] ]
[ [ F(b, 1, x) ] [ F(b, 2, x) ] ]
[ [ ] [ ] ]]
[ [ F(b, 1, y) ] [ F(b, 2, y) ] ]
(%i5) outermap ("+", [a, b, c], [1, 2, 3]);
(%o5) [[a + 1, a + 2, a + 3], [b + 1, b + 2, b + 3],
[c + 1, c + 2, c + 3]]
Das Beispiel zeigt die Rückgabe der Funktion outermap detaillierter.
Das erste, zweite und dritte Argument sind eine Matrix, eine Liste und eine
Matrix. Der Rückgabewert ist eine Matrix. Jedes Element der Matrix ist eine
Liste und jedes Element der Liste ist eine Matrix.
(%i1) arg_1 : matrix ([a, b], [c, d]);
[ a b ]
(%o1) [ ]
[ c d ]
(%i2) arg_2 : [11, 22];
(%o2) [11, 22]
(%i3) arg_3 : matrix ([xx, yy]);
(%o3) [ xx yy ]
(%i4) xx_0 : outermap(lambda([x, y, z], x / y + z), arg_1,
arg_2, arg_3);
[ [ a a ] [ a a ] ]
[ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
[ [ 11 11 ] [ 22 22 ] ]
(%o4) Col 1 = [ ]
[ [ c c ] [ c c ] ]
[ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
[ [ 11 11 ] [ 22 22 ] ]
[ [ b b ] [ b b ] ]
[ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
[ [ 11 11 ] [ 22 22 ] ]
Col 2 = [ ]
[ [ d d ] [ d d ] ]
[ [[ xx + -- yy + -- ], [ xx + -- yy + -- ]] ]
[ [ 11 11 ] [ 22 22 ] ]
(%i5) xx_1 : xx_0 [1][1];
[ a a ] [ a a ]
(%o5) [[ xx + -- yy + -- ], [ xx + -- yy + -- ]]
[ 11 11 ] [ 22 22 ]
(%i6) xx_2 : xx_0 [1][1] [1];
[ a a ]
(%o6) [ xx + -- yy + -- ]
[ 11 11 ]
(%i7) xx_3 : xx_0 [1][1] [1] [1][1];
a
(%o7) xx + --
11
(%i8) [op (arg_1), op (arg_2), op (arg_3)];
(%o8) [matrix, [, matrix]
(%i9) [op (xx_0), op (xx_1), op (xx_2)];
(%o9) [matrix, [, matrix]
outermap erhält die Struktur der Argumente im Ergebnis. Die Funktion
cartesian_product erhält die Struktur der Argumente nicht.
(%i1) outermap (F, [a, b, c], [1, 2, 3]);
(%o1) [[F(a, 1), F(a, 2), F(a, 3)], [F(b, 1), F(b, 2), F(b, 3)],
[F(c, 1), F(c, 2), F(c, 3)]]
(%i2) setify (flatten (%));
(%o2) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
F(c, 1), F(c, 2), F(c, 3)}
(%i3) map(lambda([L], apply(F, L)),
cartesian_product({a, b, c}, {1, 2, 3}));
(%o3) {F(a, 1), F(a, 2), F(a, 3), F(b, 1), F(b, 2), F(b, 3),
F(c, 1), F(c, 2), F(c, 3)}
(%i4) is (equal (%, %th (2)));
(%o4) true
Hebt die Bindung der Symbole f_1, …, f_n an ihre
Funktionsdefinitionen auf. Die Argumente können die Namen von Funktionen
sein, die mit dem Operator :=
oder der Funktion define
definiert
wurden sowie Makro-Funktionen, die mit dem Operator ::=
definiert wurden.
remfunction(all) entfernt alle Bindungen von Funktionsdefinitionen.
remfunction gibt eine Liste mit den Symbolen zurück, die von ihren
Funktionsdefinitionen entbunden wurden. false wird für die Symbole
zurückgegeben, für die es keine Funktionsdefinition gibt.
remfunction wertet die Argumente nicht aus.
remfunction kann nicht auf Array-Funktionen und indizierte Funktionen
angewendet werden. Für diese Funktionen kann remarray
verwendet
werden.
Wendet die Funktion f rekursiv auf alle Teilausdrücke in expr an. Dies kann zum Beispiel verwendet werden, um einen Ausdruck vollständig zu faktorisieren.
Beispiele:
(%i1) exp:(a^2+2*a+1)*y + x^2$
(%i2) scanmap(factor,exp);
2 2
(%o2) (a + 1) y + x
(%i3) scanmap(factor,expand(exp));
2 2
(%o3) a y + 2 a y + y + x
Ein weiteres Beispiel für die Anwendung einer Funktion auf alle Teilausdrücke.
(%i4) expr : u*v^(a*x+b) + c$
(%i5) scanmap('f, expr);
f(f(f(a) f(x)) + f(b))
(%o5) f(f(f(u) f(f(v) )) + f(c))
scanmap (f, expr, bottomup) wendet die Funktion f
Bottom-up auf den Ausdruck expr an.
scanmap(f,a*x+b) ->
f(a*x+b) -> f(f(a*x)+f(b)) -> f(f(f(a)*f(x))+f(b))
scanmap(f,a*x+b,bottomup) -> f(a)*f(x)+f(b)
-> f(f(a)*f(x))+f(b) ->
f(f(f(a)*f(x))+f(b))
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Crategus on Dezember, 12 2012 using texi2html 1.76.