[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

24. Muster und Regeln


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

24.1 Einführung in Muster und Regeln

Dieses Kapitel beschreibt nutzerdefinierte Muster und Regeln für die Vereinfachung von Ausdrücken. Es gibt zwei verschiedene Gruppen von Funktionen, die einen unterschiedlichen Musterabgleich implementieren. Die eine Gruppe enthält die Funktionen tellsimp, tellsimpafter, defmatch, defrule, apply1, applyb1 apply2. sind die Funktionen let letsimp verwenden Mustervariablen, die mit der Funktion matchdeclare werden.

Regeln, die mit den Funktionen tellsimp und tellsimpafter definiert werden, werden von Maxima automatisch bei der Vereinfachung von Ausdrücken angewendet. Regeln, die mit den Funktionen defmatch, defrule oder let definiert werden, werden durch den Aufruf einer Funktion auf einen Ausdruck angewendet.

Maxima kennt weitere Methoden wie die Definition von minimalen Polynomen mit der Funktion tellrat, Polynomen zu nehmen, oder Funktionen der kommutativen und nicht-kommutativen Algebra, die in dem Paket affine definiert sind.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [Index] [ ? ]

24.2 Funktionen und Variablen für Muster und Regeln

Optionsvariable: announce_rules_firing

Standardwert: false

Hat die Optionsvariable announce_rules_firing den Wert true und wird mit den Funktionen tellsimp tellsimpafter definiert, dann wird immer dann eine Meldung ausgegeben, wenn die Regel angewendet wird. announce_rules_firing hat keinen Einfluss auf Regeln, die bereits definiert sind. Die Meldung von Regeln kann auch nicht durch das Setzen von announce_rules_firing auf den Wert false abgeschaltet werden.

Diese Optionsvariable ist nützlich, wenn die Anwendung von nutzerdefinierten Regeln für die Fehlersuche kontrolliert werden soll.

Beispiel:

(%i1) announce_rules_firing:true;
(%o1)                         true
(%i2) tellsimpafter(tan(x), sin(x)/cos(x));
(%o2)                 [tanrule1, simp-%tan]
(%i3) tan(x);

By tanrule1 , tan(x) --> sin(x)/cos(x) 
                             sin(x)
(%o3)                        ------
                             cos(x)

Funktion: apply1 (expr, rule_1, …, rule_n)

Wendet die Regel rule_1 auf den Ausdruck expr solange an, bis sich das Ergebnis nicht mehr ändert. Die Regel wird zuerst auf der obersten Ebene des Ausdrucks und dann nacheinander von links nach rechts auf die Teilausdrücke angewendet. Ist expr_1 das Ergebnis der Anwendung der Regel rule_1, dann wird die Regel rule_2 auf gleiche Weise auf den Ausdruck expr_1 angewendet. Zuletzt wird die Regel rule_n angewendet. Das letzte Ergebnis wird zurückgegeben.

Die Optionsvariable maxapplydepth Verschachtelungstiefe, für die die Funktionen apply1 und apply2 auf einen Ausdruck angewendet werden.

Siehe auch die Funktionen applyb1 apply2, einen Ausdruck anzuwenden, die mit der Funktion defrule

Beispiele:

(%i1) defrule(trig1, tan(x), sin(x)/cos(x));
                                      sin(x)
(%o1)               trig1 : tan(x) -> ------
                                      cos(x)
(%i2) defrule(trig2, cot(x), 1/tan(x));
                                        1
(%o2)               trig2 : cot(x) -> ------
                                      tan(x)
(%i3) apply1(cot(x), trig1, trig2);
                               1
(%o3)                        ------
                             tan(x)
(%i4) apply1(cot(x), trig2, trig1);
                             cos(x)
(%o4)                        ------
                             sin(x)

Die folgenden Beispiele zeigen, wie mit der Optionsvariablen maxapplydepth die Tiefe kontrolliert wird, in der eine Regel auf die Teilausdrücke angewendet wird.

(%i1) expr: tan(x)+exp(a+2*tan(x));
                                2 tan(x) + a
(%o1)                tan(x) + %e
(%i2) defrule(trig, tan(x), sin(x)/cos(x));
                                      sin(x)
(%o2)                trig : tan(x) -> ------
                                      cos(x)
(%i3) maxapplydepth: 1;
(%o3)                           1
(%i4) apply1(expr, trig);
                     sin(x)     2 tan(x) + a
(%o4)                ------ + %e
                     cos(x)
(%i5) maxapplydepth: 4;
(%o5)                           4
(%i6) apply1(expr, trig);
                                2 sin(x)
                                -------- + a
                     sin(x)      cos(x)
(%o6)                ------ + %e
                     cos(x)

Funktion: apply2 (expr, rule_1, …, rule_n)

Zunächst werden nacheinander die Regeln rule_1, rule_2, … auf den Ausdruck expr angewendet. Schlägt die Anwendung aller Regeln fehl, werden die Regeln nacheinander auf die Teilausdrücke des Argumentes expr angewendet. Kann eine der Regeln erfolgreich angewendet werden, wird die Anwendung aller Regeln auf den Teilausdruck wiederholt.

Im Unterschied zur Funktion apply1 immer alle Regeln angewendet. Sind jedoch die Regeln, die als Argumente übergeben werden, zirkulär definiert, so führt Maxima eine Endlosschleife aus. Siehe dazu auch das Beispiel unten.

Die Optionsvariable maxapplydepth Verschachtelungstiefe, für die die Funktionen apply1 und apply2 auf einen Ausdruck angewendet werden.

Siehe auch die Funktionen apply1 applyb1, auf einen Ausdruck anzuwenden, die mit der Funktion defrule sind.

Beispiele:

Im Unterschied zur Funktion apply1 immer sin(x)/cos(x), da alle Regeln wiederholt auf einen Teilausdruck angewendet werden, wenn sich der Ausdruck für eine Regel ändert.

(%i1) defrule(trig1, tan(x), sin(x)/cos(x));
                                      sin(x)
(%o1)               trig1 : tan(x) -> ------
                                      cos(x)
(%i2) defrule(trig2, cot(x), 1/tan(x));
                                        1
(%o2)               trig2 : cot(x) -> ------
                                      tan(x)
(%i3) apply2(cot(x), trig1, trig2);
                             cos(x)
(%o3)                        ------
                             sin(x)
(%i4) apply2(cot(x), trig2, trig1);
                             cos(x)
(%o4)                        ------
                             sin(x)

Das folgende Beispiel zeigt eine zirkuläre Definition der Regeln trig1 und trig2. Mit der Funktion apply1 hängt das Ergebnis von der Reihenfolge der Anwendung der Regeln ab. Die Anwendung der Funktion apply2 führt für dieses Beispiel zu einer Endlosschleife.

(%i1) defrule(trig1, tan(x), sin(x)/cos(x));
                                      sin(x)
(%o1)               trig1 : tan(x) -> ------
                                      cos(x)
(%i2) defrule(trig2, sin(x)/cos(x), tan(x));
                            sin(x)
(%o2)               trig2 : ------ -> tan(x)
                            cos(x)
(%i3) expr: tan(x) + exp(sin(x)/cos(x));
                                   sin(x)
                                   ------
                                   cos(x)
(%o3)                   tan(x) + %e
(%i4) apply1(expr, trig1, trig2);
                                   tan(x)
(%o4)                   tan(x) + %e
(%i5) apply1(expr, trig2, trig1);
                                   sin(x)
                                   ------
                        sin(x)     cos(x)
(%o5)                   ------ + %e
                        cos(x)

Funktion: applyb1 (expr, rule_1, …, rule_n)

Wendet die Regel rule_1 auf den tiefsten Teilausdruck in der Baumstruktur eines Ausdrucks an. Schlägt die Anwendung fehl, wird der Teilausdruck eine Ebene höher betrachtet, bis rule_1 auf die oberste Ebene des Ausdrucks expr angewendet wird. Danach wird auf gleiche Weise die Regel rule_2 auf den Ausdruck expr angewendet. Nachdem die letzte Regel rule_n angewendet wurde, wird das Ergebnis zurückgegeben.

applyb1 ist vergleichbar mit apply1 die Regeln Bottom-Up angewendet werden.

Die Optionsvariable maxapplyheight Verschachtelungstiefe, für die applyb1 angewendet wird.

Siehe auch die Funktionen apply1 apply2, einen Ausdruck anzuwenden, die mit der Funktion defrule

Beispiel:

Das folgende Beispiel zeigt, wie die Regel trig zuerst auf die unterste Ebene des Ausdrucks angewendet wird. Dazu wird die Optionsvariable maxapplyheight zunächst auf den Wert 1 gesetzt und dann auf den Wert 4 erhöht.

(%i1) matchdeclare(x, true);
(%o1)                         done
(%i2) defrule(trig, tan(x), sin(x)/cos(x));
                                      sin(x)
(%o2)                trig : tan(x) -> ------
                                      cos(x)
(%i3) expr: exp(a+2*tan(b+exp(tan(x))));
                              tan(x)
                      2 tan(%e       + b) + a
(%o3)               %e
(%i4) maxapplyheight: 1;
(%o4)                           1
(%i5) applyb1(expr, trig);
                              sin(x)
                              ------
                              cos(x)
                      2 tan(%e       + b) + a
(%o5)               %e
(%i6) maxapplyheight: 4;
(%o6)                           4
(%i7) applyb1(expr, trig);
                              sin(x)
                              ------
                              cos(x)
                      2 sin(%e       + b)
                      ------------------- + a
                             sin(x)
                             ------
                             cos(x)
                       cos(%e       + b)
(%o7)               %e

Funktion: clear_rules ()

Führt das Kommando kill(rules) aus und setzt die internen Zähler für die Benennung der Regeln für die Addition, die Multiplikation und die Exponentiation auf den Anfangswert zurück. Mit dem Kommando kill(rules) werden alle Regeln entfernt, ohne dass die internen Zähler zurückgesetzt werden. Siehe auch die Funktion kill.

Beispiel:

(%i1) tellsimpafter(a+b, add(a,b));
(%o1)                   [+rule1, simplus]
(%i2) tellsimpafter(a*b, mul(a,b));
(%o2)                  [*rule1, simptimes]
(%i3) tellsimpafter(a^b, expt(a,b));
(%o3)                  [^rule1, simpexpt]
(%i4) rules;
(%o4)               [+rule1, *rule1, ^rule1]
(%i5) clear_rules();
(%o5)                         done
(%i6) rules;
(%o6)                          []

Das folgende Beispiel zeigt einen Programmfehler von Maxima. Die Funktion trigsimp automatisch beim ersten Aufruf der Funktion trigsimp geladen und in die Liste rules clear_rules oder kill gelöscht, führt der nächste Aufruf der Funktion trigsimp zu einem Fehler.

(%i1) trigsimp(sin(x)^2+cos(x)^2);
(%o1)                           1
(%i2) rules;
(%o2) [trigrule1, trigrule2, trigrule3, trigrule4, htrigrule1, 
                              htrigrule2, htrigrule3, htrigrule4]
(%i3) disprule(trigrule1, trigrule2, trigrule3, trigrule4)$
                                        sin(a)
(%t3)             trigrule1 : tan(a) -> ------
                                        cos(a)

                                          1
(%t4)             trigrule2 : sec(a) -> ------
                                        cos(a)

                                          1
(%t5)             trigrule3 : csc(a) -> ------
                                        sin(a)

                                        cos(a)
(%t6)             trigrule4 : cot(a) -> ------
                                        sin(a)

(%i7) clear_rules();
(%o7)                         done
(%i8) rules;
(%o8)                          []
(%i9) trigsimp(sin(x)^2+cos(x)^2);

apply1: no such rule: trigrule1
#0: trigsimp(x=sin(x)^2+cos(x)^2)(trgsmp.mac line 71)
 -- an error. To debug this try: debugmode(true);

Optionsvariable: current_let_rule_package

Standardwert: default_let_rule_package

Die Optionsvariable current_let_rule_package enthält den Namen des aktuellen Regelpaketes, das von den Funktionen let, letrules, letsimp remlet Optionsvariablen kann jedes mit der Funktion let definierte Regelpaket zugewiesen werden.

Wird das Kommando letsimp(expr, rule_pkg_name) ausgeführt, dann wird für das aktuelle Kommando das Paket rule_pkg_name verwendet. Der Wert der Variablen current_let_rule_package wird nicht geändert.

Siehe auch die Optionsvariable default_let_rule_package.

Optionsvariable: default_let_rule_package

Standardwert: default_let_rule_package

Die Optionsvariable default_let_rule_package bezeichnet das Regelpaket, das verwendet wird, wenn kein Regelpaket mit der Funktion let explizit definiert und der Wert der Optionsvariablen current_let_rule_package nicht geändert wurde.

Funktion: defmatch (progname, pattern, x_1, …, x_n)
Funktion: defmatch (progname, pattern)

Definiert eine Aussagefunktion progname(expr) oder progname(expr, x_1, ..., x_n), die einen Ausdruck expr testet, um zu prüfen, ob dieser das Muster pattern enthält.

Das Argument pattern ist ein Ausdruck mit den Musterargumenten x_1, …, x_n. Die Musterargumente können entfallen. Der Ausdruck kann weiterhin Mustervariablen enthalten, die mit der Funktion matchdeclare entsprechen sich selbst bei einem Musterabgleich.

Das erste Argument der Aussagefunktion progname ist ein Ausdruck expr, für den geprüft wird, ob das Muster pattern enthalten ist. Die weiteren Argumente der Funktion progname sind die Variablen, die den Musterargumenten x_1, …, x_n des Musters pattern entsprechen.

Ist der Musterabgleich erfolgreich, gibt die Aussagefunktion progname eine Liste mit Gleichungen zurück. Die linken Seiten der Gleichungen sind die Musterargumente und Mustervariablen und die rechten Seiten sind die Teilausdrücke, für die der Musterabgleich eine Übereinstimmung gefunden hat. Die erhaltenen Ergebnisse des Musterabgleichs werden den mit matchdeclare Musterargumenten der Funktion defmatch zugewiesen. Ist der Musterabgleich nicht erfolgreich, ist die Rückgabe false.

Ein Muster, das keine Musterargumente oder Mustervariablen enthält, hat den Rückgabewert true, wenn der Musterabgleich erfolgreich ist.

Die Aussagefunktion progname wird in die Informationsliste rules

Siehe auch die Funktionen matchdeclare, defrule, tellsimp tellsimpafter.

Beispiele:

Definition einer Funktion linearp(expr, x), die prüft, ob ein Ausdruck expr die Form a*x+b hat, wobei a und b die Variable x nicht enthalten und a von Null verschieden ist. Die Definition enthält das Musterargument x, so dass die Linearität des Ausdrucks für eine beliebige Variable getestet werden kann. Den Mustervariablen a und b werden die Teilausdrücke des Musterabgleichs zugewiesen, nicht jedoch dem Musterargument x.

(%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), 
                    b, freeof(x));
(%o1)                         done
(%i2) defmatch (linearp, a*x + b, x);
(%o2)                        linearp
(%i3) linearp (3*z + (y + 1)*z + y^2, z);
                         2
(%o3)              [b = y , a = y + 4, x = z]
(%i4) a;
(%o4)                         y + 4
(%i5) b;
                                2
(%o5)                          y
(%i6) x;
(%o6)                           x

Wie im letzten Beispiel wird eine Aussagefunktion definiert, die prüft, ob ein Ausdruck expr linear ist. In diesem Fall wird kein Musterargument angegeben. Der Musterabgleich kann nur feststellen, ob ein Ausdruck linear in der Variablen x ist. Eine andere Variable ist nicht möglich.

(%i1) matchdeclare (a, lambda ([e], e#0 and freeof(x, e)), b,
                    freeof(x));
(%o1)                         done
(%i2) defmatch (linearp, a*x + b);
(%o2)                        linearp
(%i3) linearp (3*z + (y + 1)*z + y^2);
(%o3)                         false
(%i4) linearp (3*x + (y + 1)*x + y^2);
                             2
(%o4)                  [b = y , a = y + 4]

Definition eine Aussagefunktion checklimits(expr), die prüft, ob ein Ausdruck expr ein bestimmtes Integral ist.

(%i1) matchdeclare ([a, f], true);
(%o1)                         done
(%i2) constinterval (l, h) := constantp (h - l);
(%o2)        constinterval(l, h) := constantp(h - l)
(%i3) matchdeclare (b, constinterval (a));
(%o3)                         done
(%i4) matchdeclare (x, atom);
(%o4)                         done
(%i5) simp : false;
(%o5)                         false
(%i6) defmatch (checklimits, 'integrate (f, x, a, b));
(%o6)                      checklimits
(%i7) simp : true;
(%o7)                         true
(%i8) 'integrate (sin(t), t, %pi + x, 2*%pi + x);
                       x + 2 %pi
                      /
                      [
(%o8)                 I          sin(t) dt
                      ]
                      /
                       x + %pi
(%i9) checklimits (%);
(%o9)    [b = x + 2 %pi, a = x + %pi, x = t, f = sin(t)]

Funktion: defrule (rulename, pattern, replacement)

Definiert eine Regel, um das Muster pattern durch den Ausdruck replacement zu ersetzen. Wird die Regel mit dem Namen rulename mit den Funktionen apply1, apply2 applyb1 einen Ausdruck angewendet, werden alle Teilausdrücke, die dem Muster pattern entsprechen, durch den Ausdruck replacement ersetzt. Sind Mustervariablen vorhanden, die durch den Musterabgleich einen Wert erhalten haben, werden die Werte eingesetzt und der Ausdruck wird vereinfacht.

Die Regel rulename kann als eine Funktion aufgefasst werden, die einen Ausdruck durch Anwendung eines Musterabgleichs transformiert. Die Regel kann wie ein Funktionsaufruf auf einen Ausdruck angewendet werden.

Schlägt der Musterabgleich fehl, gibt die Regel den Wert false zurück.

Die Regel wird in die Informationsliste rules

Beispiele:

Es wird eine Regel trig definiert, die den Ausdruck sin(x)^2 nach 1-cos(x)^2 transformiert. Diese Definition funktioniert nur, wenn das Argument der Sinusfunktion das Symbol x ist.

(%i1) defrule(trig, sin(x)^2, 1-cos(x)^2);
                            2              2
(%o1)             trig : sin (x) -> 1 - cos (x)
(%i2) trig(sin(x)^2);
                                  2
(%o2)                      1 - cos (x)
(%i3) trig(sin(y)^2);
(%o3)                         false

In diesem Beispiel wird zunächst mit der Funktion matchdeclare Mustervariable a definiert, der jeder Ausdruck zugewiesen werden kann und die als Argument der Regel verwendet wird. Jetzt kann das Argument der Sinusfunktion ein beliebiger Ausdruck sein.

(%i1) matchdeclare(a, true);
(%o1)                         done
(%i2) defrule(trig, sin(a)^2, 1-cos(a)^2);
                            2              2
(%o2)             trig : sin (a) -> 1 - cos (a)
(%i3) trig(sin(x)^2);
                                  2
(%o3)                      1 - cos (x)
(%i4) trig(sin(exp(x))^2);
                                 2   x
(%o4)                     1 - cos (%e )

Die Regel kann mit der Funktion apply1 wobei Teilausdrücke, die das Muster enthalten transformiert werden.

(%i5) trig(exp(sin(x)^2));
(%o5)                         false
(%i6) apply1(exp(sin(x)^2), trig);
                                   2
                            1 - cos (x)
(%o6)                     %e

Funktion: disprule (rulename_1, …, rulename_n)
Funktion: disprule (all)

Zeigt die Regeln mit den Namen rulename_1, …, rulename_n an, die mit den Funktionen defrule, tellsimp tellsimpafter Funktion defmatch Zwischenmarke %t

Mit dem Kommando disprule(all) werden alle Regeln und Muster angezeigt, die der Nutzer definiert hat und in der Informationsliste rules enthalten sind.

disprule wertet die Argumente nicht aus. Der Rückgabewert ist eine Liste mit den Zwischenmarken, denen eine Regel zugewiesen wurde.

Siehe auch die Funktion letrules, der Funktion let

Beispiele:

(%i1) tellsimpafter (foo (x, y), bar (x) + baz (y));
(%o1)                   [foorule1, false]
(%i2) tellsimpafter (x + y, special_add (x, y));
(%o2)                   [+rule1, simplus]
(%i3) defmatch (quux, mumble (x));
(%o3)                         quux
(%i4) disprule (foorule1, "+rule1", quux);
(%t4)        foorule1 : foo(x, y) -> baz(y) + bar(x)

(%t5)          +rule1 : y + x -> special_add(x, y)

(%t6)                quux : mumble(x) -> []

(%o6)                    [%t4, %t5, %t6]
(%i6) ''%;
(%o6) [foorule1 : foo(x, y) -> baz(y) + bar(x), 
     +rule1 : y + x -> special_add(x, y), quux : mumble(x) -> []]

Funktion: let (prod, repl)
Funktion: let (prod, repl, predname, arg_1, …, arg_n)
Funktion: let ([prod, repl, predname, arg_1, …, arg_n], package_name)

Definiert eine Regel, die mit der Funktion letsimp angewendet werden kann, so dass prod durch repl ersetzt wird. Das Argument prod ist ein Produkt von positiven oder negativen Potenzen der folgenden Terme:

Ein Term mit einer positiven Potenz stimmt mit einem Ausdruck nur dann überein, wenn dieser mindestens dieselbe Potenz hat. Entsprechend gilt für einen Term mit einer negativen Potenz, dass dieser dann mit einem Ausdruck übereinstimmt, wenn dieser mindestens dieselbe negative Potenz hat. Für negative Potenzen wird eine Übereinstimmung nur dann gefunden, wenn die Optionsvariable letrat

Hat die Funktion let eine Aussagefunktion predname als Argument mit den Argumenten arg_1, …, arg_n, wird eine Übereinstimmung dann festgestellt, wenn der Ausdruck predname(arg_1', ..., arg_n') das Ergebnis true hat. Dabei sind die Argumente arg_i' die Werte aus dem Musterabgleich. Die Argumente arg_i können die Namen von Variablen oder Termen sein, die im Ausdruck pred auftreten. repl kann ein beliebiger rationaler Ausdruck sein. Treten irgendwelche der Symbole oder Argumente aus prod im Argument repl auf, wird die entsprechende Substitution ausgeführt.

Die Optionsvariable letrat durch letsimp. Zähler und der Nenner eines Bruches einzeln vereinfacht. Der Bruch als ganzes wird dagegen nicht vereinfacht. Hat die Optionsvariable letrat den Wert true, werden nacheinander der Zähler, der Nenner und dann der Bruch vereinfacht.

Die Funktion letsimp Regelpaket kann eine beliebige Anzahl an Regeln enthalten. Das Kommando let([prod, repl, predname, arg_1, ..., arg_n], package_name) fügt die Regel predname dem Paket package_name hinzu.

Die Optionsvariable current_let_rule_package Regelpaketes, das aktuell von der Funktion letsimp verwendet wird. Der Optionsvariablen kann jedes mit dem Kommando let definierte Regelpaket zugewiesen werden. Wird mit letsimp(expr, package_name) ein Regelpaket als Argument übergeben, wird dieses anstatt dem in current_let_rule_package enthaltene Regelpaket für die Vereinfachung verwendet. Wenn nicht anders spezifiziert, hat current_let_rule_package den Standardwert default_let_rule_package.

Die Informationsliste let_rule_packages Regelpakete. Mit der Funktion letrules oder Regeln einzelner Pakete angezeigt werden.

Beispiele:

Die Funktion isintegerp prüft auch, ob Variablen oder Ausdrücke eine ganze Zahl repräsentieren. Es wird eine Regel definiert, die dann angewendet wird, wenn das Argument eine ganze Zahl repräsentiert.

(%i1) isintegerp(x) := featurep(x, integer)$

(%i2) let(tan(x), sin(x)/cos(x), isintegerp, x);
(%o2) tan(x) --> sin(x)/cos(x) where isintegerp(x)

(%i3) letsimp(tan(x));
(%o3) tan(x)

(%i4) declare(x, integer)$

(%i5) letsimp(tan(x));
(%o5) sin(x)/cos(x)
(%i6) letsimp(tan(1));
(%o6) tan(1)

Weitere Beispiele:

(%i1) matchdeclare ([a, a1, a2], true)$
(%i2) oneless (x, y) := is (x = y-1)$
(%i3) let (a1*a2!, a1!, oneless, a2, a1);
(%o3)         a1 a2! --> a1! where oneless(a2, a1)
(%i4) letrat: true$
(%i5) let (a1!/a1, (a1-1)!);
                        a1!
(%o5)                   --- --> (a1 - 1)!
                        a1
(%i6) letsimp (n*m!*(n-1)!/m);
(%o6)                      (m - 1)! n!
(%i7) let (sin(a)^2, 1 - cos(a)^2);
                        2               2
(%o7)                sin (a) --> 1 - cos (a)
(%i8) letsimp (sin(x)^4);
                        4           2
(%o8)                cos (x) - 2 cos (x) + 1

Optionsvariable: let_rule_packages

Standardwert: [default_let_rule_package]

let_rule_packages ist eine Informationsliste mit den vom Nutzer mit der Funktion let

Optionsvariable: letrat

Standardwert: false

Hat die Optionsvariable letrat den Wert false, werden von der Funktion letsimp vereinfacht. Der Bruch als ganzes wird dagegen nicht vereinfacht.

Hat die Optionsvariable letrat den Wert true, werden nacheinander der Zähler, der Nenner und dann der Bruch vereinfacht.

Beispiele:

(%i1) matchdeclare (n, true)$
(%i2) let (n!/n, (n-1)!);
                         n!
(%o2)                    -- --> (n - 1)!
                         n
(%i3) letrat: false$
(%i4) letsimp (a!/a);
                               a!
(%o4)                          --
                               a
(%i5) letrat: true$
(%i6) letsimp (a!/a);
(%o6)                       (a - 1)!

Funktion: letrules ()
Funktion: letrules (package_name)

Zeigt die Regeln eines Regelpaketes an. Das Kommando letrules() zeigt die Regeln des aktuellen Regelpaketes an, das durch die Optionsvariable current_let_rule_package letrules(package_name) zeigt die Regeln des Paketes package_name an.

Wenn der Optionsvariablen current_let_rule_package kein Name eines Paketes zugewiesen wurde, enthält es den Standardwert default_let_rule_package.

Siehe auch die Funktion disprule, den Funktionen tellsimp, tellsimpafter defrule definiert wurden.

Beispiel:

Im folgenden Beispiel werden einem Paket mit dem Namen trigrules zwei Regeln hinzugefügt. Die Regeln werden mit dem Kommando letrules(trigrules) angezeigt. Wird das Paket zum aktuellen Paket erklärt, indem es der Variablen current_let_rule_package zugewiesen wird, dann werden die Regeln auch mit dem Kommando letrules() angezeigt.

(%i1) let([sin(x)^2, 1-cos(x)^2], trigrules);
                        2               2
(%o1)                sin (x) --> 1 - cos (x)
(%i2) let([tan(x), sin(x)/cos(x)], trigrules);
                                   sin(x)
(%o2)                   tan(x) --> ------
                                   cos(x)
(%i3) letrules(trigrules);
                                   sin(x)
                        tan(x) --> ------
                                   cos(x)

                        2               2
                     sin (x) --> 1 - cos (x)

(%o3)                         done
(%i4) letrules();
(%o4)                         done
(%i5) current_let_rule_package: trigrules;
(%o5)                       trigrules
(%i6) letrules();
                                   sin(x)
                        tan(x) --> ------
                                   cos(x)

                        2               2
                     sin (x) --> 1 - cos (x)

(%o6)                         done

Funktion: letsimp (expr)
Funktion: letsimp (expr, package_name)
Funktion: letsimp (expr, package_name_1, …, package_name_n)

Wendet die Regeln, die mit der Funktion let solange an, bis sich das Argument expr nicht mehr ändert. letsimp(expr) wendet die aktuellen Regeln an, die mit der Optionsvariablen current_let_rule_package

letsimp(expr, package_name) wendet die Regeln des Argumentes package_name an. Die Optionsvariable current_let_rule_package ändert ihren Wert nicht. Es können auch mehrere Regelpakete package_name_1, …, package_name_n angegeben werden.

Die Optionsvariable letrat durch letsimp. Hat letrat den Wert false, werden der Zähler und der Nenner eines Bruches einzeln vereinfacht. Der Bruch als ganzes wird dagegen nicht vereinfacht. Hat die Optionsvariable letrat den Wert true, werden nacheinander der Zähler, der Nenner und dann der Bruch vereinfacht.

Funktion: matchdeclare (a_1, pred_1, …, a_n, pred_n)

Mit der Funktion matchdeclare werden Mustervariablen definiert. matchdeclare ordnet eine Aussagefunktion pred_k einer Variable oder eine Liste von Variablen a_k zu, so dass a_k bei einem Musterabgleich mit Ausdrücken übereinstimmt, für die die Aussage ein anderes Ergebnis als false hat.

Eine Aussagefunktion pred_i kann durch den Namen einer Funktion, einen Lambda-Ausdruck, einen Funktionsaufruf, einen Lambda-Ausdruck, dem das letzte Argument fehlt, oder die Werte true oder all bezeichnet werden. Ist die Aussagefunktion ein Funktionsaufruf oder ein Lambda-Aufruf, dann wird der zu testende Ausdruck der Liste der Argumente hinzugefügt. Die Argumente werden ausgewertet, wenn der Musterabgleich ausgeführt wird. Ist die Aussage der Name einer Funktion oder ein Lambda-Ausdruck, ist die zu testende Aussage das einzige Argument. Die Aussagefunktion braucht noch nicht definiert zu sein, wenn mit matchdeclare eine Mustervariable definiert wird, da die Aussagefunktion erst aufgerufen wird, wenn ein Musterabgleich durchgeführt wird.

Eine Aussagefunktion kann einen logischen Ausdruck oder die Werte true oder false zurückgeben. Logische Ausdrücke werden von der Funktion is notwendig, dass die Aussagefunktion selbst die Funktion is aufruft.

Wenn für einen Ausdruck eine Übereinstimmung bei einem Musterabgleich gefunden wird, wird der Mustervariablen der Ausdruck zugewiesen. Jedoch nicht für Mustervariablen, die Argumente der Addition + oder Multiplikation * sind. Diese Operatoren werden besonders behandelt. Andere Maxima oder vom Nutzer definierte N-ary-Operatoren werden dagegen wie normale Funktionen behandelt.

Im Falle der Addition und der Multiplikation kann der Mustervariablen ein einzelner Term zugewiesen werden, für den der Musterabgleich zu einer Überstimmung führt, oder auch eine Summe oder ein Produkt von Termen. Die mehrfache Übereinstimmung hat Vorrang. Aussagefunktionen werden in der Reihenfolge ausgewertet, in der die der Aussagefunktion zugeordneten Mustervariablen im Muster auftreten. Führt der Musterabgleich für einen Term zu einer Übereinstimmung mit mehreren Aussagefunktionen, dann wird der Term der Mustervariablen zugeordnet für den die erste Aussagefunktion zutrifft. Jede Aussagefunktion wird zunächst auf alle Argumente einer Summe oder eines Produktes angewendet, bevor die nächste Aussagefunktion ausgewertet wird. Wird für die Zahlen 0 oder 1 eine Übereinstimmung gefunden und es sind keine weiteren Terme vorhanden, wird der Mustervariablen 0 oder 1 zugewiesen.

Der Algorithmus, um Muster abzugleichen, die die Addition oder die Multiplikation als Operanden enthalten, kann von der Anordnung der Terme im Muster oder im zu prüfenden Ausdruck abhängen. Solange sich jedoch die einzelnen Aussagefunktionen gegeneinander ausschließen, wird das Ergebnis nicht von der Reihenfolge der Argumente beeinflußt.

Der Aufruf von matchdeclare für eine Variable a überschreibt eine vorhergehende Definition für diese Variable. Wird eine Regel definiert, ist die letzte mit matchdeclare definierte Zuordnung zu einer Aussagefunktion wirksam. Der erneute Aufruf von matchdeclare für eine Variable hat keinen Einfluss auf bereits vorhandene Regeln.

Das Kommando propvars(matchdeclare) gibt eine Liste der Variablen zurück, die mit matchdeclare als Mustervariable definiert sind. printprops(a, matchdeclare) gibt die der Variable a zugeordnete Aussagefunktion zurück. printprops(all, matchdeclare) gibt die Aussagefunktionen aller Mustervariablen zurück. Mit dem Kommando remove(a, matchdeclare) wird die Definition von a als Mustervariable entfernt. Siehe auch die Funktionen propvars, printprops remove.

Mit den Funktionen defmatch, defrule, tellsimp, tellsimpafter let definiert, die für Ausdrücke einen Musterabgleich ausführen, wobei die Mustervariablen mit den Werten belegt werden, für die eine Übereinstimmung gefunden wird.

matchdeclare wertet die Argumente nicht aus. matchdeclare gibt immer done als Ergebnis zurück.

Beispiele:

Eine Aussagefunktion kann mit dem Namen einer Funktion, einem Lambda-Ausdruck, einem Funktionsaufruf, einem Lambda-Ausdruck, dem das letzte Argument fehlt, oder den Werten true oder all bezeichnet werden.

(%i1) matchdeclare (aa, integerp);
(%o1)                         done
(%i2) matchdeclare (bb, lambda ([x], x > 0));
(%o2)                         done
(%i3) matchdeclare (cc, freeof (%e, %pi, %i));
(%o3)                         done
(%i4) matchdeclare (dd, lambda ([x, y], gcd (x, y) = 1) (1728));
(%o4)                         done
(%i5) matchdeclare (ee, true);
(%o5)                         done
(%i6) matchdeclare (ff, all);
(%o6)                         done

Wird für einen Ausdruck beim Musterabgleich eine Übereinstimmung gefunden, wird dieser der Mustervariablen zugewiesen.

(%i1) matchdeclare (aa, integerp, bb, atom);
(%o1)                         done
(%i2) defrule (r1, bb^aa, ["integer" = aa, "atom" = bb]);
                    aa
(%o2)        r1 : bb   -> [integer = aa, atom = bb]
(%i3) r1 (%pi^8);
(%o3)               [integer = 8, atom = %pi]

Im Falle der Addition und Multiplikation kann der Mustervariablen ein einzelner Term zugewiesen werden, welcher mit der Aussage übereinstimmt, aber auch eine Summe oder ein Produkt solcher Ausdrücke.

(%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
(%o1)                         done
(%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" =
               bb]);
bb + aa partitions `sum'
(%o2)  r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
(%i3) r1 (8 + a*b + sin(x));
(%o3)     [all atoms = 8, all nonatoms = sin(x) + a b]
(%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" =
               bb]);
bb aa partitions `product'
(%o4)   r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
(%i5) r2 (8 * (a + b) * sin(x));
(%o5)    [all atoms = 8, all nonatoms = (b + a) sin(x)]

Wird nach Übereinstimmungen für die Argumente der Operatoren + oder * gesucht und schließen sich die Aussagefunktionen gegeneinander aus, ist das Ergebnis unabhängig von der Anordnung der Terme.

(%i1) matchdeclare (aa, atom, bb, lambda ([x], not atom(x)));
(%o1)                         done
(%i2) defrule (r1, aa + bb, ["all atoms" = aa, "all nonatoms" =
               bb]);
bb + aa partitions `sum'
(%o2)  r1 : bb + aa -> [all atoms = aa, all nonatoms = bb]
(%i3) r1 (8 + a*b + %pi + sin(x) - c + 2^n);
                                                     n
(%o3) [all atoms = %pi + 8, all nonatoms = sin(x) + 2  - c + a b]
(%i4) defrule (r2, aa * bb, ["all atoms" = aa, "all nonatoms" =
               bb]);
bb aa partitions `product'
(%o4)   r2 : aa bb -> [all atoms = aa, all nonatoms = bb]
(%i5) r2 (8 * (a + b) * %pi * sin(x) / c * 2^n);
                                                  n
                                         (b + a) 2  sin(x)
(%o5) [all atoms = 8 %pi, all nonatoms = -----------------]
                                                 c

Die Funktionen propvars printprops Mustervariablen aus.

(%i1) matchdeclare ([aa, bb, cc], atom, [dd, ee], integerp);
(%o1)                         done
(%i2) matchdeclare (ff, floatnump, gg, lambda ([x], x > 100));
(%o2)                         done
(%i3) propvars (matchdeclare);
(%o3)             [aa, bb, cc, dd, ee, ff, gg]
(%i4) printprops (ee, matchdeclare);
(%o4)                    [integerp(ee)]
(%i5) printprops (gg, matchdeclare);
(%o5)              [lambda([x], x > 100, gg)]
(%i6) printprops (all, matchdeclare);
(%o6) [lambda([x], x > 100, gg), floatnump(ff), integerp(ee), 
                      integerp(dd), atom(cc), atom(bb), atom(aa)]

Optionsvariable: maxapplydepth

Standardwert: 10000

maxapplydepth ist die maximale Verschachtelungstiefe für die die Funktionen apply1 apply2 angewendet werden.

Optionsvariable: maxapplyheight

Standardwert: 10000

maxapplyheight ist die maximale Verschachtelungstiefe für die die Funktion applyb1 angewendet wird.

Funktion: remlet (prod, package_name)
Funktion: remlet ()
Funktion: remlet (all)
Funktion: remlet (all, package_name)

Entfernt die Regel prod -> repl, die zuletzt mit der Funktion let ein Paket angegeben, wird die Regeln aus dem entsprechenden Paket entfernt.

remlet() und remlet(all) entfernen alle Regeln aus dem aktuellen Paket, das mit current_let_rule_package eines Regelpaketes als Argument angegeben, werden zusätzlich die Regeln dieses Paketes entfernt.

Soll eine vorhandene Regel durch eine neue Definition ersetzt werden, muss die Regel nicht zuvor mit remlet entfernt werden. Die neue Definition überschreibt eine vorhandene Regel. Wurde eine vorhandene Regel überschrieben und wird die letzte Regel entfernt, dann ist die vorhergehende Regel wieder aktiv.

Siehe auch die Funktion remrule, den Funktionen tellsimp tellsimpafter

Funktion: remrule (op, rulename)
Funktion: remrule (op, all)

Entfernt Regeln, die mit den Funktionen tellsimp tellsimpafter

remrule(op, rulename) entfernt die Regel mit dem Namen rulename vom Operator op. Ist der Operator op ein Maxima-Operator oder ein nutzerdefinierter Operator, der mit Funktionen wie infix prefix op als eine Zeichenkette in Anführungszeichen angegeben werden.

remrule(op, all) entfernt alle Regeln des Operators op.

Siehe auch die Funktion remlet, Funktion let

Beispiele:

(%i1) tellsimp (foo (aa, bb), bb - aa);
(%o1)                   [foorule1, false]
(%i2) tellsimpafter (aa + bb, special_add (aa, bb));
(%o2)                   [+rule1, simplus]
(%i3) infix ("@@");
(%o3)                          @@
(%i4) tellsimp (aa @@ bb, bb/aa);
(%o4)                   [@@rule1, false]
(%i5) tellsimpafter (quux (%pi, %e), %pi - %e);
(%o5)                  [quuxrule1, false]
(%i6) tellsimpafter (quux (%e, %pi), %pi + %e);
(%o6)             [quuxrule2, quuxrule1, false]
(%i7) [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
       quux (%e, %pi)];
                                     bb
(%o7) [bb - aa, special_add(aa, bb), --, %pi - %e, %pi + %e]
                                     aa
(%i8) remrule (foo, foorule1);
(%o8)                          foo
(%i9) remrule ("+", ?\+rule1);
(%o9)                           +
(%i10) remrule ("@@", ?\@\@rule1);
(%o10)                         @@
(%i11) remrule (quux, all);
(%o11)                        quux
(%i12) [foo (aa, bb), aa + bb, aa @@ bb, quux (%pi, %e),
        quux (%e, %pi)];
(%o12) [foo(aa, bb), bb + aa, aa @@ bb, quux(%pi, %e), 
                                         quux(%e, %pi)]

Systemvariable: rules

Standardwert: []

rules ist eine Informationsliste, die die vom Nutzer mit den Funktionen tellsimp, tellsimpafter, defmatch oder defrule definierten Regeln enthält.

Regeln, die mit der Funktion let rules enthalten. Diese Regeln werden in Paketen organisiert, die in der Systemvariablen let_rule_packages letrules

Siehe auch die Systemvariable infolists.

Funktion: tellsimp (pattern, replacement)

tellsimp ist vergleichbar mit der Funktion tellsimpafter, wobei mit tellsimp Regeln für die Vereinfachung von Ausdrücken definiert werden, die noch vor den Regeln angewendet werden, die intern in Maxima bekannt sind.

tellsimp wird daher eingesetzt, wenn Maxima Regeln für die Vereinfachung des Ausdruckes kennt, es jedoch notwendig ist, noch vor Anwendung dieser Regeln den Ausdruck auf eine andere Art zu modifizieren. Für den Fall das Maxima den Ausdruck nicht ausreichend vereinfacht, kann es besser sein, eine Regel mit der Funktion tellsimpafter

Das Argument pattern kann keine Summe, kein Produkt, keine einzelne Variable und keine Zahl sein.

Regeln die mit tellsimp definiert werden, werden in die Informationsliste rules

Beispiele:

(%i1) matchdeclare (x, freeof (%i));
(%o1)                         done
(%i2) %iargs: false$
(%i3) tellsimp (sin(%i*x), %i*sinh(x));
(%o3)                 [sinrule1, simp-%sin]
(%i4) trigexpand (sin (%i*y + x));
(%o4)         sin(x) cos(%i y) + %i cos(x) sinh(y)
(%i5) %iargs:true$
(%i6) errcatch(0^0);
 0
0  has been generated
(%o6)                          []
(%i7) ev (tellsimp (0^0, 1), simp: false);
(%o7)                  [^rule1, simpexpt]
(%i8) 0^0;
(%o8)                           1
(%i9) remrule ("^", %th(2)[1]);
(%o9)                           ^
(%i10) tellsimp (sin(x)^2, 1 - cos(x)^2);
(%o10)                 [^rule2, simpexpt]
(%i11) (1 + sin(x))^2;
                                      2
(%o11)                    (sin(x) + 1)
(%i12) expand (%);
                                   2
(%o12)               2 sin(x) - cos (x) + 2
(%i13) sin(x)^2;
                                  2
(%o13)                     1 - cos (x)
(%i14) kill (rules);
(%o14)                        done
(%i15) matchdeclare (a, true);
(%o15)                        done
(%i16) tellsimp (sin(a)^2, 1 - cos(a)^2);
(%o16)                 [^rule3, simpexpt]
(%i17) sin(y)^2;
                                  2
(%o17)                     1 - cos (y)

Funktion: tellsimpafter (pattern, replacement)

Definiert eine Regel für die Vereinfachung eines Ausdrucks, die nach Anwendung der Regeln angewendet wird, die Maxima intern kennt. pattern ist ein Ausdruck, der Mustervariablen enthält, die mit der Funktion matchdeclare die die wörtliche Übereinstimmung bei einem Musterabgleich angenommen wird. replacement wird in den Ausdruck substituiert, wenn der Musterabgleich das Muster pattern im Ausdruck findet. Den Mustervariablen in replacement werden die Werte des Musterabgleichs zugewiesen.

Das Muster pattern kann ein beliebiger Ausdruck sein, in dem der Hauptoperator keine Mustervariable ist. Die neue Regel wird nach dem Hauptoperator des Musters benannt und diesem zugeordnet. Der Name von Funktionen, mit einer unten beschriebenen Ausnahme, Listen und Arrays können in pattern nicht als eine Mustervariable auftreten. Daher können Ausdrücke wie aa(x) oder bb[y] nicht als Muster verwendet werden, wenn aa oder bb Mustervariablen sind. Die Namen von Funktionen, Listen und Arrays, welche Mustervariablen sind, können dann in dem Muster pattern auftreten, wenn sie nicht der Hauptoperator sind.

Es gibt eine Ausnahme der oben genannten Einschränkung für die Verwendung von Funktionsnamen. Der Name einer indizierten Funktion wie aa[x](y) kann eine Mustervariable sein, da der Hauptoperator nicht aa ist, sondern das interne Symbol mqapply. Dies ist eine Konsequenz der internen Darstellung einer indizierten Funktion.

Regeln für die Vereinfachung werden nach der Auswertung eines Ausdrucks angewendet, sofern die Auswertung, zum Beispiel mit dem Schalter noeval, tellsimpafter definiert sind, werden nach den internen Regeln und in der Reihenfolge angewendet, in der sie definiert sind. Die Regeln für die Vereinfachung werden zunächst für Teilausdrücke und zuletzt für den ganzen Ausdruck angewendet. Es kann notwendig sein, Regeln für die Vereinfachung mehrfach zum Beispiel mit dem Quote-Quote-Operator '' oder dem Auswertungsschalter infeval erreichen, dass alle Regeln angewendet werden.

Mustervariable werden als lokale Variablen in Regeln für die Vereinfachung behandelt. Sobald eine Regel definiert ist, beeinflusst die Zuweisung eines Wertes an die Mustervariable nicht die Regel und die Variable wird nicht von der Regel beeinflusst. Die Zuweisung an eine Mustervariable, die aufgrund eines erfolgreichen Musterabgleichs vorgenommen wird, beeinflusst nicht den aktuellen Wert der Variablen. Jedoch sind die Eigenschaften der Mustervariablen, wie sie zum Beispiel auch mit der Funktion put in Maxima.

Eine mit tellsimpafter definierte Regel wird nach dem Hauptoperator des Musters pattern benannt. Regeln für Maxima-Operatoren und für Funktionen, die mit infix, prefix, postfix, matchfix nofix Lisp-Bezeichner als Namen. Alle anderen Regeln erhalten einen Maxima-Bezeichner als Namen.

tellsimpafter wertet die Argumente nicht aus. tellsimpafter gibt eine Liste der Regeln zurück, die für den Hauptoperator des Musters pattern definiert sind.

Siehe auch die Funktionen matchdeclare, defmatch, defrule, tellsimp, remrule clear_rules.

Beispiele:

Das Muster pattern kann ein beliebiger Ausdruck sein, in dem der Hauptoperator keine Mustervariable ist.

(%i1) matchdeclare (aa, atom, [ll, mm], listp, xx, true)$
(%i2) tellsimpafter (sin (ll), map (sin, ll));
(%o2)                 [sinrule1, simp-%sin]
(%i3) sin ([1/6, 1/4, 1/3, 1/2, 1]*%pi);
                    1  sqrt(2)  sqrt(3)
(%o3)              [-, -------, -------, 1, 0]
                    2     2        2
(%i4) tellsimpafter (ll^mm, map ("^", ll, mm));
(%o4)                  [^rule1, simpexpt]
(%i5) [a, b, c]^[1, 2, 3];
                                2   3
(%o5)                      [a, b , c ]
(%i6) tellsimpafter (foo (aa (xx)), aa (foo (xx)));
(%o6)                   [foorule1, false]
(%i7) foo (bar (u - v));
(%o7)                    bar(foo(u - v))

Regeln werden in der Reihenfolge angewendet, in der sie definiert sind. Treffen zwei Regeln bei einem Musterabgleich zu, wird die zuerst definierte Regel angewendet.

(%i1) matchdeclare (aa, integerp);
(%o1)                         done
(%i2) tellsimpafter (foo (aa), bar_1 (aa));
(%o2)                   [foorule1, false]
(%i3) tellsimpafter (foo (aa), bar_2 (aa));
(%o3)              [foorule2, foorule1, false]
(%i4) foo (42);
(%o4)                       bar_1(42)

Mustervariable werden als lokale Variable beim Musterabgleich der mit der Funktion tellsimpafter definierten Regel behandelt. Im Unterschied dazu werden von Regeln, die mit defmatch globale Variable behandelt.

(%i1) matchdeclare (aa, integerp, bb, atom);
(%o1)                         done
(%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
(%o2)                   [foorule1, false]
(%i3) bb: 12345;
(%o3)                         12345
(%i4) foo (42, %e);
(%o4)                 bar(aa = 42, bb = %e)
(%i5) bb;
(%o5)                         12345

Die Eigenschaften von Mustervariablen sind global, auch wenn die Werte lokal sind. In diesem Beispiel wird eine Eigenschaft für die Zuweisung an eine Variable mit der Funktion define_variable des Symbols bb ist global in Maxima.

(%i1) matchdeclare (aa, integerp, bb, atom);
(%o1)                         done
(%i2) tellsimpafter (foo(aa, bb), bar('aa=aa, 'bb=bb));
(%o2)                   [foorule1, false]
(%i3) foo (42, %e);
(%o3)                 bar(aa = 42, bb = %e)
(%i4) define_variable (bb, true, boolean);
(%o4)                         true
(%i5) foo (42, %e);
Error: bb was declared mode boolean, has value: %e
 -- an error.  Quitting.  To debug this try debugmode(true);

Regeln werden nach dem Hauptoperator benannt. Die Namen der Regeln für Maxima-Funktionen und nutzerdefinierte Operatoren sind Lisp-Bezeichner. Alle anderen Namen sind Maxima-Bezeichner.

(%i1) tellsimpafter (foo (%pi + %e), 3*%pi);
(%o1)                   [foorule1, false]
(%i2) tellsimpafter (foo (%pi * %e), 17*%e);
(%o2)              [foorule2, foorule1, false]
(%i3) tellsimpafter (foo (%i ^ %e), -42*%i);
(%o3)         [foorule3, foorule2, foorule1, false]
(%i4) tellsimpafter (foo (9) + foo (13), quux (22));
(%o4)                   [+rule1, simplus]
(%i5) tellsimpafter (foo (9) * foo (13), blurf (22));
(%o5)                  [*rule1, simptimes]
(%i6) tellsimpafter (foo (9) ^ foo (13), mumble (22));
(%o6)                  [^rule1, simpexpt]
(%i7) rules;
(%o7) [foorule1, foorule2, foorule3, +rule1, *rule1, ^rule1]
(%i8) foorule_name: first (%o1);
(%o8)                       foorule1
(%i9) plusrule_name: first (%o4);
(%o9)                        +rule1
(%i10) remrule (foo, foorule1);
(%o10)                         foo
(%i11) remrule ("^", ?\^rule1);
(%o11)                          ^
(%i12) rules;
(%o12)        [foorule2, foorule3, +rule1, *rule1]

Ein ausgearbeitetes Beispiel der nicht-kommutativen Multiplikation.

(%i1) gt (i, j) := integerp(j) and i < j;
(%o1)           gt(i, j) := integerp(j) and i < j
(%i2) matchdeclare (i, integerp, j, gt(i));
(%o2)                         done
(%i3) tellsimpafter (s[i]^^2, 1);
(%o3)                 [^^rule1, simpncexpt]
(%i4) tellsimpafter (s[i] . s[j], -s[j] . s[i]);
(%o4)                   [.rule1, simpnct]
(%i5) s[1] . (s[1] + s[2]);
(%o5)                    s  . (s  + s )
                          1     2    1
(%i6) expand (%);
(%o6)                      1 - s  . s
                                2    1
(%i7) factor (expand (sum (s[i], i, 0, 9)^^5));
(%o7) 100 (s  + s  + s  + s  + s  + s  + s  + s  + s  + s )
            9    8    7    6    5    4    3    2    1    0

[ << ] [ >> ]           [Top] [Contents] [Index] [ ? ]

This document was generated by Robert Dodier on Oktober, 11 2013 using texi2html 1.76.