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

25. Muster und Regeln


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

25.1 Einführung in Muster und Regeln

Dieses Kapitel beschreibt die nutzerdefinierte Mustererkennung und Vereinfachungsregeln. Es gibt zwei verschiedene Gruppen an Funktionen, die eine etwas unterschiedliche Mustererkennung 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 Mustererkennungsverfahren verwenden die Funktion matchdeclare, um Muster zu definieren.

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

Es gibt zusätzliche Mechanismen wie tellrat, um Regeln auf Polynome anzuwenden und weitere Funktionen der kommutativen und nicht-kommutativen Algebra in dem affine -Paket.


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

25.2 Funktionen und Variablen für Muster und Regeln

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

Wendet die Regel rule_1 auf den Ausdruck expr solange an, bis die Anwendung fehlschlägt. Dann wird die Regel von links nach rechts auf alle Teilausdrücke von expr angewendet. Ist expr_2 das Ergebnis, dann wird die Regel rule_2 auf gleiche Weise auf den Ausdruck expr_2 angewendet. Zuletzt wird die Regel rule_n angewendet. Das letzte Ergebnis wird zurückgegeben.

Die Optionsvariable maxapplydepth ist die größte Verschachtelungstiefe für die die Funktionen apply1 und apply2 auf einen Ausdruck angewendet werden.

Siehe auch applyb1, apply2 und let.

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)

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

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

Die Optionsvariable maxapplydepth ist die größte Verschachtelungstiefe für die die Funktionen apply1 und apply2 auf einen Ausdruck angewendet werden.

Siehe auch apply1, applyb1 und let.

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) apply2(cot(x), trig1, trig2);
                             cos(x)
(%o3)                        ------
                             sin(x)
(%i4) apply2(cot(x), trig2, trig1);
                             cos(x)
(%o4)                        ------
                             sin(x)

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

Wendet wiederholt die Regel rule_1 auf den tiefsten Teilausdruck an. Schlägt die Anwendung fehlt, 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 Bottum-Up angewendet werden.

maxapplyheight ist die größte Verschachtelungstiefe für die applyb1 angewendet wird.

Siehe auch apply1, apply2 und let.

Funktion: clear_rules ()

Führt das Kommando kill(rules) aus und setzt den Zähler für die Benennung der Regeln der Addition, der Multiplikation und der Exponentiation zurück. Siehe auch kill.

Optionsvariable: current_let_rule_package

Standardwert: default_let_rule_package

current_let_rule_package enthält den Namen des Regel-Paketes, das von den let-Funktionen verwendet wird. Der Optionsvariablen kann jedes mit dem Kommando 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.

Optionsvariable: default_let_rule_package

Standardwert: default_let_rule_package

default_let_rule_package ist der Name des Regelpaketes, das verwendet wird, wenn kein Regelpaket mit der Funktion let explizit definiert wurde.

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

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

pattern ist ein Ausdruck, der die Musterargumente x_1, …, x_n enthält, sowie weitere Mustervariablen enthalten kann, die mit der Funktion matchdeclare deklariert sind. Alle Variable, die nicht als Musterargumente der Funktion defmatch oder als Mustervariable mit matchdeclare definiert sind, entsprechen sich selbst.

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

Ist der Test erfolgreich, gibt die Aussagefunktion progname eine Liste mit Gleichungen zurück. Die linke Seite der Gleichungen sind die Musterargumente und Mustervariablen und die rechte Seite sind die Teilausdrücke für die eine Übereinstimmung gefunden wurde. Den Mustervariablen, jedoch nicht den Musterargumenten, werden die Ergebnisse zugewiesen. Ist der Test nicht erfolgreich, ist die Rückgabe false.

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

Siehe auch matchdeclare, defrule, tellsimp und tellsimpafter.

Beispiele:

Definiere eine Funktion linearp(expr, x), die testet, 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.

(%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 oben wird eine Testfunktion definiert, die prüft ob ein Ausdruck expr linear ist. In diesem Fall wird kein Musterargument angegeben. Der Test 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]

Definiere eine Testfunktion 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 Regeln, um das Muster pattern durch den Ausdruck replacement zu ersetzen. Wird die Regeln mit dem Namen rulename mit den Funktionen apply1, apply2 oder applyb1 auf einen Ausdruck angewendet, wird alle Teilausdrücke, die dem Muster pattern entsprechen durch den Ausdruck replacement ersetzt.

Die Regel rulename kann auch als eine Funktion angewendet werden, die, falls vorhanden, das Muster pattern durch replacement ersetzt.

Beispiele:

Es wird eine Regel definiert, um den Ausdruck sin(x)^2 nach 1-cos(x)^2 transformiert. Diese Definition funktioniert nur für einen Ausdruck sin(x)^2.

(%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 Fall wird zunächst mit der Funktion matchdeclare eine Mustervariable a definiert, der jeder Ausdruck zugewiesen werden kann und die als Argument der Ersetzungsregel 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 Ersetzungsregel kann mit der Funktion apply1 auf verschachtelte Ausdrücke angewendet 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_2)
Funktion: disprule (all)

Zeigt die Regeln mit den Namen rulename_1, …, rulename_n an. Den einzelnen Regeln werden mit einer Zwischenmarke %t angezeigt.

Mit dem Kommando disprule(all) werden alle Regeln angezeigt.

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

Sieh auch die Funktion letrules, die die Regeln ausgibt, die mit der Funktion let definiert wurden.

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, predname, arg_1, …, arg_n)
Funktion: let ([prod, repl, predname, arg_1, …, arg_n], package_name)

Definiert eine Ersetzungsregel, die mit der Funktion letsimp auf einen Ausdruck angewendet wird, 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 muss weiterhin die Optionsvariable letrat den Wert true haben.

Hat die Funktion let eine Aussagefunktion predname als Argument, mit dem Argumenten arg_1, …, arg_n, wird eine vorläufige Übereinstimmung dann festgestellt wenn der Ausdruck predname(arg_1', ..., arg_n') das Ergebnis true hat. 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 false, 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 let-Regeln enthalten und erhält vom Nutzer einen Namen. Das Kommando let([prod, repl, predname, arg_1, ..., arg_n], package_name) fügt die Regel predname dem Paket package_name hinzu. Das Kommando letsimp(expr, package_name1, package_name2, ...) ist äquivalent zu letsimp(expr, package_name1), dem das Kommando letsimp(%, package_name2), … folgt.

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.

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: letrat

Standardwert: false

Hat die Optionsvariable 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 false, 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 Regel-Paketes an. Das Kommando letrules() zeigt die Regeln des aktuellen Regel-Paketes an, das in der Optionsvariablen current_let_rule_package enthalten ist. Das Kommando letrules(package_name) zeigt die Regeln des Paketes package_name an.

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

Siehe auch die Funktion disprule, um Regeln anzuzeigen, die mit 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 Substitutionsregeln, die mit der Funktion let definiert sind, solange an, bis sich das Argument expr nicht mehr ändert. letsimp(expr) wendet die Regeln der Optionsvariablen current_let_rule_package an.

letsimp(expr), package_name) wendet die Regeln des Argumentes package_name an. Die Optionsvariable current_let_rule_package ändert ihren Wert nicht.

letsimp(expr, package_name_1, ..., package_name_n) ist äquivalent zum Kommando letsimp(expr, package_name_1) dem letsimp(%, package_name_2) folgt u.s.w.

Optionsvariable: let_rule_packages

Standardwert: [default_let_rule_package]

let_rule_packages ist eine Informationsliste mit den vom Nutzer definierten let-Regeln.

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

Assoziiert eine Aussage pred_k mit einer Variable oder eine Liste von Variablen a_k, so dass a_k mit Ausdrücken übereinstimmt, für die die Aussage ein anderes Ergebnis als false zurück gibt.

Eine Aussage ist der Name einer Funktion, ein Lambda-Ausdruck, ein Funktionsaufruf, ein Lambda-Ausdruck, dem das letzte Argument fehlt, oder die Werte true oder all. Ist die Aussage ein Funktionsaufruf oder ein Lambda-Aufruf, dann wird der zu testende Ausdruck an die Liste der Argumente angefügt. Die Argumente werden ausgewertet, wenn die Übereinstimmung ausgewertet wird. Ist die Aussage der Name einer Funktion oder ein Lambda-Ausdruck, ist die zu testende Aussage das einzige Argument. Eine Aussagefunktion braucht nicht definiert zu sein, wenn matchdeclare aufgerufen wird. Die Aussage wird nicht eher ausgewertet, bevor eine Übereinstimmung getestet wird.

Eine Aussage kann einen logischen Ausdruck oder die Werte true oder false zurück geben. Logische Ausdrücke werden von is von der definierten Regel ausgewertet. Daher ist es nicht notwendig, dass die Aussage selbst die Funktion is aufruft.

Wenn für ein Ausdruck eine Übereinstimmung 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 andere Funktionen behandelt.

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. Die mehrfache Übereinstimmung ist vorrangig: Aussagen werden in der Reihenfolge ausgewertet, in der die Mustervariablen im Musterausdruck auftreten. Stimmt ein Termin mit mehreren Aussagen überein, wird der Term der ersten Aussage zugeordnet, die zutrifft. Jede Aussage wird zunächst auf alle Argumente einer Summe oder eines Produktes angewendet, bevor die nächste Aussage 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 mit der Addition und Multiplikation zu verarbeiten, ist für manche Übereinstimmungen abhängig von der Anordnung der Terme im Muster und im Ausdruck für den eine Übereinstimmung gesucht wird. Solange sich jedoch die einzelnen Muster gegeneinander ausschließen, wird das Ergebnis nicht von der Reihenfolge der Argumente beeinflußt.

Der Aufruf von matchdeclare für eine Variable a überschreibt einen vorhergehenden Aufruf von matchdeclare für diese Variable. Nur die letzte Definition ist wirksam, wenn eine Regel definiert wird. Spätere Änderungen der matchdeclare-Eigenschaft eines Symbols haben keinen Einfluss auf definierte Regeln.

Das Kommando propvars(matchdeclare) gibt eine Liste der Variablen zurück, für die eine matchdeclare-Eigenschaft definiert ist. printprops(a, matchdeclare) gibt die der Variable zugeordnete Aussage zurück. printprops(all, matchdeclare) gibt die Aussagen aller Variablen mit einer matchdeclare-Eigenschaft zurück. remove(a, matchdeclare) entfernt die matchdeclare-Eigenschaft für die Variable a.

Die Funktion defmatch, defrule, tellsimp, tellsimpafter und let konstruieren Regeln, die Ausdrücke gegen Muster testen.

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

Beispiele:

Eine Aussage ist der Name einer Funktion, ein Lambda-Ausdruck, ein Funktionsaufruf, ein Lambda-Ausdruck, dem das letzte Argument fehlt, oder die Werte true oder all.

(%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

Stimmt ein Ausdruck mit einer Musteraussage überein, wird der Ausdruck der Mustervariable 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 Aussagen 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.

(%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 Tiefe für die die Funktionen apply1 und apply2 rekursiv auf einen Ausdruck angewendet werden.

Optionsvariable: maxapplyheight

Standardwert: 10000

maxapplyheight ist die maximale Größe die applyb1 erreichen kann, bevor die Funktion aufgibt.

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

Entfernt die Ersetzungsregel prod -> repl die zuletzt mit der Funktion let definiert wurde. Wird mit dem Argument package_name ein Paket angegeben, wird die Regeln aus dem Paket entsprechenden Paket entfernt.

remlet() und remlet(all) entfernen alle Ersetzungsregeln aus dem aktuellen Paket, das in current_let_rule_package enthalten ist. Wird ein Regelpaket als Argument angegeben, werden zusätzlich die Regeln dieses Paketes entfernt.

Soll eine vorhandene Ersetzungsregel durch eine neue Definition ersetzt werden, muss die Regel zuvor nicht mit remlet entfernt werden. Die neue Definition überschreibt eine vorhandene Regel.

Siehe auch remrule, um Regeln zu entfernen, die mit tellsimp oder tellsimpafter definiert sind.

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

Entfernt Regeln die mit den Funktionen tellsimp oder tellsimpafter. definiert wurden.

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 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: []

Enthält die vom Nutzer mit den Funktionen tellsimp, tellsimpafter, defmatch oder defrule definierten Regeln. Siehe auch infolists.

Funktion: tellsimp (pattern, replacement)

tellsimp ist vergleichbar mit der Funktion tellsimpafter, wobei tellsimp die Vereinfachungsregel vor der Anwendung der eingebauten Vereinfachungen ausgeführt wird.

tellsimp wird 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 Vereinfachungsregel mit tellsimpafter zu definieren.

Das Argument pattern kann keine Summe, Produkte, eine einzelne Variable oder eine Zahl sein.

rules ist eine Informationsliste, die alle Regeln enthält die mit den tellsimpafter, defrule, defmatch und tellsimp definiert sind.

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 Vereinfachungsregel, die nach Anwendung der eingebauten Regeln angewendet wird. pattern ist ein Ausdruck, der Mustervariablen enthält, die mit der Funktion matchdeclare definiert werden und weitere Symbole und Operatoren, für die die wörtliche Übereinstimmung in einem Ausdruck angenommen wird. replacement wird in den Ausdruck substituiert, wenn pattern im Ausdruck gefunden wird. Mustervariablen in replacement werden die Werte des geprüften Ausdrucks zugewiesen.

Das Argument pattern kann ein beliebiger Ausdruck sein, in dem der Hauptoperator keine Mustervariable ist. Die Vereinfachungsregel wird mit dem Hauptoperator assoziiert. Der Name von Funktionen, mit einer unten beschriebenen Ausnahme, Listen und Arrays können in pattern nur als eine wörtliche Übereinstimmung und nicht in Mustervariablen 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 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 Lisp-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 vorhandenen Maxima-Regeln und in der Reihenfolge angewendet werden, 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 Schalter infeval anzuwenden, um sicher zu gehen, dass alle Regeln angewendet werden.

Mustervariable werden als lokale Variablen in Vereinfachungsregeln 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 einer erfolgreichen Übereinstimmung des Musters mit einem Ausdruck 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.

Die mit tellsimpafter definierte Regel wird nach dem Hauptoperator des Argumentes pattern benannt. Regeln der Maxima-Operatoren und mit den Funktionen infix, prefix, postfix, matchfix und nofix definierte Operatoren haben einen Lisp-Bezeichner als Namen. Alle anderen Regeln haben Maxima-Bezeichner als Namen.

tellsimpafter werden die Argumente nicht aus. tellsimpafter gibt eine Liste der Regeln des Hauptoperators des Argumentes pattern einschließlich der neu definierten Regeln zurück.

Siehe auch matchdeclare, defmatch, defrule, tellsimp, kill, remrule und clear_rules.

Beispiele:

Das Muster pattern kann ein beliebiger Ausdruck sein, in dem der Hauptoperator nicht die 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 wurden. Können zwei Regeln mit einem Ausdruck übereinstimmen, 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 in Vereinfachungsregeln behandelt. Im Unterschied dazu behandelt defmatch Mustervariable als globale Variable.

(%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 nutzerdefinierten 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 April, 4 2011 using texi2html 1.76.