| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
| 17.1 Einführung in Polynome | ||
| 17.2 Funktionen und Variablen für Polynome |
| [ < ] | [ > ] | [ << ] | [ Up ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
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] | [ ? ] |
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 die Funktion hipow
zum Einsatz, um den höchsten
Koeffizienten zu ermitteln. Die Funktionen cons
und reverse
werden verwendet, um die Koeffizienten einer Liste hinzufügen und um die
Liste zu invertieren.
coeff_list(a,x) :=
block([liste:[]],
for i:0 thru hipow(a,x) do
(
liste : cons(coeff(a,x,i),liste)
),
reverse(liste)
)$
(%i1) coeff_list(2*x^4+3*x^2+1,x); (%o1) [1, 0, 3, 0, 2]
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:
ezezgcd-Alogrithmus
subresSubresultanten-Algorithmus
redReduzierter modularer Algorithmus
spmodModularer Algorithmus
falsekein 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:
subresSubresultanten-Algorithmus
modModularer Resultanten-Algorithmus
redReduzierter 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.
| [ << ] | [ >> ] | [Top] | [Contents] | [Index] | [ ? ] |
This document was generated by Crategus on Dezember, 12 2012 using texi2html 1.76.