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

  - Hat `radexpand` den Wert `all` oder wurde `assume(x>0)` ausgeführt, dann vereinfacht `sqrt(x^2)` zu `x`.
  - Hat `radexpand` den Wert `true` und `domain` ist `real`, dann vereinfacht `sqrt(x^2)` zu `abs(x)`.
  - Hat `radexpand` den Wert `false` oder hat `radexpand` den Wert `true` und `domain` ist `complex`, dann wird `sqrt(x^2)` nicht vereinfacht.

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 Viktor T. Toth on September, 27 2018 using texi2html 1.76.