[ < ] [ > ]   [ << ] [ 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 und apply2. In der anderen Gruppe sind die Funktionen let und letsimp enthalten. Beide Methoden verwenden Mustervariablen, die mit der Funktion matchdeclare definiert 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, um Einfluss auf die Vereinfachung von 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 oder tellsimpafter eine Regel 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 enthält die größte Verschachtelungstiefe, für die die Funktionen apply1 und apply2 auf einen Ausdruck angewendet werden.

Siehe auch die Funktionen applyb1 und apply2, um Regeln auf einen Ausdruck anzuwenden, die mit der Funktion defrule definiert sind.

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 werden von der Funktion apply2 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 enthält die größte Verschachtelungstiefe, für die die Funktionen apply1 und apply2 auf einen Ausdruck angewendet werden.

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

Beispiele:

Im Unterschied zur Funktion apply1 ist in diesem Fall das Ergebnis 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 mit dem Unterschied, dass die Regeln Bottom-Up angewendet werden.

Die Optionsvariable maxapplyheight enthält den Wert der größten Verschachtelungstiefe, für die applyb1 angewendet wird.

Siehe auch die Funktionen apply1 und apply2, um Regeln auf einen Ausdruck anzuwenden, die mit der Funktion defrule definiert sind.

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 ist mit Hilfe von Regeln implementiert. Die Regeln werden automatisch beim ersten Aufruf der Funktion trigsimp geladen und in die Liste rules eingetragen. Werden die Regeln mit der Funktion 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 und remlet verwendet wird. Der 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 definiert sind. Alle anderen Variablen und Bezeichner 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 definierten Mustervariablen, jedoch nicht den 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 eingetragen.

Siehe auch die Funktionen matchdeclare, defrule, tellsimp und 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 oder applyb1 auf 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 eingetragen.

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 eine 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 auf Ausdrücke angewendet werden, 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 oder tellsimpafter definiert sind, oder ein Muster, das mit der Funktion defmatch definiert ist. Die Regeln werden mit einer Zwischenmarke %t angezeigt.

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, die die Regeln anzeigt, die mit der Funktion let definiert sind.

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 auf einen Ausdruck 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 den Wert true hat.

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 kontrolliert die Vereinfachung von Quotienten 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.

Die Funktion letsimp kann mit verschiedenen Regelpaketen arbeiten. Jedes 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 enthält den Namen des 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 enthält die definierten Regelpakete. Mit der Funktion letrules können alle definierten Regeln 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 definierten Regelpaketen.

Optionsvariable: letrat

Standardwert: false

Hat die Optionsvariable letrat den Wert false, werden von der Funktion letsimp 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.

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 bezeichnet wird. Das Kommando 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, um Regeln anzuzeigen, die mit den Funktionen tellsimp, tellsimpafter und 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 definiert sind, 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 bezeichnet werden.

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 kontrolliert die Vereinfachung von Quotienten 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 ausgewertet, wenn die Regel angewendet wird. Daher ist es nicht 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 und remove.

Mit den Funktionen defmatch, defrule, tellsimp, tellsimpafter und let werden Regeln 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 und printprops geben Informationen über 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 und apply2 auf die Baumstruktur eines Ausdrucks angewendet werden.

Optionsvariable: maxapplyheight

Standardwert: 10000

maxapplyheight ist die maximale Verschachtelungstiefe für die die Funktion applyb1 Bottom-up auf die Baumstruktur eines Ausdrucks 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 definiert wurde. Wird mit dem Argument package_name 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 bezeichnet ist. Wird der Name 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, um Regeln zu entfernen, die mit den Funktionen tellsimp oder tellsimpafter definiert sind.

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

Entfernt Regeln, die mit den Funktionen tellsimp oder tellsimpafter definiert sind.

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 oder prefix definiert wurde, muss der Name des Operators op als eine Zeichenkette in Anführungszeichen angegeben werden.

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

Siehe auch die Funktion remlet, um Regeln zu entfernen, die mit der Funktion let definiert sind.

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 definiert sind, sind nicht in der Liste rules enthalten. Diese Regeln werden in Paketen organisiert, die in der Systemvariablen let_rule_packages aufgelistet und mit der Funktion letrules angezeigt werden.

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 zu definieren.

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

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 definiert sind und weitere Symbole und Operatoren, für 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, nicht unterdrückt wurde. Regeln, die mit 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 anzuwenden, um zu 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 definiert werden können, global 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 und nofix als Operator definiert sind, haben einen 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 und 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 definiert sind, Mustervariable als 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 definiert. Die Eigenschaft 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 Jaime Villate on Oktober, 14 2014 using texi2html 1.76.