[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
24.1 Einführung in Muster und Regeln | ||
24.2 Funktionen und Variablen für Muster und Regeln |
[ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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] | [ ? ] |
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)
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)
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.
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
.
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.
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.
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)]
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
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) -> []]
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:
letsimp
wörtlich sucht, wenn kein Muster
mit der Funktion matchdeclare
definiert wurde, sowie Atome, denen mit der
Funktion matchdeclare
eine Aussagefunktion zugeordnet wurde.
sin(x)
, n!
oder f(x,y)
. Wie für Atome
sucht die Funktion letsimp
nach wörtlichen Übereinstimmungen, sowie
nach Übereinstimmungen, die mit der Funktion matchdeclare
für einen
Ausdruck definiert wurde.
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
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)!
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
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.
Standardwert: [default_let_rule_package]
let_rule_packages
ist eine Informationsliste mit den vom Nutzer
definierten let
-Regeln.
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)]
Standardwert: 10000
maxapplydepth
ist die maximale Tiefe für die die Funktionen
apply1
und apply2
rekursiv auf einen Ausdruck angewendet werden.
Standardwert: 10000
maxapplyheight
ist die maximale Größe die applyb1
erreichen
kann, bevor die Funktion aufgibt.
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.
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)]
Standardwert: []
Enthält die vom Nutzer mit den Funktionen tellsimp
,
tellsimpafter
, defmatch
oder defrule
definierten Regeln.
Siehe auch infolists
.
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)
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 August, 1 2011 using texi2html 1.76.