Zurück zum Inhaltsverzeichnis

Kapitel 15

Grenzwerte

Grenzwerte für x -> infinity und x -> x0

Die Verwendung von limit soll zunächst an einem einfachen Beispiel demonstriert werden

> restart:

> f:=(2*x+1)/(x-3);

f := (2*x+1)/(x-3)

Eine Zeichnung ist immer sinnvoll

> plot({limit(f,x=infinity),f},x=-10..15,-5..8);

[Maple Plot]

> #plot({limit(f,x=infinity),f},x=-infinity..infinity,-5..8);

>

Verhalten für große x

>

> Limit(f,x=infinity)=limit(f,x=infinity), Limit(f,x=-infinity)=limit(f,x=-infinity);

Limit((2*x+1)/(x-3),x = infinity) = 2, Limit((2*x+1...

Und nicht:

> subs(x=infinity,f);

undefined

Verhalten in einem Punkt

> Limit(f,x=0)=limit(f,x=0);

Limit((2*x+1)/(x-3),x = 0) = -1/3

Unstetigkeitsstelle mit uneigentlichem Grenzwert

> x0:=op(discont(f,x));

x0 := 3

> Limit(f,x=x0)=limit(f,x=x0), Limit(f,x=x0,left)=limit(f,x=x0,left),
Limit(f,x=x0,right)=limit(f,x=x0,right);

Limit((2*x+1)/(x-3),x = 3) = undefined, Limit((2*x+...

Und nicht:

> subs(x=x0,f);

Error, division by zero

Richtungsangaben

Es gibt vier Richtungsangaben für die Annäherung an einen Punkt

> for dir in [left,right,real, complex] do

> dir=limit(f,x=x0,dir) od;

left = -infinity

right = infinity

real = undefined

complex = infinity-infinity*I

>

Dem unendlich fernen Punkt kann man sich nur von einer Seite nähern

> limit(f,x=infinity,right);

Error, (in limit) inconsistent direction with infinities

Mit bidirektional gegen infinity ist gegen +- infinity gemeint:

> limit(f,x=infinity,real);

2

> limit(arctan(x),x=infinity,real);

undefined

denn

> limit(arctan(x),x=infinity);

1/2*Pi

> limit(arctan(x),x=-infinity);

-1/2*Pi

>

Endlicher Sprung

> f:=cos(x)/sqrt(1-sin(x));

f := cos(x)/(sqrt(1-sin(x)))

> discont(f,x);

{1/2*Pi+2*Pi*_Z1}

> plot(f, x=0..4*Pi);

[Maple Plot]

> limit( f, x=Pi/2);

undefined

> limit( f, x=Pi/2, left);

sqrt(2)

> limit( f, x=Pi/2, right);

-sqrt(2)

>

Hebbare Unstetigkeit

> f:=(sqrt(1+x)-1)/x;

f := (sqrt(1+x)-1)/x

> discont(f,x);

{-1, 0}

> plot(f,x=-1..10);

[Maple Plot]

>

Ein etwas schwierigeres Beispiel

> f:=tan(Pi/4+x)^cot(2*x);

f := tan(1/4*Pi+x)^cot(2*x)

> limit(f, x=0 );

exp(1)

Maple verwendet häufig die Reihenentwicklung

> series(f, x=0);

series(exp(1)+(-2/3*exp(1))*x^2+(-16/45*exp(1))*x^4...

Es handelt sich wirklich um eine abenteuerliche Funktion (die auch komplexwertig ist)

> plot(f, x=-1..10);

[Maple Plot]

Man kann noch etwas mit dieser Funktion experimentieren

> subs(x=0,f);

tan(1/4*Pi)^cot(0)

Und ein falsches Ergebnis provozieren

> evalf(subs(x=0,f));

1.

> eval(f,x=0);

Error, (in cot) numeric exception: division by zero

Oder die Rechengenauigkeit testen

> eval(f,x=1e-5);

tan(1/4*Pi+.1e-4)^49999.99999

> evalf(%);

2.718254646

> Digits:=10:

> eval(f,x=1e-10);

tan(1/4*Pi+.1e-9)^5000000000.

> evalf(%);

1.

Mit einer größeren Stellenzahl (Digits s.o.) klappt es.

>

Noch ein unbestimmter Ausdruck der Sorte infinity/infinity (nach dem Motto 'was wächst schneller'):

> limit(x!/x^x, x=infinity);

0

limit(x!/x^x, x=0);

plot(x!/x^x, x=0..10);

>

Grenzwerte mit Parametern

Der Term kann auch weitere Unbekannte enthalten

> f:=(-x^(-a)+x^a) / (x-1/x);

f := (-x^(-a)+x^a)/(x-1/x)

> limit(f, x=1);

a

> limit( cos(a/x)^x, x=infinity);

1

> limit(exp(-k*x),x=infinity);

limit(exp(-k*x),x = infinity)

Hier muß allerdings eine weitere Annahme gemacht werden

> assume(k>0): limit(exp(-k*x),x=infinity);

0

>

Manchmal kann man nur mit Bestimmtheit sagen, daß die Funktion beschränkt ist

> limit(sin(x),x=infinity);

-1 .. 1

> limit(a*sin(x),x=infinity);

min(-a,a) .. max(-a,a)

> limit( b*sin(1/x), x=0);

min(-b,b) .. max(-b,b)

>

>

Der Differentialquotient

Maple kennt auch den Differentialquotienten

> f:='f':

> fs:=limit( (f(x+dx) -f(x)) / dx, dx=0);

fs := D(f)(x)

Und die zweite Ableitung

> fss:=limit( (f(x+2*dx) -2*f(x+dx) +f(x)) / (dx^2), dx=0);

fss := `@@`(D,2)(f)(x)

> eval(fs,f=sin);

cos(x)

> eval(fss,f=sqrt);

-1/4*1/(x^(3/2))

>

Grenzwerte zusammenfassen

Mit combine können Grenzwerte zusammengefasst werden

> combine(limit(1/x,x=a)*limit(x,x=a));

1

Oder auch nicht

> combine(limit(1/x,x=0,right)*limit(x,x=0,right));

undefined

Die träge Schreibweise sollte man dabei nicht verwenden

> combine(Limit(1/x,x=0)*Limit(x,x=0));

Limit(1,x = 0)

> value(%);

1

>

Grenzwerte von Funktionen mit mehreren Variablen

Nur sehr eingeschränkt verwendbar

> restart:

> limit(x/y,{x=3,y=4});

3/4

> limit(x/y,{x=3,y=infinity});

0

> limit(x/y,{x=infinity,y=4});

undefined

> limit(x/y,{x=infinity,y=infinity});

undefined

> limit(x/y,{x=0,y=0});

undefined

> limit(x^2/y^2,{x=0,y=0});

undefined

>

Die Richtungsangabe wird nicht umgesetzt

> limit(x/y,{x=3,y=4},right);

limit(x/y,{y = 4, x = 3},right)

> limit(x/y,{x=0,y=0},right);

limit(x/y,{x = 0, y = 0},right)

Es gibt viele Richtungen und Grenzwerte...

> plot3d(x/y,x=-2..2,y=-2..2,view=[-2..2,-2..2,-2..2],axes=framed,grid=[30,30],color=red);

> plot3d(x/y,x=-2..2,y=-2..2,view=[-2..2,-2..2,-2..2],axes=framed,grid=[100,100],color=red,style=patchcontour,contours=30);

>

Zurückführen auf einen eindimensionalen Grenzwert durch Angabe einer Richtung (eines Wegs)

> limit(x/(m*x),x=0); # y=m*x

1/m

> limit(x/sqrt(x),x=0); # y=sqrt(x)

0

> limit(x/x^2,x=0,right); # y=x^2

infinity

Komplexe Grenzwerte

> restart:with(plots):

Warning, the name changecoords has been redefined

Der 'omnidirektionale' Grenzwert (Richtungsangabe complex) liefert eine falsche Aussage

> limit(1/z,z=0,complex);

infinity-infinity*I

und kann auch nicht mit dem multidirektionalen limit berechnet werden

> limit(1/(x+I*y),{x=0,y=0},right);

limit(1/(x+I*y),{y = 0, x = 0},right)

>

Vielmehr muss der Benutzer wieder die Richtung der Annäherung angeben.

Annäherung längs einer Geraden

> limit(1/(x+I*m*x),x=0,left);

infinity*I/signum(-I+m)

> simplify(evalc(limit(1/(x+I*m*x),x=0,left))); # y=m*x

infinity*I*m-infinity

Annäherung längs y = sqrt(x)

> limit(1/(x+I*sqrt(x)),x=0,right); # y=sqrt(x)

-infinity*I

Nach Real- und Imaginärteil getrennt:

> limit(Re(1/(x+I*sqrt(x))),x=0,right); # y=sqrt(x)

1

> limit(Im(1/(x+I*sqrt(x))),x=0,right); # y=sqrt(x)

-infinity

Annäherung längs y = x^2

> limit(1/(x+I*x^2),x=0,left); # y=x^2

-infinity

Nach Real- und Imaginärteil getrennt:

> limit(Re(1/(x+I*x^2)),x=0,left); # y=x^2

-infinity

> limit(Im(1/(x+I*x^2)),x=0,left); # y=x^2

-Re(O(1))

>

>

Auch hier hilft eine Zeichnung

> pre:=plot3d(Re(1/(x+I*y)),x=-2..2,y=-2..2,view=[-2..2,-2..2,-2..2],axes=framed,grid=[30,30],color=grey):

> pim:=plot3d(Im(1/(x+I*y)),x=-2..2,y=-2..2,view=[-2..2,-2..2,-2..2],axes=framed,grid=[50,50],color=yellow,style=patchcontour,contours=30):

> wegre:=plots[spacecurve]([x,sqrt(x),evalc(Re(1/(x+I*sqrt(x))))],x=0..2,axes=framed,color=black, thickness=5,numpoints=1000):

> #display(pre,wegre);

> wegim:=spacecurve([x,sqrt(x),evalc(Im(1/(x+I*sqrt(x))))],x=0..2,axes=framed,color=black, thickness=5,numpoints=500): #wegim;

> #display(pim,wegim);

>

> display(wegre,wegim,pim,display(pre,color=grey),orientation=[124,72]);

[Maple Plot]

> wegebene:=implicitplot3d( y^2=x ,x=-2..2,y=-2..2,
zz=-2..2,style=patchnogrid,color=red,grid=[5,45,5]):#wegebene;

> display(pim,pre,wegre,wegim,wegebene);

>

Weitere Möglichkeiten zur Veranschaulichung und Kontrolle

> restart: with(plots):

Warning, the name changecoords has been redefined

> z:=seq(x+I*2*x,x=seq(1/(100.*n),n=1..10));

z := .1000000000e-1+.2000000000e-1*I, .5000000000e-...
z := .1000000000e-1+.2000000000e-1*I, .5000000000e-...
z := .1000000000e-1+.2000000000e-1*I, .5000000000e-...
z := .1000000000e-1+.2000000000e-1*I, .5000000000e-...
z := .1000000000e-1+.2000000000e-1*I, .5000000000e-...

> complexplot([z],style=point);

>

> w:=seq(evalc(1/z[i]),i=1..10);

w := 20.00000000-40.00000000*I, 40.00000000-80.0000...
w := 20.00000000-40.00000000*I, 40.00000000-80.0000...
w := 20.00000000-40.00000000*I, 40.00000000-80.0000...
w := 20.00000000-40.00000000*I, 40.00000000-80.0000...

> complexplot([w],style=point);

> z:=seq(x+I*sqrt(x),x=seq(1/(100.*n),n=1..10));

z := .1000000000e-1+.1000000000*I, .5000000000e-2+....
z := .1000000000e-1+.1000000000*I, .5000000000e-2+....
z := .1000000000e-1+.1000000000*I, .5000000000e-2+....
z := .1000000000e-1+.1000000000*I, .5000000000e-2+....

> complexplot([z],style=point);

>

> w:=seq(evalc(1/z[i]),i=1..10);

w := .9900990099-9.900990099*I, .9950248756-14.0717...
w := .9900990099-9.900990099*I, .9950248756-14.0717...
w := .9900990099-9.900990099*I, .9950248756-14.0717...
w := .9900990099-9.900990099*I, .9950248756-14.0717...

> complexplot([w],style=point);

> z:=seq(x+I*x^2,x=seq(1/(100.*n),n=1..10));

z := .1000000000e-1+.1000000000e-3*I, .5000000000e-...
z := .1000000000e-1+.1000000000e-3*I, .5000000000e-...
z := .1000000000e-1+.1000000000e-3*I, .5000000000e-...
z := .1000000000e-1+.1000000000e-3*I, .5000000000e-...
z := .1000000000e-1+.1000000000e-3*I, .5000000000e-...

> complexplot([z],style=point);

>

>

> w:=seq(evalc(1/z[i]),i=1..10);

w := 99.99000100-.9999000100*I, 199.9950001-.999975...
w := 99.99000100-.9999000100*I, 199.9950001-.999975...
w := 99.99000100-.9999000100*I, 199.9950001-.999975...
w := 99.99000100-.9999000100*I, 199.9950001-.999975...

> complexplot([w],style=point);

>

Als Funktion

> y:='y':

> z:=x+I*y;

z := x+I*y

> y:=2*x;

y := 2*x

> complexplot(z,x=0..10);

> complexplot(1/z,x=0.0001..10,numpoints=500);

> y:=sqrt(x);

y := sqrt(x)

> complexplot(1/z,x=0.001..10,numpoints=500);

[Maple Plot]

> y:=x^2:

> complexplot(1/z,x=0.1..10,numpoints=500);

>

>

>

Summen

Die Befehle add und sum im Vergleich

Bestimmte Summen mit numerischem Laufbereich werden mit add gebildet

> restart:

> add(i,i=1..100);

5050

Gauß soll das fast so schnell wie Maple berechnet haben. Sein Mathematiklehrer wollte etwas Ruhe haben und ließ die Klasse alle Zahlen von 1 bis 100 addieren. Nach kurzer Zeit kam Gauß mit seinem Heft ans Lehrerpult und sagte 'lieget se' (da liegen die Zahlen). Nur hatte er die 100 Zahlen nicht unter einander geschrieben und addiert, sondern er hatte eine Formel gefunden:

> Sum(i,i=1..n)=factor(sum(i,i=1..n));

Sum(i,i = 1 .. n) = 1/2*n*(n+1)

Und es ist gut, dass auch Maple diese Formel kennt:

> restart:

> symb:=n->sum(i,i=1..n);

symb := proc (n) options operator, arrow; sum(i,i =...

> st:=time():
symb(10^7);
time()-st;

50000005000000

0.

Zum Vergleich:

> num:=n->add(i,i=1..n);

num := proc (n) options operator, arrow; add(i,i = ...

> st:=time():
num(10^7);
time()-st;

50000005000000

55.460

Oder mit der Angabe des benötigten Speichers

> showtime();

O1 := symb(10^7);

50000005000000

time = 0.00, bytes = 5090

O2 := num(10^7);

50000005000000

time = 55.45, bytes = 273272958

O3 := off;

>

Trotzdem ist es oft sinnvoll, add statt sum zu verwenden:

> f:=x->add(a[i]*x^i,i=0..5);

f := proc (x) options operator, arrow; add(a[i]*x^i...

> f(0);

a[0]

> g:=x->sum(a[i]*x^i,i=0..5);

g := proc (x) options operator, arrow; sum(a[i]*x^i...

> g(0);

0

Alternativen:

> g:=x->sum('a[i]*'x'^i',i=0..5); g(0);

g := proc (x) options operator, arrow; sum('a[i]*('...

a[0]

>

> h:=unapply(sum(a[i]*x^i,i=0..5),x);

h := proc (x) options operator, arrow; a[0]+a[1]*x+...

> h(0);

a[0]

>

Oder wenn man eben wirklich nur numerisch und nicht symbolisch rechnen will:

> ad:=add(1/i^3,i=1..1000);

> su:=sum(1/i^3,i=1..1000);

su := 1/2*Psi(2,1001)+Zeta(3)

Natürlich läßt sich eine symbolisches Ergebnis auch nachträglich numerisch berechnen.

> evalf(su);

1.202056403

> evalf(ad);

1.202056404

>

Der Befehl add ist auch insofern stabiler als sum, als die Laufvariable und der Summand nicht mit '.. ' gekapselt werden müssen, und kann z.B. zur eigenen Reihenentwicklung verwendet werden (Variablenliste in diff in [ ] für k=0):

>

> reihe:=(f,x0,n)->add((x-x0)^k*eval(diff(f(x),[x$k]),x=x0)/k!,k=0..n);

reihe := proc (f, x0, n) options operator, arrow; a...

> reihe(sin^2+cos,Pi/3,5);

5/4-3/4*(x-1/3*Pi)^2-1/4*(x-1/3*Pi)^3*sqrt(3)+3/16*...

>

> plot({reihe(sin^2+cos,Pi/3,10),sin(x)^2+cos(x)},x=-1..4);

>

> reihe(x->x^4-x^2,2,5);

-44+28*x+23*(x-2)^2+8*(x-2)^3+(x-2)^4

> simplify(%);

x^4-x^2

> reihe(x->x^2+sin(x),Pi,5);

Pi^2+(x-Pi)*(2*Pi-1)+(x-Pi)^2+1/6*(x-Pi)^3-1/120*(x...

>

Auch Schachtelungen sind erlaubt

> add( add(k[i,j]*x^(i+j), i=1..3), j=1..3);

k[1,1]*x^2+k[2,1]*x^3+k[3,1]*x^4+k[1,2]*x^3+k[2,2]*...

>

>

Summenformeln

Unbestimmte Summen

Ohne Angabe des Laufbereichs, also mit sum(f(i), i) erhält man einen Term g(i) so dass g(i+1)-g(i)=f(i) für alle i gilt:

> s:=factor(sum(i,i));

s := 1/2*i*(i-1)

> simplify(eval(s,i=n+1)-eval(s,i=n));

n

> factor(sum(2*i,i));

i*(i-1)

> factor(sum(i^2,i));

1/6*i*(2*i-1)*(i-1)

>

Bestimmte Summen

Mit Angabe des Laufbereichs, also mit sum(f(i), i=m..n) erhält man einen Term g(m,n) = g(n+1)-g(m) wobei g die unbestimmte Summe ist.

>

> simplify(eval(s,i=n+1)-eval(s,i=m));

1/2*n^2+1/2*n-1/2*m^2+1/2*m

> simplify(sum(i,i=m..n));

1/2*n^2+1/2*n-1/2*m^2+1/2*m

> factor(sum(i^2,i=1..n));

1/6*n*(n+1)*(2*n+1)

> factor(sum(i^2,i=1..n-1));

1/6*n*(2*n-1)*(n-1)

(Ohne Angabe des Laufbereichs erhält man also in der Regel die Summe von 1 bis n-1.)

>

Mit sum können ebenfalls Summen von Summen gebildet werden

> sum( sum(x^(k+j), k), j);

x^k*x^j/((x-1)^2)

>

> sort(sum( sum(x^(k+j), k=1..j), j=1..5));

x^11/(x-1)+x^9/(x-1)+x^7/(x-1)-x^6/(x-1)-x^4/(x-1)-...

>

Unendliche Reihen

Unendliche Reihen werden mit der oberen Grenze infinity formuliert

> sum(1/i!,i=0..infinity);

exp(1)

> sum(1/(2*i+1)^4,i=0..infinity);

1/96*Pi^4

> sum(1/i^(2*k),i=1..infinity);

Zeta(2*k)

> sum(i,i=1..infinity);

infinity

> sum(1/i,i=1..infinity);

infinity

>

Verschiedene Typen von Summen

Maple verwendet je nach Typ des Summanden verschiedene Methoden zur symbolischen Summation:

Polynome werden unter Verwendung von Bernoulli-Polynomen bernoulli(n,x) summiert. Rationale Funktionen der Summationsvariablen werden nach Moenck summiert. Dabei wird u.U. die zeta -Funktion, die Psi -Funktion und die Eulersche Konstante gamma oder die verallgemeinerte hypergeometrische Funktion (siehe ?zeta, ?Psi, ?gamma, ?hypergeom) verwendet.

>

> sum(1/k^x,k=1..infinity);

Zeta(x)

> sum(1/i,i);

Psi(i)

> sum(k/(k-1),k=2..n);

n-1+Psi(n)+gamma

> Psi(3); Psi(100); expand(Psi(100));

3/2-gamma

Psi(100)

-gamma+360968703235711654233892612988250163157207/6...

>

Die hypergeometrische Funktion kann in 'Standardfunktionen' umgewandelt werden

> sum((-1)^k/(k^2+1),k=1..infinity);

-1/2*hypergeom([1, 1-I, 1+I],[2-I, 2+I],-1)

> # evalf(%); # innerhalb zwei Minuten kein Ergebnis

Warning, computation interrupted

> convert( %, StandardFunctions);

1/2*I*(1/2*Psi(1-1/2*I)-1/2*Psi(1/2-1/2*I))-1/2*I*(...

> evalf(%);

-.3639854724+0.*I

>

Schließlich können auch Terme summiert werden, die Binomialkoeffizienten enthalten:

> sum(k*binomial(n,k), k=0..n);

1/2*2^n*n

> sum(binomial(n+k,k), k=0..n);

binomial(2*n+1,n+1)

>

Eine Besonderheit stellt die Summation über die Wurzeln eines Polynoms (oder allgemeiner von RootOf-Termen) dar:

> Sum(k/(k-1), k=RootOf(x^3+x^2+1))=sum(k/(k-1), k=RootOf(x^3+x^2+1));

Sum(k/(k-1),k = RootOf(_Z^3+_Z^2+1)) = 4/3

Dies vereinfacht die weitere Bearbeitung, auch wenn die Summe nicht explizit berechnet wird, z.B.:

> allvalues(RootOf(x^3+x^2+1));

-1/6*(116+12*sqrt(93))^(1/3)-2/3*1/((116+12*sqrt(93...
-1/6*(116+12*sqrt(93))^(1/3)-2/3*1/((116+12*sqrt(93...
-1/6*(116+12*sqrt(93))^(1/3)-2/3*1/((116+12*sqrt(93...

> sum(exp(k), k=RootOf(x^3+x^2+1));

sum(exp(k),k = RootOf(_Z^3+_Z^2+1))

> evalf(%);

2.003025952+0.*I

>

Maple setzt auch automatisch RootOfs ein

> sum(1/(x^4+1),x=1..infinity);

-Sum(-1/4*_alpha*Psi(1-_alpha),_alpha = RootOf(_Z^4...

die bei Bedarf numerisch ausgewertet werden können

> evalf(%);

.5784775797-0.*I

>

>

Konvergenz und Divergenz

Für die geometrische Reihe bekommt man nicht nur die Teilsumme

> restart:

> s:=n->sum(a*q^i,i=0..n-1);

s := proc (n) options operator, arrow; sum(a*q^i,i ...

> normal(s(n));

a*(q^n-1)/(q-1)

sondern auch ohne Rückfrage den Grenzwert:

> s(infinity);

-a/(q-1)

Mit limit muss man Annahmen machen

> lim:=limit(s(n),n=infinity);

lim := limit(a*q^n/(q-1)-a/(q-1),n = infinity)

> assume(q<1);additionally(q>-1);

> lim;

limit(a*q^n/(q-1)-a/(q-1),n = infinity)

> additionally(q>0);#about(q);

> lim;

-a/(q-1)

die aber zu eng sind

> assume(-1<q,q<0);#about(q);

> lim;q:='q':

-a/(q-1)

Auch hier ist es also angebracht, symbolische Berechnungen numerisch zu kontrollieren, oder eine Zeichnung zu erstellen:

> a:=1: q:=-1.01:

> seq(s(n),n=1000..1010);

-10426.94310, 10532.21253, -10636.53466, 10743.9000...
-10426.94310, 10532.21253, -10636.53466, 10743.9000...

> plot([seq([n,s(n)],n=1000..1050)]);

[Maple Plot]

>

>

Asymptotische Näherung für Reihen

Euler-Maclaurinsche Summation:

Für die Summe sum(expr,x) kann mit eulermac(expr,x) eine asymptotische Näherung aufgestellt werden, d.h.,

mit F(x) = eulermac(f(x),x) ist F(x + 1) - F(x) asymptotisch gleich f(x).

>

> eulermac(k/(1+k^2),k,4);

1/2*ln(1+k^2)-1/2*k/(1+k^2)+1/12/(1+k^2)-1/6*k^2/((...
1/2*ln(1+k^2)-1/2*k/(1+k^2)+1/12/(1+k^2)-1/6*k^2/((...

> convert(%,polynom);

>

1/2*ln(1+k^2)-1/2*k/(1+k^2)+1/12/(1+k^2)-1/6*k^2/((...

zum Vergleich

> sum(k/(1+k^2),k);

1/2*Psi(k-I)+1/2*Psi(k+I)

>

Oder mit Bereichsangabe

> eulermac(k/(1+k^2),k=1..x,4);

1/2*ln(1+x^2)-241/2520+O(1)+1/2*x/(1+x^2)+1/12/(1+x...
1/2*ln(1+x^2)-241/2520+O(1)+1/2*x/(1+x^2)+1/12/(1+x...

> convert(%,polynom);

1/2*ln(1+x^2)-241/2520+1/2*x/(1+x^2)+1/12/(1+x^2)-1...

>

Hier sind weitere Möglichkeiten, die Güte der Näherung zu beurteilen:

> seq([evalf(sum(k/(1+k^2),k=1..n)),evalf(convert(eulermac(k/(1+k^2),k=1..n,4),polynom))],n=1000..1010);

[6.813605376+0.*I, 6.812620774], [6.814604376+0.*I,...
[6.813605376+0.*I, 6.812620774], [6.814604376+0.*I,...
[6.813605376+0.*I, 6.812620774], [6.814604376+0.*I,...
[6.813605376+0.*I, 6.812620774], [6.814604376+0.*I,...

>

>

> sum(x/(1+x^2),x=1..1000);

1/2*Psi(1001-I)+1/2*Psi(1001+I)-1/2*Psi(1-I)-1/2*Ps...

> evalf(%);

6.813605376+0.*I

> evalf(eulermac(x/(1+x^2),x=1..1000,4));

6.812620774+O(1)+O(-119998200001799999880/100000600...

>

Produkte

Analog zu add können Produkte mit mul berechnet werden

> mul( 1+1/x^2, x=1..20);

1060759394707991417279425/302973535625290620862464

> evalf(%);

3.501161884

>

Für symbolische Berechnungen gibt es den Befehl product:

> product(x,x);

GAMMA(x)

> Product(x^2,x=1..5)=product(x^2,x=1..5);

Product(x^2,x = 1 .. 5) = 14400

> Product(1+1/x^2, x)=product(1+1/x^2, x);

Product(1+1/(x^2),x) = GAMMA(x-I)*GAMMA(x+I)/(GAMMA...

> evalf( product( 1+1/x^2, x=1..100) );

3.639682295

> product( 1+1/x^2, x=1..infinity);

sinh(Pi)/Pi

> evalf( % );

3.676077910

> limit( product( 1+1/x^2, x=1..n), n=infinity );

1/(GAMMA(-I)*GAMMA(I))

> simplify(%);

sinh(Pi)/Pi

>

Numerische Berechnungen

>

> sum( (-1)^x/x^2, x=1..n);

-hypergeom([1, 1, 1],[2, 2],-1)-(-1)^(n+1)*hypergeo...

> convert(%,StandardFunctions);

-1/12*Pi^2-(-1)^n*(-1+LerchPhi(-1,2,n)*n^2)/(n^2)

> eval(%,n=2000);

-1/12*Pi^2+1/4000000-LerchPhi(-1,2,2000)

> showtime();

O1 := evalf( sum( (-1)^x/x^2, x=1..2000), 40);

-.8224669084866132026112193020564110699511

time = 1.15, bytes = 8741878

O2 := evalf( Sum( (-1)^x/x^2, x=1..2000), 40);

-.8224669084866132026112193020564110699511

time = 0.19, bytes = 1346178

O3 := off;

>

Numerische Berechnungen im Unendlichen

> f:=sinh(x)^2-sinh(x^2);

f := sinh(x)^2-sinh(x^2)

> limit( f, x=infinity);

-infinity

Falsch

> evalf( Limit( f, x=infinity));

Float(infinity)

Aber

> evalf( limit( f, x=infinity));

Float(-infinity)

Test

> evalf(subs(x=10^2, f));

-.4403409113e4343

>

>

Zurück zum Inhaltsverzeichnis