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

17. Polynome


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

17.1 Einführung in Polynome

Polynome werden in einer allgemeinen Darstellung oder in einer kanonischen Darstellung (CRE - Cannonical Rational Expressions) gespeichert. Die CRE-Darstellung ist die Standardform für Operationen mit Polynomen und wird intern von Funktionen wie factor oder ratsimp verwendet.

Ausdrücke in einer CRE-Form sind besonders für die Darstellung von Polynomen und rationalen Funktionen geeignet. Die CRE-Form nimmt eine Ordnung der Variablen an. Polynome werden rekursiv als eine Liste definiert, die als ersten Eintrag den Namen der Variablen und als nächste Einträge die Exponenten und Koeffizienten der Variablen enthalten. Der Koeffizient kann eine Zahl oder wiederum ein Polynom sein. Zum Beispiel hat das Polynom 3*x^2-1 die Darstellung (X 2 3 0 -1) und das Polynom 2*x*y+x-3 die Darstellung (Y 1 (X 1 2) 0 (X 1 1 0 -3)), wenn y die Hauptvariable des Polynoms ist. Ist x die Hauptvariable des Polynoms, dann ist die Darstellung (X 1 (Y 1 2 0 1) 0 -3).

Die Ordnung der Variablen ist in der Regel umgekehrt alphabetisch. Die Variablen müssen keine Atome sein. Alle Ausdrücke, die nicht die Operatoren +, -, *, / oder ^ enthalten, werden in einer CRE-Darstellung als "Variable" angenommen. Zum Beispiel sind x, sqrt(x) und sin(x+1) die CRE-Variablen des Ausdrucks x+sin(x+1)+2*SQRT(x)+1. Wird vom Nutzer keine abweichende Ordnung der Variablen mit der Funktion ratvars definiert, nimmt Maxima eine alphabetische Ordnung der Variablen an.

Im Allgemeinen werden rationale Funktionen in einer CRE-Form dargestellt, die keinen gemeinsamen Faktor im Zähler und Nenner haben. Die interne Darstellung ist ein Paar von Polynomen, die jeweils den Zähler und den Nenner darstellen. Diesem Paar geht eine Liste mit der Ordnung der Variablen im Ausdruck voraus. Ein Ausdruck in einer CRE-Form oder der CRE-Formen enthält, wird in der Ausgabe mit dem Symbol /R/ gekennzeichnet. Mit der Funktion rat können allgemeine Ausdrücke in eine CRE-Form transformiert werden. Umgekehrt wird ein Ausdruck in einer CRE-Form mit der Funktion ratdisrep in eine allgemeine Form transformiert.

Für die Darstellung von Taylor-Polynomen der Funktion taylor wird eine erweiterte CRE-Form verwendet. In dieser Darstellung können die Exponenten von Polynomen auch rationale Zahlen sein. Weiterhin können die Koeffizienten rationale Funktionen sein. Die erweiterte CRE-Form enthält auch Informationen über den Grad des Polynoms. In der Ausgabe wird die erweiterte CRE-Form mit dem Symbol /T/ bezeichnet.


[ < ] [ > ]   [ << ] [ Up ] [ >> ]         [Top] [Contents] [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.


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

This document was generated by Jaime Villate on Oktober, 14 2014 using texi2html 1.76.