Vorige: Einführung in Polynome, Nach oben: Polynome [Inhalt][Index]
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
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
.
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
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
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 ]
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]
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
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
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)
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)]
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]
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.
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)
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
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)
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) )
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.
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
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
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]
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
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
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)
Entspricht der Funktion factorsum
mit den Unterschied, dass anstatt der
Funktion factor
die Funktion gfactor
angewendet wird, um den
Ausdruck expr zu faktorisieren.
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)
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.
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]
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)
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
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
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
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)
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
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
.
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.
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
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
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)
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
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
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
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
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
.
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
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
.
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.
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.
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
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
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
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
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
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
.
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
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.
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.
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
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
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.
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.
Gibt eine Liste mit den Variablen des Ausdrucks expr zurück. Der Ausdruck liegt in einer CRE-Form vor.
Siehe auch die Funktion ratvars
.
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)
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]
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.
Entfernt Eigenschaften von den Symbolen x_1, …, x_n, die mit
der Funktion tellrat
zugewiesen wurden.
Vorige: Einführung in Polynome, Nach oben: Polynome [Inhalt][Index]