Nächste: Poisson Reihen, Vorige: Einführung in Reihen, Nach oben: Summen, Produkte und Reihen [Inhalt][Index]
Für eine Funktion f_i einer Variablen x_i definiert
deftaylor den Ausdruck expr_i als die Taylorreihe um den Nullpunkt.
expr_i ist typischerweise ein Polynom in der Variablen x_i oder eine
Summe. deftaylor akzeptiert aber auch allgemeinere Ausdrücke.
powerseries(f_i(x_i), x_i, 0) gibt die Reihe zurück,
die mit deftaylor definiert wurde.
deftaylor gibt eine Liste der Funktionen f_1, …, f_n
zurück. deftaylor wertet die Argumente aus.
Siehe auch taylor und powerseries.
Beispiele:
(%i1) deftaylor (f(x), x^2 + sum(x^i/(2^i*i!^2), i, 4, inf)); (%o1) [f] (%i2) powerseries (f(x), x, 0);
inf
==== i1
\ x 2
(%o2) > -------- + x
/ i1 2
==== 2 i1!
i1 = 4
(%i3) taylor (exp (sqrt (f(x))), x, 0, 4);
2 3 4
x 3073 x 12817 x
(%o3)/T/ 1 + x + -- + ------- + -------- + . . .
2 18432 307200
Standardwert: true
Hat maxtayorder den Wert true, werden bei der algebraischen
Manipulation von Taylor-Reihen, von der Funktion taylor so viele
Terme wie möglich mitgeführt.
Gibt eine Liste aller rationalen Funktionen zurück, die die angegebene Taylor-Reihenentwicklung haben und deren Summe des Nennergrads und des Zählergrads kleiner oder gleich des Grads der Reihenentwicklung ist.
Das Argument taylor_series ist eine Taylor-Reihe in einer Variablen. Die Argumente numer_deg_bound und denom_deg_bound sind positive ganze Zahlen, die eine Grenze für den Nennergrad und den Zählergrad der rationalen Funktion angeben.
Die Taylor-Reihe kann auch eine Laurent-Reihe sein und die Grenzen für den
Grad können inf sein.
Siehe auch taylor.
Beispiele:
(%i1) taylor (1 + x + x^2 + x^3, x, 0, 3);
2 3
(%o1)/T/ 1 + x + x + x + . . .
(%i2) pade (%, 1, 1);
1
(%o2) [- -----]
x - 1
(%i3) t: taylor(-(83787*x^10 - 45552*x^9 - 187296*x^8
+ 387072*x^7 + 86016*x^6 - 1507328*x^5
+ 1966080*x^4 + 4194304*x^3 - 25165824*x^2
+ 67108864*x - 134217728)
/134217728, x, 0, 10);
2 3 4 5 6 7
x 3 x x 15 x 23 x 21 x 189 x
(%o3)/T/ 1 - - + ---- - -- - ----- + ----- - ----- - ------
2 16 32 1024 2048 32768 65536
8 9 10
5853 x 2847 x 83787 x
+ ------- + ------- - --------- + . . .
4194304 8388608 134217728
(%i4) pade (t, 4, 4); (%o4) []
Es gibt keine rationale Funktion des Grads 4 im Zähler und Nenner für die
oben angegebene Taylor-Reihenentwicklung. Die Summe des Zählergrads und des
Nennergrads müssen mindestens gleich dem Grad der Reihenentwicklung sein.
In diesem Fall ist der Grad der Taylor-Reihenentwicklung 10.
(%i5) pade (t, 5, 5);
5 4 3
(%o5) [- (520256329 x - 96719020632 x - 489651410240 x
2
- 1619100813312 x - 2176885157888 x - 2386516803584)
5 4 3
/(47041365435 x + 381702613848 x + 1360678489152 x
2
+ 2856700692480 x + 3370143559680 x + 2386516803584)]
Gibt eine geschlossene Form für die Reihenentwicklung des Ausdrucks expr
in der Variablen x um den Punkt a zurück. Das Argument a
kann die Werte inf oder infinity haben. Die Reihenentwicklung
für eine Funktion f(x) hat die allgemeine Form:
inf
====
\ n
f(x) = > b (x - a)
/ n
====
n = 0
Mit den Koeffzienten:
!
d !
-- (f(x))!
dn !
!x = a
b = ---------------
n n!
Kann die Funktion powerseries keine Reihenentwicklung für den Ausdruck
expr finden, können möglicherweise mit der Funktion taylor die
ersten Terme der Reihenentwicklung berechnet werden.
Hat die Optionsvariable verbose den Wert true, werden Meldungen
zu den verwendeten Algorithmen von der Funktion powerseries angezeigt.
Beispiel:
(%i1) verbose: true$
(%i2) powerseries (log(sin(x)/x), x, 0);
trigreduce: can't expand
log(sin(x))
trigreduce: try again after applying the rule:
d
/ -- (sin(x))
[ dx
log(sin(x)) = I ----------- dx
] sin(x)
/
powerseries: first simplification returned
/
[
- log(x) + I cot(x) dx
]
/
inf
==== i1 - 1 + 2 i1 2 i1
\ (- 1) 2 bern(2 i1) x
(%o2) > ------------------------------------
/ i1 (2 i1)!
====
i1 = 1
Default value: false
When psexpand is true,
an extended rational function expression is displayed fully expanded.
The switch ratexpand has the same effect.
When psexpand is false,
a multivariate expression is displayed just as in the rational function package.
When psexpand is multi,
then terms with the same total degree in the variables are grouped together.
Die Funktion revert berechnet eine Taylorreihe in der Variablen x
um den Entwicklungspunkt Null, die der Taylorreihe der inversen Funktion
entspricht, die von der Taylorreihe expr repräsentiert wird. Das
Ergebnis ist ein Polynom in einer CRE-Darstellung mit dem Grad der höchsten
Potenz im Ausdruck expr.
Die Funktion revert2 entspricht der Funktion revert mit dem
Unterschied, dass mit dem dritten Argument n der Grad der neuen
Taylorreihe explizit angegeben werden kann. Dieser kann kleiner oder
größer als der Grad der Taylorreihe expr sein.
Mit dem Kommando load("revert") werden die Funktionen geladen.
Siehe auch die Funktion taylor.
Beispiel:
Die Inverse der Funktion exp(x) - 1 ist die Funktion log(x+1).
Mit dem Kommando revert(taylor(exp(x) - 1, x, 0, 6), x) wird die
Taylorreihe der Inversen log(x+1) berechnet.
(%i1) load ("revert")$
(%i2) t: taylor (exp(x) - 1, x, 0, 6);
2 3 4 5 6
x x x x x
(%o2)/T/ x + -- + -- + -- + --- + --- + . . .
2 6 24 120 720
(%i3) revert (t, x);
6 5 4 3 2
10 x - 12 x + 15 x - 20 x + 30 x - 60 x
(%o3)/R/ - --------------------------------------------
60
(%i4) ratexpand (%);
6 5 4 3 2
x x x x x
(%o4) - -- + -- - -- + -- - -- + x
6 5 4 3 2
(%i5) taylor (log(x+1), x, 0, 6);
2 3 4 5 6
x x x x x
(%o5)/T/ x - -- + -- - -- + -- - -- + . . .
2 3 4 5 6
(%i6) ratsimp (revert (t, x) - taylor (log(x+1), x, 0, 6));
(%o6) 0
(%i7) revert2 (t, x, 4);
4 3 2
x x x
(%o7) - -- + -- - -- + x
4 3 2
taylor(expr, x, a, n) entwickelt den Ausdruck
expr in eine Taylor- oder Laurent-Reihenwicklung in der Variablen x
um den Punkt a, die die Terme bis zur Ordnung (x -
a)^n enthält.
Hat der Ausdruck expr die Form f(x)/g(x)
und hat g(x) keine Terme bis zur Ordnung n, dann
versucht taylor den Ausdruck g(x) bis zur Ordnung
2 n zu entwickeln. Treten in der Entwicklung weiterhin keine
von Null verschiedenen Terme auf, verdoppelt taylor die Ordnung der
Entwicklung für g(x) so lange, wie die Ordnung kleiner
oder gleich n 2^taylordepth ist. Siehe auch taylordepth.
taylor(expr, [x_1, x_2, ...], a, n) gibt
die Reihenentwicklung der Ordnung n in allen Variablen x_1,
x_2, … um den Punkt a zurück.
Die beiden folgenden äquivalenten Kommandos taylor(expr,
[x_1, a_1, n_1], [x_2, a_2, n_2], ...) und
taylor(expr, [x_1, x_2, ...], [a_1,
a_2, ...], [n_1, n_2, ...]) geben eine Reihenentwicklung
für die Variablen x_1, x_2, … um den Punkt (a_1,
a_2, ...) mit den Ordnungen n_1, n_2, … zurück.
taylor(expr, [x, a, n, 'asymp]) entwickelt den
Ausdruck expr in negativen Potenzen von x - a. Der
Term mit der größten Ordnung ist (x - a)^-n.
Folgende Optionsvariablen kontrollieren die Berechnung einer Taylorreihe:
maxtayorderHat maxtayorder den Wert true, werden bei der algebraischen
Manipulation von Taylor-Reihen, von der Funktion taylor so viele
Terme wie möglich mitgeführt.
taylordepthFindet taylor keine von Null verschiedenen Terme in der
Reihenentwicklung, wird die Ordnung der Entwicklung solange erhöht wie sie
kleiner oder gleich 2^taylordepth ist.
taylor_logexpandDie Optionsvariable taylor_logexpand kontrolliert die Entwicklung von
Logarithmusfunktionen, die bei der Reihenentwicklung auftreten. Der
Standardwert ist true und die Logarithmusfunktionen in einer
Reihenentwicklung werden vollständig entwickelt.
taylor_order_coefficientsDie Optionsvariable taylor_order_coefficients kontrolliert die Anordung
von Termen in einer Reihenentwicklung. Der Standardwert ist true und
die Anordung entspricht der kanonischen Darstellung eines Ausdrucks.
taylor_truncate_polynomialsHat die Optionsvariable taylor_truncate_polynomials den Wert
false, wird das Ergebnis der Reihenentwicklung eines Polynoms als exakt
angenommen.
taylor_simplifierDie Funktion zur Vereinfachung der Koeffizienten einer Entwicklung ist in der Optionsvariablen taylor_simplifier enthalten. Der Standardwert ist
simplify. Der Variablen kann eine nutzerdefinierte Funktion zugewiesen
werden.
Mit der Funktion taylorp kann getestet werden, ob ein Ausdruck eine
Taylorreihe repräsentiert. Die Funktion taylorinfo gibt Informationen
zu einer Taylorreihe aus. Die spezielle CRE-Form einer Taylorreihe wird mit der
Funktion taytorat in eine Standardform gebracht.
Mit den Funktionen revert und revert2 kann die Taylorreihe einer
inversen Funktion berechnet werden.
Beispiele:
(%i1) taylor (sqrt (sin(x) + a*x + 1), x, 0, 3);
2 2
(a + 1) x (a + 2 a + 1) x
(%o1)/T/ 1 + --------- - -----------------
2 8
3 2 3
(3 a + 9 a + 9 a - 1) x
+ -------------------------- + . . .
48
(%i2) %^2;
3
x
(%o2)/T/ 1 + (a + 1) x - -- + . . .
6
(%i3) taylor (sqrt (x + 1), x, 0, 5);
2 3 4 5
x x x 5 x 7 x
(%o3)/T/ 1 + - - -- + -- - ---- + ---- + . . .
2 8 16 128 256
(%i4) %^2;
(%o4)/T/ 1 + x + . . .
(%i5) product ((1 + x^i)^2.5, i, 1, inf)/(1 + x^2);
inf
/===\
! ! i 2.5
! ! (x + 1)
! !
i = 1
(%o5) -----------------
2
x + 1
(%i6) ev (taylor(%, x, 0, 3), keepfloat);
2 3
(%o6)/T/ 1 + 2.5 x + 3.375 x + 6.5625 x + . . .
(%i7) taylor (1/log (x + 1), x, 0, 3);
2 3
1 1 x x 19 x
(%o7)/T/ - + - - -- + -- - ----- + . . .
x 2 12 24 720
(%i8) taylor (cos(x) - sec(x), x, 0, 5);
4
2 x
(%o8)/T/ - x - -- + . . .
6
(%i9) taylor ((cos(x) - sec(x))^3, x, 0, 5);
(%o9)/T/ 0 + . . .
(%i10) taylor (1/(cos(x) - sec(x))^3, x, 0, 5);
2 4
1 1 11 347 6767 x 15377 x
(%o10)/T/ - -- + ---- + ------ - ----- - ------- - --------
6 4 2 15120 604800 7983360
x 2 x 120 x
+ . . .
(%i11) taylor (sqrt (1 - k^2*sin(x)^2), x, 0, 6);
2 2 4 2 4
k x (3 k - 4 k ) x
(%o11)/T/ 1 - ----- - ----------------
2 24
6 4 2 6
(45 k - 60 k + 16 k ) x
- -------------------------- + . . .
720
(%i12) taylor ((x + 1)^n, x, 0, 4);
2 2 3 2 3
(n - n) x (n - 3 n + 2 n) x
(%o12)/T/ 1 + n x + ----------- + --------------------
2 6
4 3 2 4
(n - 6 n + 11 n - 6 n) x
+ ---------------------------- + . . .
24
(%i13) taylor (sin (y + x), x, 0, 3, y, 0, 3);
3 2
y y
(%o13)/T/ y - -- + . . . + (1 - -- + . . .) x
6 2
3 2
y y 2 1 y 3
+ (- - + -- + . . .) x + (- - + -- + . . .) x + . . .
2 12 6 12
(%i14) taylor (sin (y + x), [x, y], 0, 3);
3 2 2 3
x + 3 y x + 3 y x + y
(%o14)/T/ y + x - ------------------------- + . . .
6
(%i15) taylor (1/sin (y + x), x, 0, 3, y, 0, 3);
1 y 1 1 1 2
(%o15)/T/ - + - + . . . + (- -- + - + . . .) x + (-- + . . .) x
y 6 2 6 3
y y
1 3
+ (- -- + . . .) x + . . .
4
y
(%i16) taylor (1/sin (y + x), [x, y], 0, 3);
3 2 2 3
1 x + y 7 x + 21 y x + 21 y x + 7 y
(%o16)/T/ ----- + ----- + ------------------------------- + . . .
x + y 6 360
Standardwert: 3
Findet die Funktion taylor keine von Null verschiedenen Terme in der
Reihenentwicklung, wird die Ordnung der Entwicklung solange erhöht wie sie
kleiner oder gleich 2^taylordepth ist.
Siehe auch taylor.
Gibt Informationen über die Taylorreihe expr zurück. Die Rückgabe ist eine Liste, die Listen mit den Namen der Variablen, den Entwicklungspunkten und den Ordnungen der Entwicklung enthalten.
Ist expr keine Taylorreihe, ist die Rückgabe false.
Beispiele:
(%i1) taylor ((1 - y^2)/(1 - x), x, 0, 3, [y, a, inf]);
2 2
(%o1)/T/ - (y - a) - 2 a (y - a) + (1 - a )
2 2
+ (1 - a - 2 a (y - a) - (y - a) ) x
2 2 2
+ (1 - a - 2 a (y - a) - (y - a) ) x
2 2 3
+ (1 - a - 2 a (y - a) - (y - a) ) x + . . .
(%i2) taylorinfo(%);
(%o2) [[y, a, inf], [x, 0, 3]]
Hat den Rückgabewert true, wenn das Argument expr eine
Taylorreihe ist. Ansonsten ist der Rückgabewert false.
Standardwert: true
taylor_logexpand kontrolliert die Entwicklung von Logarithmen in einer
Taylorreihe. Der Standardwert ist true und die Logarithmusfunktionen in
einer Reihenentwicklung werden vollständig entwickelt. Ansonsten werden
Logarithmusfunktionen so weit entwickelt, wie es notwendig ist, um eine formale
Reihenentwicklung zu erhalten.
Standardwert: true
Die Optionsvariable taylor_order_coefficients kontrolliert die Ordnung
der Koeffizienten einer Taylorreihenentwicklung.
Hat taylor_order_coefficients den Wert true, werden die
Koeffizienten kanonisch angeordnet.
Standardwert: SIMPLIFY
Die Optionsvariable taylor_simplifier enthält den Namen der Funktion,
die für die Vereinfachung der Koeffizienten einer Taylorreihenentwicklung
von taylor aufgerufen wird. Der Standardwert ist die Lisp-Funktion
SIMPLIFY.
Standardwert: true
Hat die Optionsvariable taylor_truncate_polynomials den Wert
false, wird das Ergebnis der Reihenentwicklung eines Polynoms als exakt
angenommen.
Beispiel:
(%i1) taylor(x^6+x^4+x^2,x,0,4),taylor_truncate_polynomials:true;
2 4
(%o1)/T/ x + x + . . .
(%i2) taylor(x^6+x^4+x^2,x,0,4),taylor_truncate_polynomials:false;
2 4
(%o2)/T/ x + x
Konvertiert den Ausdruck expr von der speziellen Darstellung einer Taylorreihenentwicklung in eine CRE-Form.
Beispiel:
(%i1) taylor(atan(x),x,0,5);
3 5
x x
(%o1)/T/ x - -- + -- + . . .
3 5
(%i2) taytorat(%);
5 3
3 x - 5 x + 15 x
(%o2)/R/ ------------------
15
Die Rückgabe der Funktion trunc ist ein Ausdruck, der das Argument
expr in der Ausgabe wie eine Taylorreihenentwicklung anzeigt. Der
Ausdruck expr wird ansonsten nicht modifiziert.
Beispiel:
(%i1) expr: x^2 + x + 1;
2
(%o1) x + x + 1
(%i2) trunc (expr);
2
(%o2) 1 + x + x + . . .
(%i3) is (expr = trunc (expr));
(%o3) true
Standardwert: false
Hat die Optionsvariable verbose den Wert true, werden von der
Funktion powerseries Meldungen über die verwendeten Algorithmen
ausgegeben.
Nächste: Poisson Reihen, Vorige: Einführung in Reihen, Nach oben: Summen, Produkte und Reihen [Inhalt][Index]