Funktionen und Variablen für die Vereinfachung (Maxima Manual)

Vorige: Einführung in die Vereinfachung, Nach oben: Vereinfachung [Inhalt][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)

Vorige: Einführung in die Vereinfachung, Nach oben: Vereinfachung [Inhalt][Index]