Maxima Manual: Funktionen und Variablen für Polynome

Previous: Einführung in Polynome, Nach oben: Polynome [Inhalt][Index]

### 17.2 Funktionen und Variablen für Polynome

Optionsvariable: algebraic

  Standardwert: `false`

  Hat die Optionsvariable `algebraic` den Wert `true`, wird beim Umwandeln von Ausdrücken in die CRE-Form und beim Rechnen mit Ausdrücken in einer CRE-Form der Ausdruck so vereinfacht, dass der Nenner frei von algebraischen Zahlen (das sind Wurzeln von ganzen Zahlen) ist.

  Beispiele:

  Im zweiten Beispiel wird der Ausdruck automatisch mit `sqrt(2)` erweitert, um den Nenner frei von der algebraischen Zahl `sqrt(2)` zu machen.

      (%i1) algebraic:false;
      (%o1)                         false
      (%i2) rat(x^2+x)/sqrt(2);
                                    2
                                   x  + x
      (%o2)/R/                     -------
                                   sqrt(2)
      (%i3) algebraic:true;
      (%o3)                         true
      (%i4) rat(x^2+x)/sqrt(2);
                                    2
                           sqrt(2) x  + sqrt(2) x
      (%o4)/R/             ----------------------
                                     2

Optionsvariable: berlefact

  Standardwert: `true`

  Hat die Optionsvariable `berlefact` den Wert `false`, dann wird der Kronecker-Algorithmus von der Funktion `factor` für die Faktorisierung genutzt. Ansonsten wird der Berlekamp-Algorithmus genutzt. Der Standardwert ist `true`.

Funktion: bezout (p1, p2, x)

  Die Rückgabe ist die Sylvestermatrix der zwei Polynome p1 und p2 mit der unabhängigen Variablen x. Die Determinante der Sylvestermatrix ist die Resultante der Polynome. Die Resultante kann auch sofort mit der Funktion `resultant` berechnet werden.

  Beispiele:

      (%i1) bezout(a*x+b, c*x^2+d, x);
                               [ b c  - a d ]
      (%o1)                    [            ]
                               [  a     b   ]
      (%i2) determinant(%);
                                  2      2
      (%o2)                      a  d + b  c
      (%i3) resultant(a*x+b, c*x^2+d, x);
                                  2      2
      (%o3)                      a  d + b  c

Funktion: bothcoef (expr, x)

  Gibt eine Liste zurück, deren erstes Element der Koeffizient der Variablen x im Ausdruck expr und deren zweites Element der verbleibende Teil des Ausdrucks expr ist. Das Ergebnis ist also `[A,B]` und es gilt `expr = A * x + B`.

  Die Funktion `bothcoef` hat den Alias-Namen `bothcoeff`.

  Siehe auch die Funktion `coeff`.

  Beispiele:

      (%i1) bothcoeff(a*x+2, x);
      (%o1)                        [a, 2]
      (%i2) bothcoeff(x^2+a*x+2, x);
                                      2
      (%o2)                      [a, x  + 2]

  Definition einer Funktion `islinear`, die die Funktion `bothcoeff` nutzt, um den linearen Anteil eines Ausdrucks zu ermitteln.

      (%i1) islinear (expr, x) :=
               block ([c],
                  c: bothcoef (rat (expr, x), x),
                  is (freeof (x, c) and c[1] # 0))$
      (%i2) islinear ((r^2 - (x - r)^2)/x, x);
      (%o2)                         true

Funktion: coeff (expr, x, n)
Funktion: coeff (expr, x)

  Gibt den Koeffizienten von `x^n` des Ausdrucks expr zurück. Das Argument expr ist ein Polynom in der Variablen x.

  Das Kommando `coeff(expr, x^n)` ist äquivalent zu `coeff(expr, x, n)`. Das Kommando `coeff(expr, x, 0)` gibt den Teil des Ausdrucks expr zurück, der frei von der Variablen x ist. Wenn nicht angegeben, wird das Argument n als `1` angenommen.

  Das Argument x kann auch eine indizierte Variable oder ein Teilausdruck von expr sein.

  `coeff` wendet weder die Funktion `expand` noch die Funktion `factor` an, um einen Ausdruck zu expandieren oder zu faktorisieren. Daher kann es zu anderen Ergebnissen kommen, wenn zuvor diese Funktionen angewendet werden.

  Wird `coeff` auf Listen, Matrizen oder Gleichungen angewendet, wird die Funktion auf die Elemente oder beide Seiten der Gleichung angewendet.

  Siehe auch die Funktion `bothcoef`.

  Beispiele:

  `coeff` gibt den Koeffizienten von `x^n` des Ausdrucks expr zurück.

      (%i1) coeff(b^3*a^3 + b^2*a^2 + b*a + 1, a^3);
                                      3
      (%o1)                          b

  `coeff(expr, x^n)` ist äquivalent zu `coeff(expr, x, n)`.

      (%i1) coeff(c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z, 3);
      (%o1)                         - c
                                       3
      (%i2) coeff(c[4]*z^4 - c[3]*z^3 - c[2]*z^2 + c[1]*z, z^3);
      (%o2)                         - c
                                       3

  `coeff(expr, x, 0)` gibt den Teil des Ausdrucks expr zurück, der frei von der Variablen x ist.

      (%i1) coeff(a*u + b^2*u^2 + c^3*u^3, b, 0);
                                  3  3
      (%o1)                      c  u  + a u

  x kann eine einfache Variable, eine indizierte Variable oder ein Teilausdruck des Ausdrucks expr sein.

      (%i1) coeff(h^4 - 2*%pi*h^2 + 1, h, 2);
      (%o1)                        - 2 %pi
      (%i2) coeff(v[1]^4 - 2*%pi*v[1]^2 + 1, v[1], 2);
      (%o2)                        - 2 %pi
      (%i3) coeff (sin(1+x)*sin(x) + sin(1+x)^3*sin(x)^3, sin(1+x)^3);
                                      3
      (%o3)                        sin (x)
      (%i4) coeff((d - a)^2*(b + c)^3 + (a + b)^4*(c - d), a + b, 4);
      (%o4)                         c - d

  `coeff` wendet die Funktionen `expand` und `factor` nicht an.

      (%i1) coeff(c*(a + b)^3, a);
      (%o1)                           0
      (%i2) expand(c*(a + b)^3);
                       3          2        2        3
      (%o2)           b  c + 3 a b  c + 3 a  b c + a  c
      (%i3) coeff(%, a);
                                      2
      (%o3)                        3 b  c
      (%i4) coeff(b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c, (a + b)^3);
      (%o4)                           0
      (%i5) factor(b^3*c + 3*a*b^2*c + 3*a^2*b*c + a^3*c);
                                        3
      (%o5)                      (b + a)  c
      (%i6) coeff(%, (a + b)^3);
      (%o6)                           c

  `coeff` wird bei Listen und Matrizen auf die Elemente und bei Gleichungen auf die beiden Seiten angewendet.

      (%i1) coeff([4*a, -3*a, 2*a], a);
      (%o1)                      [4, - 3, 2]
      (%i2) coeff(matrix ([a*x, b*x], [-c*x, -d*x]), x);
                                [  a    b  ]
      (%o2)                     [          ]
                                [ - c  - d ]
      (%i3) coeff(a*u - b*v = 7*u + 3*v, u);
      (%o3)                         a = 7

  Die folgende Definition der Funktion `coeff_list` liefert eine Liste mit den Koeffizienten, die in einem Polynom auftreten. Neben der Funktion `coeff` kommt hier die Funktion `hipow` zum Einsatz, um den höchsten Exponenten zu ermitteln. `rat` und `ratdisrep` werden verwendet, um das Polynom zwischenzeitlich in die kanonische Form (CRE) zu bringen.

      (%i1) b : (x-y)^2;
                                             2
      (%o1)                           (x - y)
      (%i2) coeff_list(a, x) := (
         a : rat(a),
         reverse( makelist(ratdisrep(coeff(a, x, i)), i,0, hipow(a, x)) ))$

      (%i3) coeff_list(b, x);
                                               2
      (%o3)                        [1, - 2 y, y ]

Funktion: content (p, x_1, …, x_n)

  Gibt eine Liste zurück, deren erstes Element der größte gemeinsame Teiler der Koeffizienten des Polynoms p in der Variablen x_n ist und dessen zweites Element das durch den größten gemeinsamen Teiler dividierte Polynom ist. Die anderen Argumente x_1, …, x_n-1 haben dieselbe Bedeutung wie für die Funktion `ratvars`.

  Beispiel:

      (%i1) content(2*x*y + 4*x^2*y^2, y);
                                         2
      (%o1)                   [2 x, 2 x y  + y]

Funktion: denom (expr)

  Gibt den Nenner des Ausdrucks expr zurück, wenn dieser ein Quotient ist. Ist der Ausdruck expr kein Quotient wird expr zurückgegeben.

  Die Funktion `denom` wertet das Argument aus. Siehe auch die Funktion `num`.

  Beispiel:

      (%i1) denom(x^2/(x+1));
      (%o1)                         x + 1

Funktion: divide (p_1, p_2, x_1, …, x_n)

  Berechnet den Quotienten und den Rest der Division des Polynom p_1 durch das Polynom p_2 für die Variable x_n. Die anderen Argumente x_1, …, x_n-1 haben dieselbe Bedeutung wie für die Funktion `ratvars`. Das Ergebnis ist eine Liste, wobei das erste Element der Quotient und das zweite Element der Rest ist.

  Die Argumente der Funktion `divide` können auch ganze Zahlen sein.

  Siehe auch die Funktionen `quotient` und `remainder`, die jeweils den Quotienten und den Rest der Polynomdivision zurückgegeben.

  Beispiele:

  Im zweiten Beispiel ist `y` die Hauptvariable des Ausdrucks.

      (%i1) divide (x + y, x - y, x);
      (%o1)                       [1, 2 y]
      (%i2) divide (x + y, x - y);
      (%o2)                      [- 1, 2 x]

  Ein Beispiel für zwei Polynome in zwei Variablen.

      (%i1) poly1 : sum(x^k*y^(6-k), k, 1, 5);
                        5    2  4    3  3    4  2    5
      (%o1)          x y  + x  y  + x  y  + x  y  + x  y
      (%i2) poly2 : sum(2*k*x^k*y^(3-k), k, 1, 3);
                                2      2        3
      (%o2)                2 x y  + 4 x  y + 6 x
      (%i3) divide(poly1, poly2, x);
                    3        2      2          5       2  4
                 4 y  + 3 x y  + 9 x  y  23 x y  + 16 x  y
      (%o3)     [----------------------, ------------------]
                           54                    27
      (%i4) expand(first(%)*poly2 + second(%));
                        5    2  4    3  3    4  2    5
      (%o4)          x y  + x  y  + x  y  + x  y  + x  y

Optionsvariable: dontfactor

  Standardwert: `[]`

  Der Optionsvariablen `dontfactor` kann eine Liste mit den Variablen zugewiesen werden, bezüglich der ein Ausdruck nicht faktorisiert werden soll. Weiterhin wird nicht bezüglich von Variablen faktorisiert, die gemäß der kanonischen Ordnung der Variablen von geringerer Bedeutung sind als die Variablen in der Liste `dontfactor`.

  Beispiel:

  Im zweiten Fall wird das Polynom nicht bezüglich der Variablen x faktorisiert.

      (%i1) expr:expand((x+1)^3*(y+2)^2);
             3  2      2  2        2    2      3         2
      (%o1) x  y  + 3 x  y  + 3 x y  + y  + 4 x  y + 12 x  y + 12 x y
                                                   3       2
                                        + 4 y + 4 x  + 12 x  + 12 x + 4
      (%i2) factor(expr);
                                     3        2
      (%o2)                   (x + 1)  (y + 2)
      (%i3) dontfactor:[x];
      (%o3)                          [x]
      (%i4) factor(expr);
                         3      2                   2
      (%o4)            (x  + 3 x  + 3 x + 1) (y + 2)

Funktion: eliminate ([eqn_1, …, eqn_n], [x_1, …, x_k])

  Wendet ein Subresultanten-Verfahren an, um die Variablen x_1, …, x_k aus den Gleichungen eqn_1, …, eqn_n zu eliminieren. Die Rückgabe ist ein Gleichungssystem mit `n - k` Gleichungen, wobei die k-Variablen x_1, …, x_k eliminiert sind.

  Beispiel:

      (%i1) eqn1: 2*x^2 + y*x + z;
                                            2
      (%o1)                    z + x y + 2 x
      (%i2) eqn2: 3*x + 5*y - z - 1;
      (%o2)                  - z + 5 y + 3 x - 1
      (%i3) eqn3: z^2 + x - y^2 + 5;
                                2    2
      (%o3)                    z  - y  + x + 5
      (%i4) eliminate([eqn1, eqn2, eqn3], [y,z]);
                    2      4      3       2
      (%o4)       [x  (45 x  + 3 x  + 11 x  + 81 x + 124)]

Funktion: ezgcd (p_1, p_2, p_3, …)

  Gibt eine Liste zurück, deren erstes Element der größte gemeinsame Teiler der Polynome p_1, …, p_n ist und deren weitere Elemente die durch den größten gemeinsamen Teiler dividierten Polynome sind. Der größte gemeinsame Teiler wird immer mit dem `ezgcd`-Algorithmus bestimmt.

  Siehe auch die Funktionen `gcd`, `gcdex` `gcdivide` und `poly_gcd`.

  Beispiel:

  Die drei Polynome haben den größten gemeinsamen Teiler `2*x-3`. Der größte gemeinsame Teiler wird zuerst mit der Funktion `gcd` berechnet. Dann wird das Ergebnis der Funktion `ezgcd` gezeigt.

      (%i1) p1 : 6*x^3-17*x^2+14*x-3;
                              3       2
      (%o1)                6 x  - 17 x  + 14 x - 3
      (%i2) p2 : 4*x^4-14*x^3+12*x^2+2*x-3;

                          4       3       2
      (%o2)            4 x  - 14 x  + 12 x  + 2 x - 3

      (%i3) p3 : -8*x^3+14*x^2-x-3;
                                3       2
      (%o3)                - 8 x  + 14 x  - x - 3

      (%i4) gcd(p1, gcd(p2, p3));
      (%o4)                        2 x - 3

      (%i5) ezgcd(p1, p2, p3);
                         2               3      2           2
      (%o5) [2 x - 3, 3 x  - 4 x + 1, 2 x  - 4 x  + 1, - 4 x  + x + 1]

Optionsvariable: facexpand

  Standardwert: `true`

  Die Optionsvariable `facexpand` kontrolliert, ob die irreduziblen Faktoren der Faktorisierung mit `factor` in einer expandierten oder in einer rekursiven (CRE-Form) vorliegen. Der Standard ist, dass die Faktoren expandiert werden.

Funktion: factor (expr)
Funktion: factor (expr, p)

  Faktorisiert den Ausdruck expr, der eine beliebige Zahl an Variablen oder Funktionen enthalten kann, in irreduzible Faktoren über die ganzen Zahlen. `factor(expr, p` faktorisiert expr über den Körper der rationalen Zahlen, der um die Nullstellen des minimalen Polynoms p erweitert ist.

  `factor` ruft die Funktion `ifactors` auf, um ganze Zahlen zu faktorisieren.

  Hat die Optionsvariable `factorflag` den Wert `false`, wird die Faktorisierung von ganzen Zahlen unterdrückt, die im Nenner einer rationalen Funktion auftreten.

  Der Optionsvariablen `dontfactor` kann eine Liste mit den Variablen zugewiesen werden, bezüglich der ein Ausdruck nicht faktorisiert werden soll. Weiterhin wird nicht bezüglich von Variablen faktorisiert, die gemäß der kanonischen Ordnung der Variablen von geringerer Bedeutung sind als die Variablen in der Liste `dontfactor`.

  Hat die Optionsvariable `savefactors` den Wert `true`, versuchen einige Funktionen bei der Vereinfachung eine bereits vorhandene Faktorisierung zu erhalten, um weitere Vereinfachungen zu beschleunigen.

  Hat die Optionsvariable `berlefact` den Wert `false`, dann wird der Kronecker-Algorithmus für die Faktorisierung genutzt. Ansonsten wird der Berlekamp-Algorithmus genutzt. Der Standardwert ist `true`.

  Hat die Optionsvariable `intfaclim` den Wert `true`, gibt Maxima die Faktorisierung von ganzen Zahlen auf, wenn keine Faktorisierung durch Anwendung der Methode der Probedivision und der Pollard-Rho-Methode gefunden werden konnten. Hat `intfaclim` den Wert `false`, versucht Maxima eine ganze Zahl vollständig zu faktorisieren. Der Wert der Optionsvariablen `intfaclim` wird von der Funktion `factor` beachtet. Mit dem Setzen von `intfaclim` kann der Nutzer verhindern, dass Maxima beim Versuch sehr große ganze Zahlen zu faktorisieren, unnötig viel Zeit verbraucht.

  Beispiele:

      (%i1) factor (2^63 - 1);
                          2
      (%o1)              7  73 127 337 92737 649657
      (%i2) factor (-8*y - 4*x + z^2*(2*y + x));
      (%o2)               (2 y + x) (z - 2) (z + 2)
      (%i3) -1 - 2*x - x^2 + y^2 + 2*x*y^2 + x^2*y^2;
                      2  2        2    2    2
      (%o3)          x  y  + 2 x y  + y  - x  - 2 x - 1
      (%i4) block ([dontfactor: [x]], factor (%/36/(1 + 2*y + y^2)));
                             2
                           (x  + 2 x + 1) (y - 1)
      (%o4)                ----------------------
                                 36 (y + 1)
      (%i5) factor (1 + %e^(3*x));
                            x         2 x     x
      (%o5)              (%e  + 1) (%e    - %e  + 1)
      (%i6) factor (1 + x^4, a^2 - 2);
                          2              2
      (%o6)             (x  - a x + 1) (x  + a x + 1)
      (%i7) factor (-y^2*z^2 - x*z^2 + x^2*y^2 + x^3);
                             2
      (%o7)              - (y  + x) (z - x) (z + x)
      (%i8) (2 + x)/(3 + x)/(b + x)/(c + x)^2;
                                   x + 2
      (%o8)               ------------------------
                                                 2
                          (x + 3) (x + b) (x + c)
      (%i9) ratsimp (%);

                      4                  3
      (%o9) (x + 2)/(x  + (2 c + b + 3) x

           2                       2             2                   2
       + (c  + (2 b + 6) c + 3 b) x  + ((b + 3) c  + 6 b c) x + 3 b c )

      (%i10) partfrac (%, x);
                 2                   4                3
      (%o10) - (c  - 4 c - b + 6)/((c  + (- 2 b - 6) c

           2              2         2                2
       + (b  + 12 b + 9) c  + (- 6 b  - 18 b) c + 9 b ) (x + c))

                       c - 2
       - ---------------------------------
           2                             2
         (c  + (- b - 3) c + 3 b) (x + c)

                               b - 2
       + -------------------------------------------------
                   2             2       3      2
         ((b - 3) c  + (6 b - 2 b ) c + b  - 3 b ) (x + b)

                               1
       - ----------------------------------------------
                   2
         ((b - 3) c  + (18 - 6 b) c + 9 b - 27) (x + 3)
      (%i11) map ('factor, %);
                    2
                   c  - 4 c - b + 6                 c - 2
      (%o11) - ------------------------- - ------------------------
                      2        2                                  2
               (c - 3)  (c - b)  (x + c)   (c - 3) (c - b) (x + c)

                             b - 2                        1
                  + ------------------------ - ------------------------
                                   2                          2
                    (b - 3) (c - b)  (x + b)   (b - 3) (c - 3)  (x + 3)
      (%i12) ratsimp ((x^5 - 1)/(x - 1));
                             4    3    2
      (%o12)                x  + x  + x  + x + 1
      (%i13) subst (a, x, %);
                             4    3    2
      (%o13)                a  + a  + a  + a + 1
      (%i14) factor (%th(2), %);
                             2        3        3    2
      (%o14)   (x - a) (x - a ) (x - a ) (x + a  + a  + a + 1)
      (%i15) factor (1 + x^12);
                             4        8    4
      (%o15)               (x  + 1) (x  - x  + 1)
      (%i16) factor (1 + x^99);
                       2            6    3
      (%o16) (x + 1) (x  - x + 1) (x  - x  + 1)

         10    9    8    7    6    5    4    3    2
       (x   - x  + x  - x  + x  - x  + x  - x  + x  - x + 1)

         20    19    17    16    14    13    11    10    9    7    6
       (x   + x   - x   - x   + x   + x   - x   - x   - x  + x  + x

          4    3            60    57    51    48    42    39    33
       - x  - x  + x + 1) (x   + x   - x   - x   + x   + x   - x

          30    27    21    18    12    9    3
       - x   - x   + x   + x   - x   - x  + x  + 1)

  Das Polynom `x^4+1` lässt sich nicht über den Körper der ganzen Zahlen faktorisieren. Wird der Körper um das minimale Polynom `a^2+1` erweitert, ist die Faktorisierung möglich. Die Nullstellen des minimalen Polynoms sind die imaginäre Einheit `%i` und `-%i`. Das Ergebnis entspricht der Faktorisierung mit der Funktion `gfactor`.

      (%i1) factor(x^4+1);
                                    4
      (%o1)                        x  + 1
      (%i2) factor(x^4+1, a^2+1);
                                2        2
      (%o2)                   (x  - a) (x  + a)
      (%i3) gfactor(x^4+1);
                               2         2
      (%o3)                  (x  - %i) (x  + %i)

Optionsvariable: factorflag

  Standardwert: `false`

  Hat die Optionsvariable `factorflag` den Wert `false`, wird die Faktorisierung von ganzen Zahlen unterdrückt, die im Nenner einer rationalen Funktion auftreten.

  Beispiel:

      (%i1) factorflag:false;
      (%o1)                         false
      (%i2) factor(1/6*(x^2+2*x+1));

                                         2
                                  (x + 1)
      (%o2)                       --------
                                     6

      (%i3) factorflag:true;
      (%o3)                         true
      (%i4) factor(1/6*(x^2+2*x+1));
                                         2
                                  (x + 1)
      (%o4)                       --------
                                    2 3

Funktion: factorout (expr, x_1, x_2, …)

  Gruppiert eine Summe expr in eine Summe mit Termen der Form `f(x_1, x_2, ...) * g`, wobei `g` ein gemeinsamer Faktor des Polynoms `f` ist.

  Beispiele:

  Das Polynom wird zuerst nach der Variablen x, dann nach y und zuletzt nach beiden Variablen faktorisiert.

      (%i1) factorout(2*a*x^2+a*x+a+a*y, x);
                                       2
      (%o1)                a y + a (2 x  + x + 1)
      (%i2) factorout(2*a*x^2+a*x+a+a*y, y);
                                           2
      (%o2)               a (y + 1) + 2 a x  + a x
      (%i3) factorout(2*a*x^2+a*x+a+a*y, y, x);
                                      2
      (%o3)                 a (y + 2 x  + x + 1)

Funktion: factorsum (expr)

  Versucht Terme in expr so zu gruppieren, dass die Teilsummen faktorisierbar sind. `factorsum` kann zum Beispiel das expandierte Polynom `expand ((x + y)^2 + (z + w)^2)` wieder herstellen, nicht jedoch das expandierte Polynom `expand ((x + 1)^2 + (x + y)^2)`, da die Terme gemeinsame Variablen enthalten.

  Beispiele:

      (%i1) expand ((x + 1)*((u + v)^2 + a*(w + z)^2));
                 2      2                            2      2
      (%o1) a x z  + a z  + 2 a w x z + 2 a w z + a w  x + v  x

                                           2        2    2            2
                              + 2 u v x + u  x + a w  + v  + 2 u v + u
      (%i2) factorsum(%);
                                         2          2
      (%o2)            (x + 1) (a (z + w)  + (v + u) )

Funktion: fasttimes (p_1, p_2)

  Führt eine schnelle Multiplikation der Polynome p_1 und p_2 aus und gibt das Ergebnis zurück. Der Algorithmus ist von Vorteil, wenn die Polynome mehrere Variablen haben und die Koeffizienten dicht besetzt sind. Sind `n_1` und `n_2` jeweils der Grad der Polynome p_1 und p_2, dann benötigt die schnelle Multiplikation `max(n_1, n_2)^1.585` Multiplikationen.

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

  Die Funktion `fullratsimp` wendet die Funktion `ratsimp` auf das Argument expr solange wiederholt an, bis sich das Ergebnis nicht mehr ändert. Nach jeder Anwendung von `ratsimp` wird der Ausdruck zusätzlich vereinfacht.

  Sind nicht-rationale Ausdrücke in einem Ausdruck enthalten, kann der Ausdruck möglicherweise mit einem Aufruf von `ratsimp` nicht vollständig vereinfacht werden. Dann kann der mehrfache Aufruf von `ratsimp` zu einem besser vereinfachten Resultat führen. Die Funktion `fullratsimp` ist für solche Falle gedacht.

  Die weiteren Argumente x_1, …, x_n entsprechen denen der Funktionen `ratsimp` und `rat`.

  Beispiele:

      (%i1) expr: (x^(a/2) + 1)^2*(x^(a/2) - 1)^2/(x^a - 1);
                             a/2     2   a/2     2
                           (x    - 1)  (x    + 1)
      (%o1)                -----------------------
                                    a
                                   x  - 1
      (%i2) ratsimp (expr);
                                2 a      a
                               x    - 2 x  + 1
      (%o2)                    ---------------
                                    a
                                   x  - 1
      (%i3) fullratsimp (expr);
                                    a
      (%o3)                        x  - 1
      (%i4) rat (expr);

                             a/2 4       a/2 2
                           (x   )  - 2 (x   )  + 1
      (%o4)/R/             -----------------------
                                    a
                                   x  - 1

Funktion: fullratsubst (a, b, c)

  Entspricht der Funktion `ratsubst` mit dem Unterschied, dass die Funktion solange rekursiv ausgeführt wird, bis sich das Ergebnis nicht mehr ändert. Diese Funktion kann nützlich sein, wenn der Ausdruck, der eingesetzt wird, und der zu ersetzende Ausdruck mehrere Variablen gemeinsam haben.

  `fullratsubst` akzeptiert auch Argumente im Format der Funktion `lratsubst`. Das erste Argument kann also auch eine einzelne oder eine Liste von Gleichungen sein. Das zweite Argument ist in diesem Fall der Ausdruck in dem die Ersetzungen durchgeführt werden.

  Mit dem Kommando `load("lrats")` werden die Funktionen `fullratsubst` und `lratsubst` geladen.

  Beispiele:

      (%i1) load ("lrats")$

  `subst` kann mehrfache Substitutionen ausführen. Die Funktion `lratsubst` funktioniert analog zu der Funktion `subst`.

      (%i2) subst ([a = b, c = d], a + c);
      (%o2)                         d + b
      (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
      (%o3)                (d + a c) e + a d + b c

  Ist nur eine Substitution auszuführen, kann diese als eine einzelne Gleichung angegeben werden.

      (%i4) lratsubst (a^2 = b, a^3);
      (%o4)                          a b

  `fullratsubst` ist äquivalent zur Funktion `ratsubst` mit dem Unterschied, dass die Funktion solange rekursiv angewendet wird, bis sich das Ergebnis nicht mehr ändert.

      (%i5) ratsubst (b*a, a^2, a^3);
                                     2
      (%o5)                         a  b
      (%i6) fullratsubst (b*a, a^2, a^3);

                                       2
      (%o6)                         a b

  `fullratsubst` akzeptiert auch eine Liste mit Gleichungen oder eine Gleichung als erstes Argument.

      (%i7) fullratsubst ([a^2 = b, b^2 = c, c^2 = a], a^3*b*c);
      (%o7)                           b
      (%i8) fullratsubst (a^2 = b*a, a^3);
                                       2
      (%o8)                         a b

  `fullratsubst` kann zu einer unendlichen Rekursion führen.

      (%i9) errcatch (fullratsubst (b*a^2, a^2, a^3));

      *** - Lisp stack overflow. RESET

Funktion: gcd (p_1, p_2, x_1, …)
Optionsvariable: gcd

  Gibt den größten gemeinsamen Teiler der Polynome p_1 und p_2 zurück. Die Argumente x_1, … sind optional und haben dieselbe Bedeutung wie für die Funktion `ratvars`. Die Optionsvariable `gcd` kontrolliert, welcher Algorithmus verwendet wird und kann die folgenden Werte annehmen:

  `ez`

    ezgcd-Alogrithmus

  `subres`

    Subresultanten-Algorithmus

  `red`

    Reduzierter modularer Algorithmus

  `spmod`

    Modularer Algorithmus

  `false`

    kein Algorithmus, die Rückgabe ist immer 1

  Siehe auch die `ezgcd`, `gcdex`, `gcdivide`, und `poly_gcd`.

  Beispiele:

      (%i1) p1:6*x^3+19*x^2+19*x+6;
                              3       2
      (%o1)                6 x  + 19 x  + 19 x + 6
      (%i2) p2:6*x^5+13*x^4+12*x^3+13*x^2+6*x;
                        5       4       3       2
      (%o2)          6 x  + 13 x  + 12 x  + 13 x  + 6 x
      (%i3) gcd(p1, p2);
                                  2
      (%o3)                    6 x  + 13 x + 6
      (%i4) p1/gcd(p1, p2), ratsimp;
      (%o4)                         x + 1
      (%i5) p2/gcd(p1, p2), ratsimp;
                                    3
      (%o5)                        x  + x

  Die Funktion `ezgcd` gibt als Ergebnis eine Liste zurück, die als erstes Element den größten gemeinsamen Teiler und als weitere Elemente die durch den größten gemeinsamen Teiler dividierten Polynome enthält.

      (%i6) ezgcd(p1, p2);
                          2                     3
      (%o6)           [6 x  + 13 x + 6, x + 1, x  + x]

Funktion: gcdex (p_1, p_2)
Funktion: gcdex (p_1, p_2, x)

  Wendet den erweiterten Euklidischen Algorithmus für die beiden Polynome p_1 und p_2 an und gibt eine Liste `[s, t, u]` mit den Parametern u, s und t als Ergebnis zurück. Der Parameter u ist der größte gemeinsame Teiler der Polynome. Die Parameter s und t sind die Bezoutkoeffizienten, so dass gilt `u = s * p_1 + t * p_2`.

  Die Rückgabe der Funktion `gcdex` ist in der CRE-Form.

  Siehe auch die Funktionen `ezgcd`, `gcd` und `gcdivide`.

  Die Argumente f und g können ganze Zahlen sein. In diesem Falle wird die Funktion `igcdex` von der Funktion `gcdex` aufgerufen.

  Siehe auch die Funktionen `ezgcd`, `gcd`, `gcdivide` und `poly_gcd`.

  Beispiel:

      (%i1) gcdex (x^2 + 1, x^3 + 4);
                             2
                            x  + 4 x - 1  x + 4
      (%o1)/R/           [- ------------, -----, 1]
                                 17        17
      (%i2) % . [x^2 + 1, x^3 + 4, -1];
      (%o2)/R/                        0

  Im folgenden Beispiel ist die unabhängige Variable explizit als x angegeben. Ohne diese Angabe ist y die unabhängige Variable.

      (%i1) gcdex (x*(y + 1), y^2 - 1, x);
                                     1
      (%o1)/R/                 [0, ------, 1]
                                    2
                                   y  - 1

Funktion: gcfactor (g)

  Faktorisiert die Gaußsche Zahl g über die Gaußsche Zahlen. Eine Gaußsche Zahl `g` ist durch `g = a + b*%i` gegeben, wobei `a` und `b` ganze Zahlen sind. Die Faktoren werden so normalisiert, dass a und b nicht negativ sind.

  Beispiele:

      (%i1) gcfactor(5);
      (%o1)               - %i (1 + 2 %i) (2 + %i)
      (%i2) expand(%);
      (%o2)                           5
      (%i3) gcfactor(5+%i);
      (%o3)               - %i (1 + %i) (2 + 3 %i)
      (%i4) expand(%);
      (%o4)                        %i + 5

Funktion: gfactor (expr)

  Faktorisiert das Polynom expr über die Gaußschen Zahlen. Das ist die Faktorisierung über den Körper der ganzen Zahlen, der um das Element %i erweitert ist.

  Die Faktorisierung der Funktion `gfactor` ist äquivalent zu `factor(expr), a^2+1)` mit dem minimalen Polynom `a^2+1`, das die Nullstelle `%i` hat. Siehe auch `factor`.

  Beispiel:

      (%i1) gfactor(x^4 - 1);
      (%o1)           (x - 1) (x + 1) (x - %i) (x + %i)
      (%i2) factor(x^4 - 1, a^2+1);
      (%o2)            (x - 1) (x + 1) (x - a) (x + a)

Funktion: gfactorsum (expr)

  Entspricht der Funktion `factorsum` mit den Unterschied, dass anstatt der Funktion `factor` die Funktion `gfactor` angewendet wird, um den Ausdruck expr zu faktorisieren.

Funktion: hipow (expr, x)

  Gibt den größten Exponenten des Arguments x zurück, der im Ausdruck expr auftritt. Treten symbolische Exponenten auf, wird ein Ausdruck mit `max` zurückgegeben. Ist das Argument x nicht im Ausdruck vorhanden, ist die Rückgabe `0`.

  Die Funktion `hipow` betrachtet keine äquivalenten Ausdrücke. Daher können die Ausdrücke `expand(expr)` und expr ein verschiedenes Ergebnis haben.

  Siehe auch die Funktionen `lopow` und `coeff`.

  Beispiele:

      (%i1) hipow (y^3 * x^2 + x * y^4, x);
      (%o1)                           2
      (%i2) hipow ((x + y)^5, x);
      (%o2)                           1
      (%i3) hipow (expand ((x + y)^5), x);
      (%o3)                           5
      (%i4) hipow ((x + y)^5, x + y);
      (%o4)                           5
      (%i5) hipow (expand ((x + y)^5), x + y);
      (%o5)                           0
      (%i1) hipow ((x+y)^2 + (x+y)^a, x+y);
      (%o1)                       max(2, a)

Optionsvariable: intfaclim

  Standardwert: `true`

  Hat die Optionsvariable `intfaclim` den Wert `true`, gibt Maxima die Faktorisierung von ganzen Zahlen auf, wenn keine Faktorisierung durch Anwendung der Methode der Probedivision und der Pollard-Rho-Methode gefunden werden konnten.

  Hat `intfaclim` den Wert `false`, versucht Maxima eine ganze Zahl vollständig zu faktorisieren. `intfaclim` wird von den Funktionen `divisors`, `divsum` und `totient` auf den Wert `false` gesetzt.

  Der Wert der Optionsvariablen `intfaclim` wird von der Funktion `factor` beachtet. Mit dem Setzen von `intfaclim` kann der Nutzer verhindern, dass Maxima beim Versuch sehr große ganze Zahlen zu faktorisieren, unnötig viel Zeit verbraucht.

Optionsvariable: keepfloat

  Standardwert: `false`

  Hat die Optionsvariable `keepfloat` den Wert `true`, werden Gleitkommazahlen nicht in rationale Zahlen umgewandelt, wenn Ausdrücke mit Gleitkommazahlen in eine CRE-Form umgewandelt werden.

  Die Funktion `solve` und Funktionen, die `solve` aufrufen, beachten den Wert von `keepfloat` nicht.

  Beispiele:

      (%i1) rat(x/2.0);

      rat: replaced 0.5 by 1/2 = 0.5
                                      x
      (%o1)/R/                        -
                                      2
      (%i2) rat(x/2.0), keepfloat;
      (%o2)/R/                      0.5 x

  Die Funktion `solve` ignoriert den Wert der Optionsvariablen `keepfloat`.

      (%i3) solve(1.0-x,x), keepfloat;

      rat: replaced 1.0 by 1/1 = 1.0
      (%o3)                        [x = 1]

Funktion: lopow (expr, x)

  Gibt den kleinsten Exponenten von x zurück, der im Ausdruck expr auftritt. Treten symbolische Exponententen auf, wird ein Ausdruck mit `min` zurückgegeben. Ist das Argument x nicht im Ausdruck enthalten, ist die Rückgabe 0.

  Die Funktion `lopow` betrachtet keine äquivalenten Ausdrücke. Daher können die Ausdrücke `expand(expr)` und expr ein verschiedenes Ergebnis haben.

  Siehe auch die Funktionen `hipow` und `coeff`.

  Beispiele:

      (%i1) lopow ((x+y)^2 + (x+y)^a, x+y);
      (%o1)                       min(a, 2)

Funktion: lratsubst (L, expr)

  Ist analog zum Kommando `subst (L, expr)` mit dem Unterschied, dass anstatt der Funktion `subst` die Funktion `ratsubst` genutzt wird.

  Das erste Argument der Funktion `lratsubst` ist eine Gleichung oder eine Liste mit Gleichungen, die dem Format der Funktion `subst` entsprechen. Die Substitutionen werden in der Reihenfolge der Gleichungen der Liste von links nach rechts ausgeführt.

  Mit dem Kommando `lrats` werden die Funktionen `fullratsubst` und `lratsubst` geladen. Siehe auch die Funktion `fullratsubst`.

  Beispiele:

      (%i1) load ("lrats")$

  `subst` kann mehrfache Substitutionen ausführen. `lratsubst` ist analog zu `subst`.

      (%i2) subst ([a = b, c = d], a + c);
      (%o2)                         d + b
      (%i3) lratsubst ([a^2 = b, c^2 = d], (a + e)*c*(a + c));
      (%o3)                (d + a c) e + a d + b c

  Soll nur eine Substitution ausgeführt werden, kann eine einzelne Gleichung als erstes Argument angegeben werden.

      (%i4) lratsubst (a^2 = b, a^3);
      (%o4)                          a b

Optionsvariable: modulus

  Standardwert: `false`

  Hat die Optionsvariable `modulus` eine positive Zahl p als Wert, werden Operationen für rationale Zahlen, wie von der Funktion `rat` und verwandte Funktionen, modulo p ausgeführt.

  `n` mod p ist definiert als eine ganze Zahl, die für ungerade p die Werte `[-(p-1)/2, ..., 0, ..., (p-1)/2]` annimmt und für gerade p die Werte `[-(p/2 - 1), ..., 0, ...., p/2]`, so dass `a p + k` gleich n ist für eine ganze Zahl a.

  Liegt ein Ausdruck expr bereits in einer CRE-Form vor und wird der Wert der Optionsvariable `modulus` geändert, dann sollte der Ausdruck zum Beispiel mit dem Kommando `expr: rat (ratdisrep (expr))` zunächst in die Standardform gebracht werden, um dann erneut in die CRE-Form umgewandelt zu werden, um korrekte Ergebnisse zu erzielen.

  Typischerweise erhält die Optionsvariable `modulus` eine Primzahl als Wert. Erhält `modulus` eine positive ganze Zahl als Wert, die nicht eine Primzahl ist, wird die Zuweisung akzeptiert, jedoch eine Warnung ausgegeben. Wird Null oder eine negative Zahl zugewiesen signalisiert Maxima einen Fehler.

  Beispiele:

      (%i1) modulus:7;
      (%o1)                           7
      (%i2) polymod([0,1,2,3,4,5,6,7]);
      (%o2)            [0, 1, 2, 3, - 3, - 2, - 1, 0]
      (%i3) modulus:false;
      (%o3)                         false
      (%i4) poly:x^6+x^2+1;
                                  6    2
      (%o4)                      x  + x  + 1
      (%i5) factor(poly);
                                  6    2
      (%o5)                      x  + x  + 1
      (%i6) modulus:13;
      (%o6)                          13
      (%i7) factor(poly);

                            2        4      2
      (%o7)               (x  + 6) (x  - 6 x  - 2)

      (%i8) polymod(%);
                                  6    2
      (%o8)                      x  + x  + 1

Funktion: num (expr)

  Gibt den Zähler des Ausdrucks expr zurück, wenn dieser ein Quotient ist. Ist der Ausdruck expr kein Quotient wird expr zurückgegeben.

  Die Funktion `num` wertet das Argument aus. Siehe auch die Funktion `denom`.

  Beispiel:

      (%i1) num(x^2/(x+1));
                                      2
      (%o1)                          x

Funktion: partfrac (expr, var)

  Führt für den Ausdruck expr eine vollständige Partialbruchzerlegung aus.

      (%i1) 1/(1+x)^2 - 2/(1+x) + 2/(2+x);
                            2       2        1
      (%o1)               ----- - ----- + --------
                          x + 2   x + 1          2
                                          (x + 1)
      (%i2) ratsimp (%);
                                       x
      (%o2)                 - -------------------
                               3      2
                              x  + 4 x  + 5 x + 2
      (%i3) partfrac (%, x);
                            2       2        1
      (%o3)               ----- - ----- + --------
                          x + 2   x + 1          2
                                          (x + 1)

Funktion: polydecomp (p, x)

  Zerlegt das Polynom p in der Variablen x in Polynome, die miteinander verkettet das ursprüngliche Polynom ergeben. `polydecomp` gibt eine Liste `[p_1, ..., p_n]` zurück, so dass der folgende Ausdruck gleich dem Polynom p ist:

      lambda ([x], p_1) (lambda ([x], p_2) (... (lambda ([x], p_n) (x))
        ...))

  Der Grad des Polynoms p_i ist größer als 1 für i kleiner als n.

  Eine solche Zerlegung ist nicht eindeutig.

  Beispiele:

      (%i1) polydecomp (x^210, x);
                                7   5   3   2
      (%o1)                   [x , x , x , x ]
      (%i2) p : expand (subst (x^3 - x - 1, x, x^2 - a));
                      6      4      3    2
      (%o2)          x  - 2 x  - 2 x  + x  + 2 x - a + 1
      (%i3) polydecomp (p, x);
                              2       3
      (%o3)                 [x  - a, x  - x - 1]

  Die folgende Funktion verkettet die Elemente der Liste `L = [e_1, ..., e_n]` zu einer Funktion in der Variablen x. Diese Funktion ist die Inverse Operation zu der Funktion `polydecomp`.

      compose (L, x) :=
        block ([r : x], for e in L do r : subst (e, x, r), r) $

  Anwendung der Funktionen `compose` und `polydecomp`.

      (%i3) polydecomp (compose ([x^2 - a, x^3 - x - 1], x), x);
                              2       3
      (%o3)                 [x  - a, x  - x - 1]

  Während `compose (polydecomp (p, x), x)` immer das Polynom p als Ergebnis hat, hat `polydecomp (compose ([p_1, ..., p_n], x), x)` nicht notwendigerweise das Ergebnis `[p_1, ..., p_n]`.

      (%i4) polydecomp (compose ([x^2 + 2*x + 3, x^2], x), x);
                                2       2
      (%o4)                   [x  + 2, x  + 1]
      (%i5) polydecomp (compose ([x^2 + x + 1, x^2 + x + 1], x), x);

                            2       2
                           x  + 3  x  + 5
      (%o5)               [------, ------, 2 x + 1]
                             4       2

Funktion: polymod (p)
Funktion: polymod (p, m)

  Konvertiert das Polynom p in eine modulare Darstellung bezüglich dem aktuellen Modul. Das Modul ist der Wert der Variablen `modulus`.

  `polymod(p, m` konvertiert das Polynom bezüglich dem Modul m, anstatt dem aktuellen Modul `modulus`.

  Siehe auch `modulus`.

Funktion: powers (expr, x)

  Gibt eine Liste mit den Potenzen der Variablen x zurück, die im Ausdruck expr auftreten.

  Mit dem Kommando `load("powers")` wird die Funktion geladen.

Funktion: quotient (p_1, p_2)
Funktion: quotient (p_1, p_2, x_1, …, x_n)

  Berechnet den Quotienten der Polynome p_1 und p_2 für die Variable x_n. Die anderen Variablen x_1, …, x_n-1 haben dieselbe Bedeutung wie für die Funktion `ratvars`.

  `quotient` gibt das erste Element des Ergebnisses der Funktion `divide` zurück.

  Siehe auch die Funktion `remainder`.

  Beispiel:

      (%i1) poly1 : x^3-2*x^2-5*x+7;
                              3      2
      (%o1)                  x  - 2 x  - 5 x + 7
      (%i2) poly2 : x-1;
      (%o2)                         x - 1
      (%i3) quotient(poly1, poly2, x);
                                  2
      (%o3)                      x  - x - 6

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

  Konvertiert einen Ausdruck expr in die CRE-Form. Der Ausdruck wird so expandiert und gruppiert, dass alle Terme einen gemeinsamen Nenner haben und der größte gemeinsame Teiler gekürzt ist. Weiterhin werden Gleitkommazahlen in rationale Zahlungen umgewandelt. Die Toleranz der Umwandlung wird von der Optionsvariablen `ratepsilon` kontrolliert. Die Variablen im Ausdruck werden entsprechend der Funktion `ratvars` gemäß der angegebenen Argumente x_1, …, x_n angeordnet.

  `rat` vereinfacht im Allgemeinen keine Ausdrücke bis auf die Addition `+`, Subtraktion `-`, Multiplikation `*`, Division `/` und die Exponentiation `^` mit einer ganzen Zahl. Dagegen führt die Funktion `ratsimp` auch weitere Vereinfachungen aus. Variablen und Zahlen in einer CRE-Form sind nicht identisch mit denen in der Standardform. Zum Beispiel hat `rat(x)- x` das Ergebnis `rat(0)`, welches eine andere interne Darstellung als `0` hat.

  Hat die Optionsvariable `ratfac` den Wert `true`, wird ein Ausdruck von der Funktion `rat` nur teilweise faktorisiert. Bei der Ausführung von Operationen wird bleibt der Ausdruck so vollständig als möglich in seiner faktorisierten Form, ohne dass eine Faktorisierung ausgeführt wird. Damit kann Rechenzeit eingespart werden.

  Hat die Optionsvariable `ratprint` den Wert `false`, werden Meldungen unterdrückt, wenn eine Gleitkommazahl in eine rationale umgewandelt wird.

  Hat die Optionsvariable `keepfloat` den Wert `true`, werden Gleitkommazahlen nicht in rationale Zahlen umgewandelt.

  Siehe auch die Funktionen `ratexpand` und `ratsimp`, um Ausdrücke zu vereinfachen, sowie die Funktion `ratdisrep`, um einen Ausdruck von einer CRE-Form in eine allgemeine Form zu transformieren.

  Beispiele:

      (%i1) ((x - 2*y)^4/(x^2 - 4*y^2)^2 + 1)*(y + a)*(2*y + x) /
            (4*y^2 + x^2);
                                                 4
                                        (x - 2 y)
                    (y + a) (2 y + x) (------------ + 1)
                                         2      2 2
                                       (x  - 4 y )
      (%o1)         ------------------------------------
                                    2    2
                                 4 y  + x
      (%i2) rat (%, y, a, x);

                                  2 a + 2 y
      (%o2)/R/                    ---------
                                   x + 2 y

Optionsvariable: ratalgdenom

  Standardwert: `true`

  Hat die Optionsvariable `ratalgdenom` den Wert `true`, versucht Maxima den Nenner beim Auftreten von Wurzeln rational zu machen. `ratalgdenom` wirkt sich nur aus, wenn die Optionsvariable `algebraic` den Wert `true` hat und der Ausdruck in einer CRE-Form vorliegt.

  Beispiele:

      (%i1) algebraic:true$

      (%i2) ratalgdenom:false$

      (%i3) rat(sqrt(3)/sqrt(2));
                                   sqrt(3)
      (%o3)/R/                     -------
                                   sqrt(2)
      (%i4) ratalgdenom:true$

      (%i5) rat(sqrt(3)/sqrt(2));
                               sqrt(2) sqrt(3)
      (%o5)/R/                 ---------------
                                      2
      (%i6) algebraic:false$

      (%i7) rat(sqrt(3)/sqrt(2));
                                   sqrt(3)
      (%o7)/R/                     -------
                                   sqrt(2)

Funktion: ratcoef (expr, x, n)
Funktion: ratcoef (expr, x)

  Gibt den Koeffizienten des Ausdrucks `x^n` in dem Argument expr zurück. Wenn das Argument n nicht angegeben ist, wird der Wert zu `1` angenommen.

  Die Rückgabe ist frei von der Variablen x. Existiert kein Koeffizient `x^n` dann ist die Rückgabe `0`.

  `ratcoef` expandiert und vereinfacht das Argument expr. Daher kann `ratcoef` ein anderes Ergebnis als die Funktion `coeff` haben, die keine Vereinfachungen ausführt. Daher `ratcoef((x + 1)/y + x, x)` das Ergebnis `(y + 1)/y` und nicht das Ergebnis `1` wie es von der Funktion `coeff` zurückgegeben wird.

  `ratcoef(expr, x, 0)` gibt eine Summe der Terme zurück, die die Variable x nicht enthalten.

  Beispiele:

      (%i1) s: a*x + b*x + 5$
      (%i2) ratcoef (s, a + b);
      (%o2)                           x

Funktion: ratdenom (expr)

  Gibt den Nenner des Argumentes expr zurück. `ratdenom` wandelt den Ausdruck zuerst in eine CRE-Form um und gibt das Ergebnis in einer CRE-Form zurück.

  Das Argument expr wird von der Funktion `rat` in eine CRE-Form gebracht, falls expr nicht bereits in einer CRE-Form vorliegt. Diese Transformation kann den Ausdruck expr verändern, da alle Terme über einen gemeinsamen Nenner zusammengefasst werden.

  Die Funktion `denom` ist vergleichbar. `denom` wandelt den Ausdruck jedoch nicht eine CRE-Form um und hat als Ergebnis einen Ausdruck in der Standardform. Daher können sich die Ergebnisse von `ratdenom` und `denom` voneinander unterscheiden.

  Beispiel:

      (%i1) expr: expand((x^2+2*x+3)/(x-1));

                              2
                             x       2 x      3
      (%o1)                 ----- + ----- + -----
                            x - 1   x - 1   x - 1

      (%i2) ratdenom(expr);
      (%o2)/R/                      x - 1
      (%i3) denom(expr);
      (%o3)                           1

Optionsvariable: ratdenomdivide

  Standardwert: `true`

  Hat die Optionsvariable `ratdenomdivide` den Wert `true`, expandiert die Funktion `ratexpand` einen Quotienten der im Zähler eine Summe hat, in eine Summe der Quotienten. Ansonsten werden die Terme über einen gemeinsamen Nenner zusammengefasst.

  Beispiele:

      (%i1) expr: (x^2 + x + 1)/(y^2 + 7);
                                  2
                                 x  + x + 1
      (%o1)                      ----------
                                    2
                                   y  + 7
      (%i2) ratdenomdivide: true$
      (%i3) ratexpand (expr);
                             2
                            x        x        1
      (%o3)               ------ + ------ + ------
                           2        2        2
                          y  + 7   y  + 7   y  + 7
      (%i4) ratdenomdivide: false$
      (%i5) ratexpand (expr);
                                  2
                                 x  + x + 1
      (%o5)                      ----------
                                    2
                                   y  + 7
      (%i6) expr2: a^2/(b^2 + 3) + b/(b^2 + 3);

                                           2
                                 b        a
      (%o6)                    ------ + ------
                                2        2
                               b  + 3   b  + 3

      (%i7) ratexpand (expr2);
                                        2
                                   b + a
      (%o7)                        ------
                                    2
                                   b  + 3

Funktion: ratdiff (expr, x)

  Differenziert einen rationalen Ausdruck expr nach der Variablen x. expr muss eine rationale Funktion oder ein Polynom in der Variablen x sein. Das Argument x kann ein Teilausdruck des Argumentes expr sein.

  Das Ergebnis ist äquivalent zum Ergebnis der Funktion `diff`, kann aber eine andere Form haben. Für rationale Funktionen kann die Funktion `ratdiff` schneller sein.

  `ratdiff` gibt das Ergebnis in einer CRE-Form zurück, wenn das Argument in einer CRE-Form vorliegt. Ansonsten ist das Ergebnis in der Standardform.

  `ratdiff` beachtet nur die Abhängigkeit des Ausdrucks von der Variablen x. Abhängigkeiten die mit der Funktion `depends` definiert werden, werden von der Funktion `ratdiff` ignoriert.

  Beispiele:

      (%i1) expr: (4*x^3 + 10*x - 11)/(x^5 + 5);
                                 3
                              4 x  + 10 x - 11
      (%o1)                   ----------------
                                    5
                                   x  + 5
      (%i2) ratdiff (expr, x);
                          7       5       4       2
                       8 x  + 40 x  - 55 x  - 60 x  - 50
      (%o2)          - ---------------------------------
                                10       5
                               x   + 10 x  + 25
      (%i3) expr: f(x)^3 - f(x)^2 + 7;
                               3       2
      (%o3)                   f (x) - f (x) + 7
      (%i4) ratdiff (expr, f(x));
                                 2
      (%o4)                   3 f (x) - 2 f(x)
      (%i5) expr: (a + b)^3 + (a + b)^2;
                                    3          2
      (%o5)                  (b + a)  + (b + a)
      (%i6) ratdiff (expr, a + b);

                          2                    2
      (%o6)            3 b  + (6 a + 2) b + 3 a  + 2 a

Funktion: ratdisrep (expr)

  Gibt das Argument expr als einen allgemeinen Ausdruck zurück. Ist expr bereits ein allgemeiner Ausdruck, wird dieser unverändert zurückgegeben.

  Im Allgemeinen wird die Funktion `ratdisrep` aufgerufen, um einen Ausdruck von der CRE-Form in einen allgemeinen Ausdruck umzuwandeln.

  Siehe auch die Funktion `totaldisrep`.

Funktion: ratexpand (expr)
Optionsvariable: ratexpand

  Expandiert das Argument expr indem Produkte und Potenzen von Summen ausmultipliziert, Brüche über einen gemeinsamen Nenner dargestellt werden und der größte gemeinsamen Teiler heraus gekürzt wird. Ist der Zähler eine Summe, wird er in seine Terme aufgespalten, die jeweils durch den Nenner dividiert werden.

  Die Rückgabe der Funktion `ratexpand` ist ein allgemeiner Ausdruck, auch wenn das Argument expr ein Ausdruck in der CRE-Form ist.

  Die Optionsvariable `ratexpand` kontrolliert die Vereinfachung der Funktion `ratsimp`. Hat `ratexpand` den Wert `true`, wird ein Ausdruck vollständig ausmultipliziert. Ist der Wert `false`, wird der Ausdruck nur bezüglich der Hauptvariablen ausmultipliziert. Zum Beispiel hat `ratsimp((x+1)*(y+1))` das Ergebnis `x y + y + x + 1`, wenn `ratexpand` den Wert `true` hat, ansonsten ist das Ergebnis `(x + 1) y + x + 1`. Siehe auch die Funktion `ratsimp`.

  Hat die Optionsvariable `ratdenomdivide` den Wert `true`, expandiert die Funktion `ratexpand` einen Quotienten der im Zähler eine Summe hat, in eine Summe der Quotienten. Ansonsten werden die Terme über einen gemeinsamen Nenner zusammengefasst.

  Hat die Optionsvariable `keepfloat` den Wert `true`, werden Gleitkommazahlen im Argument expr nicht in rationale Zahlen umgewandelt, wenn der Ausdruck in eine CRE-Form umgewandelt wird.

  Beispiele:

      (%i1) ratexpand ((2*x - 3*y)^3);
                           3         2       2        3
      (%o1)          - 27 y  + 54 x y  - 36 x  y + 8 x
      (%i2) expr: (x - 1)/(x + 1)^2 + 1/(x - 1);

                               x - 1       1
      (%o2)                   -------- + -----
                                     2   x - 1
                              (x + 1)

      (%i3) expand (expr);
                          x              1           1
      (%o3)          ------------ - ------------ + -----
                      2              2             x - 1
                     x  + 2 x + 1   x  + 2 x + 1
      (%i4) ratexpand (expr);
                              2
                           2 x                 2
      (%o4)           --------------- + ---------------
                       3    2            3    2
                      x  + x  - x - 1   x  + x  - x - 1

Optionsvariable: ratfac

  Standardwert: `false`

  Hat die Optionsvariable `ratfac` den Wert `true`, werden Ausdrücke in einer CRE-Form nur teilweise faktorisiert. Bei der Ausführung von Operationen bleibt der Ausdruck so vollständig als möglich in seiner faktorisierten Form, ohne dass eine Faktorisierung mit der Funktion `factor` ausgeführt wird. Auf diese Weise kann Rechenzeit eingespart werden.

  Der `ratweight`-Mechanismus ist nicht kompatibel mit dem Setzen der Variablen `ratfac`.

Funktion: ratnumer (expr)

  Gibt den Zähler des Argumentes expr zurück. `ratnumer` wandelt den Ausdruck zuerst in eine CRE-Form um und gibt das Ergebnis in einer CRE-Form zurück.

  Das Argument expr wird von der Funktion `rat` in eine CRE-Form gebracht, falls expr nicht bereits in einer CRE-Form vorliegt. Diese Transformation kann den Ausdruck expr verändern, da alle Terme über einen gemeinsamen Nenner zusammengefasst werden.

  Die Funktion `num` ist vergleichbar. `num` wandelt den Ausdruck jedoch nicht eine CRE-Form um und hat als Ergebnis einen Ausdruck in der Standardform. Daher können sich die Ergebnisse von `ratnumer` und `num` voneinander unterscheiden.

Funktion: ratp (expr)

  Gibt das Ergebnis `true` zurück, wenn das Argument expr in einer CRE-Form oder einer erweiterten CRE-Form vorliegt.

  CRE-Formen werden von der Funktion `rat` und verwandten Funktionen erzeugt. Erweiterte CRE-Formen werden von der Funktion `taylor` und verwandten Funktionen erzeugt.

Optionsvariable: ratprint

  Standardwert: `true`

  Hat die Optionsvariable `ratprint` den Wert `true`, gibt Maxima eine Meldung aus, wenn eine Gleitkommazahl in eine rationale Zahl umgewandelt wird.

  Beispiel:

      (%i1) ratprint:true;
      (%o1)                         true
      (%i2) rat(0.75*x);

      rat: replaced 0.75 by 3/4 = 0.75
                                     3 x
      (%o2)/R/                       ---
                                      4
      (%i3) ratprint:false;
      (%o3)                         false
      (%i4) rat(0.75*x);
                                     3 x
      (%o4)/R/                       ---
                                      4

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

  Vereinfacht den Ausdruck expr und alle Teilausdrücke, einschließlich der nicht rationalen Anteile. Das Ergebnis ist ein Quotient aus zwei Polynomen in einer rekursiven Form. In der rekursiven Form ist das Polynom nach der Hauptvariablen vollständig ausmultipliziert und ein Polynom in allen anderen Variablen. Variable können auch nicht-rationale Ausdrücke wie `sin(x^2 + 1)` sein.

  `ratsimp(expr, x_1, ..., x_n)` vereinfacht einen Ausdruck mit einer Ordnung der Variablen wie sie von der Funktion `ratvars` definiert wird.

  Hat die Optionsvariable `ratsimpexpons` den Wert `true`, wird `ratsimp` auch auf die Exponenten von Ausdrücke angewendet.

  Siehe auch die Funktion `ratexpand`. Die Funktion `ratsimp` wird auch von einigen Schaltern kontrolliert, die Einfluss auf `ratexpand` haben.

  Beispiele:

      (%i1) sin (x/(x^2 + x)) = exp ((log(x) + 1)^2 - log(x)^2);
                                               2      2
                         x         (log(x) + 1)  - log (x)
      (%o1)        sin(------) = %e
                        2
                       x  + x
      (%i2) ratsimp (%);
                                   1          2
      (%o2)                  sin(-----) = %e x
                                 x + 1
      (%i3) ((x - 1)^(3/2) - (x + 1)*sqrt(x - 1))/sqrt((x - 1)*(x + 1));

                             3/2
                      (x - 1)    - sqrt(x - 1) (x + 1)
      (%o3)           --------------------------------
                           sqrt((x - 1) (x + 1))

      (%i4) ratsimp (%);

                                 2 sqrt(x - 1)
      (%o4)                    - -------------
                                       2
                                 sqrt(x  - 1)

      (%i5) x^(a + 1/a), ratsimpexpons: true;
                                     2
                                    a  + 1
                                    ------
                                      a
      (%o5)                        x

Optionsvariable: ratsimpexpons

  Standardwert: `false`

  Hat die Optionsvariable `ratsimpexpons` den Wert `true`, wird `ratsimp` auch auf die Exponenten von Ausdrücke angewendet.

  Beispiel:

      (%i1) expr: x^(a+1/a);
                                   a + 1/a
      (%o1)                       x
      (%i2) ratsimpexpons: false;
      (%o2)                         false
      (%i3) ratsimp(expr);
                                   a + 1/a
      (%o3)                       x
      (%i4) ratsimpexpons: true;
      (%o4)                         true
      (%i5) ratsimp(expr);
                                     2
                                    a  + 1
                                    ------
                                      a
      (%o5)                        x

Optionsvariable: radsubstflag

  Standardwert: `false`

  Hat `radsubstflag` den Wert `true`, werden Wurzeln von der Funktion `ratsubst` auch dann substituiert, wenn diese nicht explizit im Ausdruck enthalten sind.

  Beispiel:

      (%i1) radsubstflag: false$
      (%i2) ratsubst (u, sqrt(x), x);
      (%o2)                           x
      (%i3) radsubstflag: true$
      (%i4) ratsubst (u, sqrt(x), x);
                                      2
      (%o4)                          u

Funktion: ratsubst (a, b, c)

  Substituiert a für b in den Ausdruck c und gibt das Ergebnis der Substitution zurück.

  Im Unterschied zu `subst` kann `ratsubst` auch Teilausdrücke im Ausdruck c substituieren. So hat `subst(a, x + y, x + y + z)` das Ergebnis `x + y + z` und `ratsubst` das Ergebnis `z + a`.

  Hat `radsubstflag` den Wert `true`, werden Wurzeln von der Funktion `ratsubst` auch dann substituiert, wenn diese nicht explizit im Ausdruck enthalten sind.

  Beispiel:

      (%i1) ratsubst (a, x*y^2, x^4*y^3 + x^4*y^8);
                                    3      4
      (%o1)                      a x  y + a
      (%i2) cos(x)^4 + cos(x)^3 + cos(x)^2 + cos(x) + 1;
                     4         3         2
      (%o2)       cos (x) + cos (x) + cos (x) + cos(x) + 1
      (%i3) ratsubst (1 - sin(x)^2, cos(x)^2, %);
                  4           2                     2
      (%o3)    sin (x) - 3 sin (x) + cos(x) (2 - sin (x)) + 3
      (%i4) ratsubst (1 - cos(x)^2, sin(x)^2, sin(x)^4);

                              4           2
      (%o4)                cos (x) - 2 cos (x) + 1

      (%i5) radsubstflag: false$
      (%i6) ratsubst (u, sqrt(x), x);
      (%o6)                           x
      (%i7) radsubstflag: true$
      (%i8) ratsubst (u, sqrt(x), x);
                                      2
      (%o8)                          u

Funktion: ratvars (x_1, …, x_n)
Funktion: ratvars ()
Systemvariable: ratvars

  Deklariert die Variablen x_1, …, x_n zu Hauptvariablen einer rationalen Funktion. Ist die Variable x_n in einem Ausdruck vorhanden, wird diese zur Hauptvariablen. Ist x_n nicht im Ausdruck vorhanden, wird einer der vorhergehenden Variablen x_i zur Hauptvariablen.

  Eine Variable einer rationalen Funktion, die nicht unter den x_1, …, x_n ist, erhält eine geringe Priorität als x_1.

  Die Argumente der Funktion `ratvars` können auch nicht-rationale Ausdrücke wie `sin(x)` sein.

  Die Systemvariable `ratvars` enthält die Liste der zuletzt mit der Funktion `ratvars` zu Hauptvariablen erklärten Variablen. Jeder Aufruf der Funktion `ratvars` setzt diese Liste zurück. Der Aufruf ohne Argumente `ratvars()` löscht die Systemvariable `ratvars`.

Funktion: ratweight (x_1, w_1, …, x_n, w_n)
Funktion: ratweight ()

  Weist der Variablen x_i ein Gewicht w_i zu. Hat ein Term einer rationalen Funktion ein größeres Gewicht als der Wert der Variablen `ratwtlvl` wird der Term durch `0` ersetzt. Das Gewicht eines Terms wird anhand der mit `ratweight` den Variablen zugewiesenen Gewichte ermittelt. Die Gewichte der Variablen in einem Term werden mit der Potenz der Variablen multipliziert und dann addiert. Zum Beispiel hat der Term `3 x_1^2 x_2` das Gewicht `2 w_1 + w_2`. Terme die den Wert von `ratwtlvl` übersteigen, werden nur dann entfernt, wenn rationale Funktionen in einer CRE-Form multipliziert oder potenziert werden.

  `ratweight()` gibt die Liste der zugewiesenen Gewichte zurück.

  Der `ratweight`-Mechanismus ist nicht kompatibel mit dem Setzen der Variablen `ratfac`.

  Beispiele:

      (%i1) ratweight (a, 1, b, 1);
      (%o1)                     [a, 1, b, 1]
      (%i2) expr1: rat(a + b + 1)$
      (%i3) expr1^2;
                        2                  2
      (%o3)/R/         b  + (2 a + 2) b + a  + 2 a + 1
      (%i4) ratwtlvl: 1$
      (%i5) expr1^2;
      (%o5)/R/                  2 b + 2 a + 1

System variable: ratweights

  Standardwert: `[]`

  Die Systemvariable `ratweights` enthält die Liste der Gewichte die Variablen mit der Funktion `ratweights` zugewiesen sind.

  Die Gewichte können mit dem Kommando `kill(ratweights)` gelöscht werden.

Optionsvariable: ratwtlvl

  Standardwert: `false`

  Die Optionsvariable wird im Zusammenhang mit den `ratweight`-Mechanismus genutzt und kontrolliert das Entfernen von Termen einer rationalen Funktion in einer CRE-Form, wenn deren Gewicht den Wert von `ratwtlvl` übersteigt. Mit dem Standardwert `false` werden keine Terme entfernt.

Funktion: remainder (p_1, p_2)
Funktion: remainder (p_1, p_2, x_1, …, x_n)

  Berechnet den Rest der Polynomdivision von p_1 und p_2 für die Variable x_n. Die anderen Variablen x_1, …, x_n-1 haben dieselbe Bedeutung wie für die Funktion `ratvars`.

  `remainder` gibt das zweite Element des Ergebnisses der Funktion `divide` zurück.

  Siehe auch die Funktion `quotient`.

  Beispiel:

      (%i1) poly1 : x^3-2*x^2-5*x+7;
                              3      2
      (%o1)                  x  - 2 x  - 5 x + 7
      (%i2) poly2 : x^2+1;
                                    2
      (%o2)                        x  + 1
      (%i3) remainder(poly1, poly2, x);
      (%o3)                        9 - 6 x

Funktion: resultant (p_1, p_2, x)

  Berechnet die Resultante der Polynome p_1 und p_2 und eliminiert die unabhängige Variable x. Die Resultante ist die Determinante der Sylvestermatrix für die beiden Polynome. Das Ergebnis ist Null, wenn die beiden Polynome p_1 und p_2 einen gemeinsamen Faktor haben.

  Können die Polynome p_1 oder p_2 faktorisiert werden, kann es von Vorteil sein, die Faktorisierung zuvor auszuführen.

  Die Optionsvariable `resultant` kontrolliert, welcher Algorithmus für die Berechnung der Resultante von Maxima genutzt wird. Siehe die Optionsvariable `resultant`.

  Die Funktion `bezout` berechnet die Sylvestermatrix der Polynome p_1 und p_2. Die Determinante der Sylvestermatrix ist die Resultante.

  Beispiele:

      (%i1) resultant(2*x^2+3*x+1, 2*x^2+x+1, x);
      (%o1)                           8
      (%i2) resultant(x+1, x+1, x);
      (%o2)                           0
      (%i3) resultant((x+1)*x, (x+1), x);
      (%o3)                           0
      (%i4) resultant(a*x^2+b*x+1, c*x + 2, x);
                               2
      (%o4)                   c  - 2 b c + 4 a

      (%i5) bezout(a*x^2+b*x+1, c*x+2, x);
                              [ 2 a  2 b - c ]
      (%o5)                   [              ]
                              [  c      2    ]
      (%i6) determinant(%);
      (%o6)                   4 a - (2 b - c) c

Optionsvariable: resultant

  Standardwert: `subres`

  Die Optionsvariable `resultant` kontrolliert, welcher Algorithmus für die Berechnung der Resultante mit der Funktion `resultant` von Maxima genutzt wird. Die möglichen Werte sind:

  `subres`

    Subresultanten-Algorithmus

  `mod`

    Modularer Resultanten-Algorithmus

  `red`

    Reduzierter Subresultanten-Algorithmus

  Der Standwert `subres` ist für die meisten Probleme geeignet. Für große Polynome in einer oder zwei Variablen kann `mod` besser sein.

Optionsvariable: savefactors

  Standardwert: `false`

  Hat die Optionsvariable `savefactors` den Wert `true`, versuchen einige Funktionen bei der Vereinfachung eine bereits vorhandene Faktorisierung zu erhalten, um weitere Vereinfachungen zu beschleunigen.

Funktion: showratvars (expr)

  Gibt eine Liste mit den Variablen des Ausdrucks expr zurück. Der Ausdruck liegt in einer CRE-Form vor.

  Siehe auch die Funktion `ratvars`.

Funktion: sqfr (expr)

  Entspricht der Funktion `factor` mit dem Unterschied, dass faktorisierte Polynome quadratfrei sind.

  Beispiel:

      (%i1) sqfr (4*x^4 + 4*x^3 - 3*x^2 - 4*x - 1);
                                      2   2
      (%o1)                  (2 x + 1)  (x  - 1)

Funktion: tellrat (p_1, …, p_n)
Funktion: tellrat ()

  Fügt dem Ring der ganzen Zahlen, die algebraische Zahlen hinzu, die Lösungen der minimalen Polynome p_1, …, p_n sind. Jedes Argument p_i ist ein Polynom, dessen Koeffizienten ganze Zahlen sind.

  `tellrat(x)` bedeutet, dass in einer rationalen Funktion die Variable x mit dem Wert `0` substituiert wird.

  `tellrat()` gibt eine Liste der minimalen Polynome zurück.

  Die Optionsvariable `algebraic` muss den Wert `true` haben, damit die Vereinfachungen von algebraischen Zahlen ausgeführt wird.

  Maxima kennt bereits die Erweiterungen um die Imaginäre Einheit `%i` und die Wurzeln der ganzen Zahlen.

  Die Funktion `untellrat` entfernt die Eigenschaften, die mit der Funktion `tellrat` definiert wurden.

  Hat ein minimales Polynom mehrere Variablen, wie zum Beispiel in `tellrat(x^2 - y^2)`, dann entsteht eine Mehrdeutigkeit, da Maxima nicht ermitteln kann, ob x^2 für y^2 zu ersetzten ist, oder umgekehrt. In diesem Fall kann die Syntax `tellrat (y^2 = x^2)` genutzt werden, die besagt, dass y^2 durch x^2 zu ersetzen ist.

  Beispiele:

      (%i1) 10*(%i + 1)/(%i + 3^(1/3));

                                 10 (%i + 1)
      (%o1)                      -----------
                                        1/3
                                  %i + 3

      (%i2) ev (ratdisrep (rat(%)), algebraic);

                   2/3      1/3              2/3      1/3
      (%o2)    (4 3    - 2 3    - 4) %i + 2 3    + 4 3    - 2

      (%i3) tellrat (1 + a + a^2);
                                  2
      (%o3)                     [a  + a + 1]
      (%i4) 1/(a*sqrt(2) - 1) + a/(sqrt(3) + sqrt(2));
                            1                 a
      (%o4)           ------------- + -----------------
                      sqrt(2) a - 1   sqrt(3) + sqrt(2)
      (%i5) ev (ratdisrep (rat(%)), algebraic);
               (7 sqrt(3) - 10 sqrt(2) + 2) a - 2 sqrt(2) - 1
      (%o5)    ----------------------------------------------
                                     7
      (%i6) tellrat (y^2 = x^2);
                              2    2   2
      (%o6)                 [y  - x , a  + a + 1]

Funktion: totaldisrep (expr)

  Konvertiert alle Teilausdrücke im Ausdruck expr von der CRE-Form in die allgemeine Form und gibt das Ergebnis zurück. Ist expr selbst eine CRE-Form, dann entspricht `totaldisrep` der Funktion `ratdisrep`.

  `totaldisrep` ist insbesondere hilfreich, wenn Gleichungen, Listen oder Matrizen in eine allgemeine Form zu konvertieren sind.

Funktion: untellrat (x_1, …, x_n)

  Entfernt Eigenschaften von den Symbolen x_1, …, x_n, die mit der Funktion `tellrat` zugewiesen wurden.

Previous: Einführung in Polynome, Nach oben: Polynome [Inhalt][Index]