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

9. Vereinfachung


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

9.1 Einführung in die Vereinfachung

Nach der Auswertung einer Eingabe, die in Auswertung beschrieben ist, schließt sich die Vereinfachung eines Ausdrucks an. Mathematische Funktionen mit denen symbolisch gerechnet werden kann, werden nicht ausgewertet, sondern vereinfacht. Mathematische Funktionen werden intern von Maxima in einer Substantivform dargestellt. Auch Ausdrücke mit den arithmetischen Operatoren werden vereinfacht. Numerische Rechnungen wie die Addition oder Multiplikation sind daher keine Auswertung, sondern eine Vereinfachung. Die Auswertung eines Ausdrucks kann mit dem Quote-Operator ' unterdrückt werden. Entsprechend kann die Vereinfachung eines Ausdrucks mit der Optionsvariablen simp kontrolliert werden.

Beispiele:

Im ersten Beispiel wird die Auswertung mit dem Quote-Operator unterdrückt. Das Ergebnis ist eine Substantivform für die Ableitung. Im zweiten Beispiel ist die Vereinfachung unterdrückt. Die Ableitung wird ausgeführt, da es sich um eine Auswertung handelt. Das Ergebnis wird jedoch nicht zu 2*x vereinfacht.

(%i1) 'diff(x*x,x);
                             d    2
(%o1)                        -- (x )
                             dx
(%i2) simp:false;
(%o2)                         false
(%i3) diff(x*x,x);
(%o3)                       1 x + 1 x

Für jede mathematischen Funktion oder Operator hat Maxima intern eine eigene Routine, die für die Vereinfachung aufgerufen wird, sobald die Funktion oder der Operator in einem Ausdruck auftritt. Diese Routinen implementieren Symmetrieeigenschaften, spezielle Funktionswerte oder andere Eigenschaften und Regeln. Mit einer Vielzahl von Optionsvariablen kann Einfluss auf die Vereinfachung der Funktionen und Operatoren genommen werden.

Beispiel:

Die Vereinfachung der Exponentialfunktion exp wird von den folgenden Optionsvariablen kontrolliert: %enumer, %emode, %e_to_numlog, radexpand, logsimp, und demoivre. Im ersten Beispiel wird der Ausdruck mit der Exponentialfunktion nicht vereinfacht. Im zweiten Beispiel vereinfacht Maxima ein Argument %i*%pi/2.

(%i1) exp(x+%i*%pi/2), %emode:false;
                                %i %pi
                            x + ------
                                  2
(%o1)                     %e
(%i2) exp(x+%i*%pi/2), %emode:true;
                                  x
(%o2)                        %i %e

Zusätzlich zu der Vereinfachung von einzelnen mathematischen Funktionen und Operatoren, die automatisch von Maxima ausgeführt werden, kennt Maxima Funktionen wie expand oder radcan, die auf Ausdrücke angewendet werden, um spezielle Vereinfachungen vorzunehmen.

Beispiel:

(%i1) (log(x+x^2)-log(x))^a/log(1+x)^(a/2);
                           2               a
                     (log(x  + x) - log(x))
(%o1)                -----------------------
                                    a/2
                          log(x + 1)
(%i2) radcan(%);
                                    a/2
(%o2)                     log(x + 1)

Einem Operator oder einer Funktion können Eigenschaften wie linear oder symmetrisch gegeben werden. Maxima berücksichtigt diese Eigenschaften bei der Vereinfachung eines Ausdrucks. Zum Beispiel wird mit dem Kommando declare(f, oddfun) eine Funktion als ungerade definiert. Maxima vereinfacht dann jedes Auftreten eines Ausdrucks f(-x) zu -f(x). Entsprechend vereinfacht Maxima f(-x) zu f(x), wenn die Funktion als gerade definiert wurde.

Die folgenden Eigenschaften sind in der Liste opproperties enthalten und kontrollieren die Vereinfachung von Funktionen und Operatoren:

   additive        lassociative     oddfun
   antisymmetric   linear           outative
   commutative     multiplicative   rassociative
   evenfun         nary             symmetric

Darüber hinaus haben auch die Fakten und die Eigenschaften des aktuellen Kontextes Einfluss auf die Vereinfachung von Ausdrücken. Siehe dazu die Ausführungen in Maximas Datenbank.

Beispiel:

Die Sinusfunktion vereinfacht für ein ganzzahliges Vielfaches von %pi zum Wert 0. Erhält das Symbol n die Eigenschaft integer, wird die Sinusfunktion entsprechend vereinfacht.

(%i1) sin(n*%pi);
(%o1)                      sin(%pi n)
(%i2) declare(n, integer);
(%o2)                         done
(%i3) sin(n*%pi);
(%o3)                           0

Führen alle oben genannten Möglichkeiten nicht zu dem gewünschten Ergebnis, kann der Nutzer Maxima um weitere Regeln für die Vereinfachung erweitern. Diese Möglichkeiten werden in Muster und Regeln erläutert.


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

9.2 Funktionen und Variablen für die Vereinfachung

Eigenschaft: additive

declare(f, additive) deklariert eine Funktion f als additiv. Hat die Funktion f ein Argument, dann wird f(x + y) zu f(x) + f(y) vereinfacht.

Ist f eine Funktion mit zwei oder mehr Argumenten, ist die Additivität für das erste Argument definiert. Zum Beispiel wird f(x + y,a + b) zu f(y, b + a) + f(x, b + a) vereinfacht.

Siehe die Funktion declare.

Beispiel:

(%i1) F3 (a + b + c);
(%o1)                     F3(c + b + a)
(%i2) declare (F3, additive);
(%o2)                         done
(%i3) F3 (a + b + c);
(%o3)                 F3(c) + F3(b) + F3(a)

Eigenschaft: antisymmetric

declare(f, antisymmetric) deklariert die Funktion f als antisymmetrisch. Zum Beispiel wird f(y, x) zu - f(x, y) vereinfacht.

Siehe auch die Eigenschaft symmetric und die Funktion declare.

Beispiel:

(%i1) S (b, a);
(%o1)                        S(b, a)
(%i2) declare (T, antisymmetric);
(%o2)                         done
(%i3) T (b, a);
(%o3)                       - T(a, b)
(%i4) T (a, c, e, d, b);
(%o4)                   T(a, b, c, d, e)

Funktion: combine (expr)

Terme einer rationalen Funktion, die denselben Nenner haben, werden zusammengefasst.

Beispiel:

(%i1) x^2/(1+x)+2*x/(1+x);
                            2
                           x       2 x
(%o1)                     ----- + -----
                          x + 1   x + 1
(%i2) combine(%);
                             2
                            x  + 2 x
(%o2)                       --------
                             x + 1

Eigenschaft: commutative

declare(f, commutative) deklariert die Funktion f als kommutativ. Zum Beispiel wird f(x, z, y) zu f(x, y, z) vereinfacht. Dies hat denselben Effekt wie die Deklaration symmetric.

Siehe auch die Funktion declare.

Funktion: demoivre (expr)
Optionsvariable: demoivre

Die Funktion demoivre(expr) konvertiert den Ausdruck expr, ohne die Optionsvariable demoivre zu setzen.

Hat die Optionsvariable demoivre den Wert true, werden komplexe Exponentialfunktionen in äquivalente Kreisfunktionen umgewandelt. exp(a + b*%i) wird zu %e^a*(cos(b)+%i*sin(b)) vereinfacht, wenn b frei von der imaginären Einheit %i ist. a und b werden nicht expandiert.

Der Standardwert von demoivre ist false.

Siehe auch die Funktion exponentialize, um trigonometrische und hyperbolische Funktionen in eine Exponentialform zu konvertieren. demoivre und exponentialize können nicht gleichzeitig den Wert true haben.

Funktion: distrib (expr)

Summen werden ausmultipliziert. Im Unterschied zu der Funktion expand wird distrib nur auf der obersten Ebene eines Ausdruckes angewendet und ist daher schneller als expand. Im Unterschied zu der Funktion multthru werden die Summen der obersten Ebenen vollständig ausmultipliziert.

Beispiele:

(%i1) distrib ((a+b) * (c+d));
(%o1)                 b d + a d + b c + a c
(%i2) multthru ((a+b) * (c+d));
(%o2)                 (b + a) d + (b + a) c
(%i3) distrib (1/((a+b) * (c+d)));
                                1
(%o3)                    ---------------
                         (b + a) (d + c)
(%i4) expand (1/((a+b) * (c+d)), 1, 0);
                                1
(%o4)                 ---------------------
                      b d + a d + b c + a c

Optionsvariable: distribute_over

Standardwert: true

Die Optionsvariable distribute_over kontrolliert die Anwendung von Funktionen auf Listen, Matrizen oder Gleichungen. Diese Eigenschaft wird nicht angewendet, wenn distribute_over den Wert false hat.

Beispiele:

Die Funktion sin wird auf eine Liste angewendet.

(%i1) sin([x,1,1.0]);
(%o1)                 [sin(x), sin(1), .8414709848078965]

Die Funktion mod hat zwei Argumente, die auf Listen angewendet werden kann. Die Funktion kann auch auf verschachtelte Listen angewendet werden.

(%i2) mod([x,11,2*a],10);
(%o2)                    [mod(x, 10), 1, 2 mod(a, 5)]
(%i3) mod([[x,y,z],11,2*a],10);
(%o3)       [[mod(x, 10), mod(y, 10), mod(z, 10)], 1, 2 mod(a, 5)]

Anwendung der Funktion floor auf eine Matrix und eine Gleichung.

(%i4) floor(matrix([a,b],[c,d]));
                            [ floor(a)  floor(b) ]
(%o4)                       [                    ]
                            [ floor(c)  floor(d) ]
(%i5) floor(a=b);
(%o5)                         floor(a) = floor(b)

Funktionen mit mehreren Argumenten können auf Listen für eines der Argumente oder alle Argumente angewendet werden.

(%i6) expintegral_e([1,2],[x,y]);
(%o6) [[expintegral_e(1, x), expintegral_e(1, y)], 
       [expintegral_e(2, x), expintegral_e(2, y)]]

Optionsvariable: domain

Standardwert: real

Hat domain den Wert complex, wird sqrt(x^2) nicht zu abs(x) vereinfacht.

Eigenschaft: evenfun
Eigenschaft: oddfun

Erhält eine Funktion oder ein Operator mit der Funktion declare die Eigenschaft evenfun oder oddfun wird die Funktion oder der Operator von Maxima als gerade und ungerade interpretiert. Diese Eigenschaft wird bei der Vereinfachung von Ausdrücken von Maxima angewendet.

Beispiele:

(%i1) o (- x) + o (x);
(%o1)                     o(x) + o(- x)
(%i2) declare (o, oddfun);
(%o2)                         done
(%i3) o (- x) + o (x);
(%o3)                           0
(%i4) e (- x) - e (x);
(%o4)                     e(- x) - e(x)
(%i5) declare (e, evenfun);
(%o5)                         done
(%i6) e (- x) - e (x);
(%o6)                           0

Funktion: expand (expr)
Funktion: expand (expr, p, n)

Expandiert den Ausdruck expr. Produkte von Summen und Potenzen von Summen werden ausmultipliziert. Die Nenner von rationalen Ausdrücken, die Summen sind, werden in ihre Terme aufgespalten. Produkte (kommutative und nicht-kommutative) werden in Summen herein multipliziert.

Für Polynome ist es besser, die Funktion ratexpand zu verwenden, welche für diesen Fall einen effizienteren Algorithmus hat.

maxnegex und maxposex kontrollieren den maximalen negativen und positiven Exponenten, für die ein Ausdruck expandiert wird.

expand(expr, p, n) expandiert expr, wobei maxposex den Wert p und maxnegex den Wert n erhalten.

expon ist der größte negative Exponent, für den ein Ausdruck automatisch expandiert wird. Hat zum Beispiel expon den Wert 4, wird (x+1)^(-5) nicht automatisch expandiert.

expop ist der größte positive Exponent, für den ein Ausdruck automatisch expandiert wird. So wird (x+1)^3 dann automatisch expandiert, wenn expop größer oder gleich 3 ist. Soll (x+1)^n mit der Funktion expand expandiert werden, weil n größer als expop ist, dann ist dies nur möglich, wenn n kleiner als maxposex ist.

expand(expr,0,0) bewirkt eine erneuerte vollständige Vereinfachung des Ausdrucks expr. Der Ausdruck wird nicht erneuert ausgewertet. Im Unterschied zum Kommando ev(expr, noeval) wird eine spezielle Darstellung (zum Beispiel eine CRE-Form) nicht entfernt. Siehe auch ev.

Das expand-Flag wird mit ev verwendet, um einen Ausdruck zu expandieren.

Die Datei `simplification/facexp.mac' enthält weitere Funktionen wie facsum, factorfacsum und collectterms und Variablen wie nextlayerfactor und facsum_combine , um Ausdrücke zu vereinfachen. Diese Funktionen werden automatisch geladen und erlauben spezielle Expansionen von Ausdrücken. Eine kurze Beschreibung ist in der Datei `simplification/facexp.usg' enthalten. Eine Demo kann mit demo(facexp) ausgeführt werden.

Beispiele:

(%i1) expr:(x+1)^2*(y+1)^3;
                               2        3
(%o1)                   (x + 1)  (y + 1)
(%i2) expand(expr);
       2  3        3    3      2  2        2      2      2
(%o2) x  y  + 2 x y  + y  + 3 x  y  + 6 x y  + 3 y  + 3 x  y
                                                      2
                                     + 6 x y + 3 y + x  + 2 x + 1
(%i3) expand(expr,2);
               2        3              3          3
(%o3)         x  (y + 1)  + 2 x (y + 1)  + (y + 1)
(%i4) expr:(x+1)^-2*(y+1)^3;
                                   3
                            (y + 1)
(%o4)                       --------
                                   2
                            (x + 1)
(%i5) expand(expr);
            3               2
           y             3 y            3 y             1
(%o5) ------------ + ------------ + ------------ + ------------
       2              2              2              2
      x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1   x  + 2 x + 1
(%i6) expand(expr, 2, 2);
                                   3
                            (y + 1)
(%o6)                     ------------
                           2
                          x  + 2 x + 1

Vereinfache einen Ausdruck erneut:

(%i7) expr:(1+x)^2*sin(x);
                                2
(%o7)                    (x + 1)  sin(x)
(%i8) exponentialize:true;
(%o8)                         true
(%i9) expand(expr, 0, 0);
                            2    %i x     - %i x
                  %i (x + 1)  (%e     - %e      )
(%o9)           - -------------------------------
                                 2

Funktion: expandwrt (expr, x_1, …, x_n)

Expandiert den Ausdruck expr in Bezug auf die Variablen x_1, …, x_n. Alle Produkte, die die Variablen enthalten, werden ausmultipliziert. Das Ergebnis ist frei von Produkten von Summen, die nicht frei von den Variablen sind. x_1, …, x_n können Variable, Operatoren oder Ausdrücke sein.

Standardmäßig wird der Nenner eines rationalen Ausdrucks nicht expandiert. Dies kann mit der Optionsvariablen expandwrt_denom kontrolliert werden.

Die Funktion wird automatisch aus der Datei `simplification/stopex.mac' geladen.

Optionsvariable: expandwrt_denom

Standardwert: false

expandwrt_denom kontrolliert die Behandlung von rationalen Ausdrücken durch die Funktion expandwrt. Ist der Wert true, werden der Zähler und der Nenner eines rationalen Ausdrucks expandiert. Ist der Wert false, wird allein der Zähler expandiert.

Funktion: expandwrt_factored (expr, x_1, …, x_n)

Ist vergleichbar mit der Funktion expandwrt , behandelt aber Ausdrücke verschieden, die Produkte enthalten. expandwrt_factored expandiert nur die Faktoren im Ausdruck expr, die die Variablen x_1, …, x_n enthalten.

Optionsvariable: expon

Standardwert: 0

expon ist der größte negative Exponent für den ein Ausdruck automatisch expandiert wird. Hat zum Beispiel expon den Wert 4, wird (x+1)^(-5) nicht automatisch expandiert. Siehe auch expop.

Funktion: exponentialize (expr)
Optionsvariable: exponentialize

Die Funktion exponentialize konvertiert trigonometrische und hyperbolische Funktion die in dem Ausdruck expr auftreten in Exponentialfunktionen, ohne dass die Optionsvariable exponentialize gesetzt wird.

Hat die Optionsvariable exponentialize den Wert true, werden trigonometrische und hyperbolischen Funktionen in eine Exponentialform konvertiert. Der Standardwert ist false.

demoivre konvertiert komplexe Exponentialfunktionen in trigonometrische und hyperbolische Funktionen. exponentialize und demoivre können nicht gleichzeitig den Wert true haben.

Optionsvariable: expop

Standardwert: 0

expop ist der größte positive Exponent, für den ein Ausdruck automatisch expandiert wird. So wird (x+1)^3 dann automatisch expandiert, wenn expop größer oder gleich 3 ist. Soll (x+1)^n mit der Funktion expand expandiert werden, weil n größer als expop ist, dann ist dies nur möglich, wenn n kleiner als maxposex ist. Siehe auch expon.

Eigenschaft: lassociative

declare(f, lassociative) deklariert f als eine links-assoziative Funktion. Zum Beispiel wird f (f (a,b), f (c, d)) zu f (f (f (a, b), c), d) vereinfacht.

Siehe auch die Eigenschaft rassociative und die Funktion declare.

Eigenschaft: linear

declare(f, linear) deklariert die Funktion f als linear.

Hat die Funktion f ein Argument, dann wird f(x + y) zu f(x) + f(y) und f(a*x) zu a*f(x) vereinfacht.

Ist f eine Funktion mit zwei oder mehr Argumenten, ist die Linearität für das erste Argument definiert. Zum Beispiel wird f(a*x + b, x) zu a f(x, x) + f(1, x) b vereinfacht.

linear ist äquivalent zu additive und outative. Siehe auch opproperties und die Funktion declare.

Beispiel:

(%i1) 'sum (F(k) + G(k), k, 1, inf);
                       inf
                       ====
                       \
(%o1)                   >    (G(k) + F(k))
                       /
                       ====
                       k = 1
(%i2) declare (nounify (sum), linear);
(%o2)                         done
(%i3) 'sum (F(k) + G(k), k, 1, inf);
                     inf          inf
                     ====         ====
                     \            \
(%o3)                 >    G(k) +  >    F(k)
                     /            /
                     ====         ====
                     k = 1        k = 1

Optionsvariable: maxnegex

Standardwert: 1000

maxnegex ist der größte negative Exponent, der von der Funktion expand exandieren wird. Siehe auch maxposex.

Optionsvariable: maxposex

Standardwert: 1000

maxposex ist der größte positive Exponent, der von der Funktion expand expandiert wird. Siehe auch maxnegex.

Eigenschaft: multiplicative

declare(f, multiplicative) deklariert die Funktion f als multiplikativ.

Hat die Funktion f ein Argument, dann wird f(x*y) zu f(x)*f(y) vereinfacht.

Ist f eine Funktion mit zwei oder mehr Argumenten, ist die Multiplikativität für das erste Argument definiert. Zum Beispiel wird f(a*x + b, x) zu f(g(x), x)*f(h(x), x) vereinfacht.

Diese Vereinfachung werden nicht für Ausdrücke der Form product(x[i], i, m, n) ausgeführt.

Siehe auch die Funktion declare.

Beispiel:

(%i1) F2 (a * b * c);
(%o1)                       F2(a b c)
(%i2) declare (F2, multiplicative);
(%o2)                         done
(%i3) F2 (a * b * c);
(%o3)                   F2(a) F2(b) F2(c)

Funktion: multthru (expr)
Funktion: multthru (expr_1, expr_2)

Multipliziert einen oder mehrere Faktoren in eine Summe herein. multthru expandiert keine Potenzen von Summen. multthru ist die effizienteste Methode, um Produkte von Summen auszumultiplizieren. Da Maxima intern die Division als ein Produkt darstellt, kann multthru auch angewendet werden, um einen Nenner in eine Summe hereinzumultiplizieren.

multthru(expr_1, expr_2) multipliziert jeden Term des Ausdrucks expr_2 mit expr_1. Der Ausdruck expr_2 kann dabei eine Summe oder eine Gleichung sein.

Siehe auch die Funktionen expand und function_distrib.

(%i1) x/(x-y)^2 - 1/(x-y) - f(x)/(x-y)^3;
                      1        x         f(x)
(%o1)             - ----- + -------- - --------
                    x - y          2          3
                            (x - y)    (x - y)
(%i2) multthru ((x-y)^3, %);
                           2
(%o2)             - (x - y)  + x (x - y) - f(x)
(%i3) ratexpand (%);
                           2
(%o3)                   - y  + x y - f(x)
(%i4) ((a+b)^10*s^2 + 2*a*b*s + (a*b)^2)/(a*b*s^2);
                        10  2              2  2
                 (b + a)   s  + 2 a b s + a  b
(%o4)            ------------------------------
                                  2
                             a b s
(%i5) multthru (%);  /* note that this does not expand (b+a)^10 */
                                        10
                       2   a b   (b + a)
(%o5)                  - + --- + ---------
                       s    2       a b
                           s
(%i6) multthru (a.(b+c.(d+e)+f));
(%o6)            a . f + a . c . (e + d) + a . b
(%i7) expand (a.(b+c.(d+e)+f));
(%o7)         a . f + a . c . e + a . c . d + a . b

Eigenschaft: nary

Erhält eine Funktion oder ein Operator mit der Funktion declare die Eigenschaft nary, werden verschachtelte Anwendungen der Funktion oder des Operators wie zum Beispiel foo(x, foo(y, z)) zu foo(x, y, z) vereinfacht. Die Deklaration als nary unterscheidet sich von der Funktion nary. Während der Funktionsaufruf einen neuen Operator definiert, wirkt sich die Deklaration nur auf die Vereinfachung aus.

Beispiel:

(%i1) H (H (a, b), H (c, H (d, e)));
(%o1)               H(H(a, b), H(c, H(d, e)))
(%i2) declare (H, nary);
(%o2)                         done
(%i3) H (H (a, b), H (c, H (d, e)));
(%o3)                   H(a, b, c, d, e)

Optionsvariable: negdistrib

Standardwert: true

Hat negdistrib den Wert true, wird die Zahl -1 in eine Summe hereinmultipliziert. Zum Beispiel wird -(x + y) zu - y - x vereinfacht. true ist der Standardwert von negdistrib.

Erhält negdistrib den Wert false wird -(x + y) nicht vereinfacht. negdistrib sollte sehr umsichtig und nur in speziellen Fällen für lokale Vereinfachungen genutzt werden.

Systemvariable: opproperties

opproperties ist eine Liste mit den Eigenschaften, die eine Funktion oder ein Operator erhalten kann und die die Vereinfachung der Funktionen und Operatoren kontrollieren. Diese Eigenschaften erhalten die Funktionen und Operatoren mit der Funktion declare. Es gibt weitere Eigenschaften, die Funktionen, Operatoren und Variablen erhalten können. Die Systemvariable features enthält eine vollständige Liste der Eigenschaften, die in Maximas Datenbank eingetragen werden. Darüberhinaus können mit der Funktion declare noch Eigenschaften definiert werden, die in der Lisp-Eigenschaftsliste eingetragen werden.

Die folgenden Eigenschaften sind in der Liste opproperties enthalten und kontrollieren die Vereinfachung von Funktionen und Operatoren:

   linear          additive        multiplicative
   outative        commutative     symmetric      
   antisymmetric   nary            lassociativ
   rassociative    evenfun         oddfun

Eigenschaft: outative

declare(f, outative) deklariert eine Funktion f als outative. Hat der Operator oder die Funktion Argumente mit konstanten Faktoren, so werden diese konstanten Faktoren herausgezogen.

Hat die Funktion f ein Argument, dann wird f(a*x) zu a*f(x) vereinfacht, wenn a ein konstanter Faktor ist.

Ist f eine Funktion mit zwei oder mehr Argumenten, ist die Outativität für das erste Argument definiert. Zum Beispiel wird f(a*g(x), x) zu a*f(g(x),x) vereinfacht, wenn a ein konstanter Faktor ist.

Die Funktionen sum, integrate und limit haben die Eigenschaft outative. Siehe auch die Funktion declare.

Beispiel:

(%i1) F1 (100 * x);
(%o1)                       F1(100 x)
(%i2) declare (F1, outative);
(%o2)                         done
(%i3) F1 (100 * x);
(%o3)                       100 F1(x)
(%i4) declare (zz, constant);
(%o4)                         done
(%i5) F1 (zz * y);
(%o5)                       zz F1(y)

Funktion: radcan (expr)

Die Funktion radcan vereinfacht Ausdrücke, die die Logarithmusfunktion, Exponentialfunktionen und Wurzeln enthalten.

Beispiele:

(%i1) radcan((log(x+x^2)-log(x))^a/log(1+x)^(a/2));
                                           a/2
(%o1)                            log(x + 1)

(%i2) radcan((log(1+2*a^x+a^(2*x))/log(1+a^x)));
(%o2)                                  2

(%i3) radcan((%e^x-1)/(1+%e^(x/2)));
                                     x/2
(%o3)                              %e    - 1

Optionsvariable: radexpand

Standardwert: true

radexpand kontrolliert die Vereinfachung von Wurzeln.

Hat radexpand den Wert all, werden die nten-Wurzeln der Faktoren eines Produktes, die eine n-te Potenz sind, aus der Wurzel herausgezogen. Zum Beispiel vereinfacht sqrt(16*x^2 zu 4*x.

Inbesondere vereinfacht der Ausdruck sqrt(x^2) folgendermaßen:

Eigenschaft: rassociative

declare(f, rassociative) deklariert die Funktion f als rechts-assioziativ. Zum Beispiel wird f(f(a, b), f(c, d)) zu f(a, f(b, f(c, d))) vereinfacht.

Siehe auch die Eigenschaft lassociative und die Funktion declare.

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

Sequential Comparative Simplification (Methode nach Stoute).

scsimp versucht den Ausdruck expr mit Hilfe der Regeln rule_1, …, rule_n zu vereinfachen. Die Regeln werden nacheinander solange angewendet, bis sich der Ausdruck nicht weiter vereinfacht. Führt keine der Regeln zu einem Erfolg, wird der ursprüngliche Ausdruck zurückgegeben.

example(scsimp) zeigt einige Beispiele.

Optionsvariable: simp

Standardwert: true

simp kontrolliert die Vereinfachung von Ausdrücken. Der Standardwert von simp ist true und Ausdrücke werden vereinfacht. simp ist auch ein Auswertungsschalter für die Funktion ev.

Wird simp als ein Auswertungschalter mit dem Wert false genutzt, dann wird die Vereinfachung nur während der Auswertungsphase unterdrückt. simp kann nicht die Vereinfachung unterdrücken, die sich der Auswertung anschließt.

Beispiele:

Die Vereinfachung wird ausgeschaltet. Der Ausdruck sin(1.0) wird nicht zu einem numerischen Wert vereinfacht. Der Auswertungsschalter simp schaltet die Vereinfachung ein.

(%i1) simp:false;
(%o1)                                false
(%i2) sin(1.0);
(%o2)                              sin(1.0)
(%i3) sin(1.0),simp;
(%o3)                          .8414709848078965

Die Vereinfachung wird wieder eingeschaltet. Der Auswertungsschalter simp kann die Vereinfachung nicht vollständig unterdrücken. In der Ausgabe ist der Ausdruck vereinfacht, aber die Variable x enthält einen nicht vereinfachten Ausdruck, da die Zuweisung noch während der Auswertungsphase des Ausdrucks vorgenommen wurde.

(%i4) simp:true;
(%o4)                                true
(%i5) x:sin(1.0),simp:false;
(%o5)                          .8414709848078965
(%i6) :lisp $X
((%SIN) 1.0)

Eigenschaft: symmetric

declare(f, symmetric) deklariert die Funktion f als symmetrisch. Zum Beispiel wird f(x, z, y) zu f(x, y, z) vereinfacht.

commutative entspricht symmetric Siehe auch die Funktion declare.

Beispiel:

(%i1) S (b, a);
(%o1)                        S(b, a)
(%i2) declare (S, symmetric);
(%o2)                         done
(%i3) S (b, a);
(%o3)                        S(a, b)
(%i4) S (a, c, e, d, b);
(%o4)                   S(a, b, c, d, e)

Funktion: xthru (expr)

Die Terme einer Summe des Ausdrucks expr werden so zusammengefasst, dass sie einen gemeinsamen Nenner haben. Produkte und Potenzen von Summen werden dabei nicht expandiert. Gemeinsame Faktoren im Zähler und Nenner werden gekürzt.

Es kann vorteilhaft sein, vor dem Ausführen von ratsimp zunächst mit xthru die gemeinsamen Faktoren eines rationalen Ausdrucks zu kürzen.

Siehe auch die Funktion combine.

Beispiele:

(%i1) ((x+2)^20 - 2*y)/(x+y)^20 + (x+y)^(-19) - x/(x+y)^20;
                                20
                 1       (x + 2)   - 2 y       x
(%o1)        --------- + --------------- - ---------
                    19             20             20
             (y + x)        (y + x)        (y + x)
(%i2) xthru (%);
                                 20
                          (x + 2)   - y
(%o2)                     -------------
                                   20
                            (y + x)

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

This document was generated by Robert on Juli, 9 2012 using texi2html 1.76.