Kapitel 17
Die Integralrechnung ist vielleicht eine der wichtigsten Anwendungen für ein CAS: Statt in endlosen Tabellen nachzuschlagen und sich mit Integrationsregeln herumzuplagen, gibt man einen Befehl ein.
Was in der Forschung höchst willkommen ist hat aber auch Auswirkungen auf die Lehre. Inwieweit müssen Schüler und Studenten von morgen noch die Integration beherrschen? Neben der Fähigkeit eines CAS, Integrale symbolisch zu berechnen, spielt aber - einmal mehr - die Grafik eine wichtige Rolle und man könnte sich die Einführung des Integrals in Physik etwa so vorstellen:
Im Wechselstromkreis sind Spannung und Strom phasenverschoben. Welche Arbeit wird verrichtet?
> restart: with(plottools):
> P:='sin(t)*cos(t-Pi/5)'; # unausgewertet, damit Maple nicht vereinfacht
Das Produkt aus Spannung und Strom stellt den Momentanwert der Leistung dar. Für genügend kurze Zeitintervalle kann man die Arbeit durch annähern. Das würde dann so aussehen:
>
student[leftbox](P, t=0..5, 30, shading=yellow);
Und die Arbeit während einer größeren Zeitspanne müsste dann ungefähr die Summe der einzelnen Beiträge sein:
>
W:=student[leftsum](P, t=0..5, 30);
> evalf(%);
Natürlich fangen dann alle Schüler sofort an, die Zerlegung zu verfeinern. Einige ändern auch die Grenzen und wundern sich über negative Ergebnisse und die Experimentierfreudigsten ändern die Phasenverschiebung von Spannung und Strom und strahlen, wenn die Arbeit 0 herauskommt.
Dann wird es Zeit, vom Einzelfall auf einen allgemein gültigen Zusammenhang zu schließen.
>
>
Wn:=student[leftsum](P, t=0..5, n);
value(%); # mit diesem Befehl kann man Verwirrung stiften
Kann Maple einen Term für die Arbeit finden, wenn man die Zerlegung beliebig fein macht?
> limit(Wn,n=infinity);
Ja! Und dazu gehört auch eine Zahl:
> evalf(%);
>
Und weil man solche Berechnungen oft benötigt, schreibt man kurz:
> Int(P, t=0..5)=int(P, t=0..5);
> combine(%);
> evalf(%);
>
Anmerkung
Wenn man die Berechnung für volle Perioden durchführt, kommt man schon mit sehr groben Zerlegungen aus. Warum?
> Wp4:=student[leftsum](P, t=0..2*Pi, 4);
> value(%);
> evalf(%);
> Wpn:=student[leftsum](P, t=0..2*Pi, n);
> simplify(value(%));
> evalf(%);
> evalf(value(Wp4)-simplify(value(Wpn)));
> eval(int(P,t=0..tb),tb=2*Pi);
>
Ohne die Angabe von Grenzen erhält man eine Stammfunktion
> Int(P,t) = int(P, t);
> W:=int(P, t);
> plot({P,seq(W+n*eval(W,t=0),n=-3..0)},t=0..2*Pi);
Integrationskonstante
> eval(W,t=0);
Und das Schaubild legt die Vermutung nahe, dass für alle Stammfunktionen gilt:
> 'P'=Diff('W',t);
> P=diff(W,t);
> combine(diff(W,t)-P,trig);
>
Zur Übung noch einmal das bestimmte Integral als Grenzwert:
> restart:
> dx:=(b-a)/n;
> x:=a+i*dx;
> bestint:=limit(sum(f(x)*dx,i=1..n),n=infinity);
> f:=t->t^2; bestint;
> f:=t->t^m; bestint;
> f:=t->sin(omega*t); simplify(bestint);
> f:=t->exp(-t^2); bestint;
> int(f(t),t);
>
Krummlinig begrenzte Flächen
Ein Aufgabentyp, mit dem man viele Schülergenerationen geplagt hat, ist die Berechnung von Flächen zwischen Kurven. Nun trifft Maple die Fallunterscheidungen.
> restart:with(plottools):
> flaeche:=int(abs(f(x)-g(x)),x=a..b);
Zum Vergleich die orientierte Fläche:
> orflaeche:=int(f(x)-g(x),x=a..b);
> f:=x->x: g:=x->x/2+1:
> flaeche;
> orflaeche;
Ein etwas anspruchsvolleres Beispiel:
> f:=x->-x^3+4*x;
> g:=x->x^4-4*x^2+1;
>
Berechnung der Schnittpunkte
> sols:=evalf(solve(f(x)=g(x)));
> eval(flaeche,{a=min(evalf(sols)),b=max(evalf(sols))});
> evalf(%);
Zur grafischen Darstellung benötigen wir noch ein paar Angaben
> a:=min(evalf(sols)); b:=max(evalf(sols));
> n:=round((b-a)/dx);
> dx:=1/100;n;
> zahl:=convert(flaeche,name);
>
A := seq(rectangle([x,f(x)], [x+dx,g(x+dx)], color=yellow),x=seq(a+i*dx,i=0..n)):
plots[display](A,plot({f(x),g(x)},x=a-0.2..b+0.2), style=patchnogrid,title=`A = `||zahl);
>
>
Rotationskörper
Auch Rotationskörper sind ein beliebtes Thema.
Folgende Fläche soll um die x-Achse rotieren
> restart: with(plots): with(plottools):
Warning, the name changecoords has been redefined
> kurven:=plot({sqrt(x),sqrt(2*(x-1))},x=0..3,thickness=2,color=black):
>
schnitt2d:=polygonplot([[0,0],seq([x,sqrt(2*(x-1))],x=seq(1+i/20,i=0..20)),seq([x,sqrt(x)],x=seq(2-i/20,i=0..40))],axes=normal,tickmarks=[2,2],color=cyan):
> display(kurven,schnitt2d);
>
Dreidimensional sieht das ungefähr so aus
> p1:=plot3d([t,sqrt(t)*sin(phi),sqrt(t)*cos(phi)],t=0..2,phi=0..3*Pi/2,axes=normal,scaling=constrained,color=yellow):
> p2:=plot3d([t,sqrt(2*(t-1))*sin(phi),sqrt(2*(t-1))*cos(phi)],t=1..2,phi=0..3*Pi/2,axes=normal,scaling=constrained,color=grey):
> #display(p1,p2);
>
schnitt:=polygonplot3d([[0,0,0],seq([x,0,sqrt(2*(x-1))],x=seq(1+i/20,i=0..20)),seq([x,0,sqrt(x)],x=seq(2-i/20,i=0..40))],axes=normal,color=red,tickmarks=[2,2,2],color=cyan):
>
> display(p1,p2,schnitt,orientation=[-130,60],scaling=unconstrained);
>
Und wie groß ist nun das Volumen?
>
> RotVol:=(radius,a,b)->Pi*int(radius(x)^2,x=a..b);
> Aussen:=RotVol(x->sqrt(x),0,2);
> Innen:=RotVol(x->sqrt(2*(x-1)),1,2);
> Aussen-Innen;
>
Bei der Integration über ein unbeschränktes Intervall ist manchmal eine Fallunterscheidung gefragt:
> restart:
> int(exp(a*x),x=0..infinity);
Definite integration: Can't determine if the integral is convergent.
Need to know the sign of --> -a
Will now try indefinite integration and then take limits.
> int(exp(a*x),x=0..xi);
>
Integriert man über Singularitäten, so kann es sein, dass das Integral nicht definiert ist:
> int(1/sqrt(abs(x)),x=-1..1);
>
Das ging gut. Aber hier gibt es Probleme:
> int(1/x^3, x=-3..2);
> int(1/x^3, x=-3..2, CauchyPrincipalValue);
>
Das heißt ausführlich:
> limit(int(1/x^3,x=-3..-x0)+int(1/x^3,x=x0..2),x0=0);
Oder
> int(1/x^3,x=-3..-x0)+int(1/x^3,x=x0..2);
> simplify(%);
Wobei die Grenzwerte einzeln nicht existieren
> limit(int(1/x^3,x=-3..x0),x0=0,left)+limit(int(1/x^3,x=x0..2),x0=0,right);
>
Weitere Beispiele
> int(1/(x^2+x), x=-2..1, CauchyPrincipalValue);
> evalf(%);
> plot( 1/(x^2+x), x=-2..1, -20..20);
>
> int(1/x, x=-2..1);
> int(1/x,x=-2..1,CauchyPrincipalValue);
> evalf(%);
Aber
> int(1/x^2, x=-2..1);
>
Unstetigkeitsstellen mit endlichem Sprung
Über nicht singuläre Unstetigkeitsstellen kann ohne weitere Angaben integriert werden.
> restart:
> f:=cos(x)/sqrt(1-sin(x));
> discont(f,x);
> limit(f,x=Pi/2,left), limit(f,x=Pi/2,right);
> F:=int(f,x);
> int(f, x=0..Pi), int(f, x=0..Pi/2), int(f, x=Pi/2..Pi);
> plot({f,int(f, x)}, x=0..Pi,discont=true);
>
>
Integraltabellen und Integrationsregeln
Integraltabellen
Nach dem Motto 'Jedem seine Tabelle' kann man sich eine Sammlung seiner Lieblingsintegrale zusammenstellen. Auch wenn man jedes Integral neu berechnen kann, ist das oft zu Vergleichszwecken sinnvoll, besonders wenn es sich nicht um elementare Funktionen handelt, für die man oft zusätzliche Annahmen machen muss. Ein Spreadsheet leistet hier gute Dienste, weil die Berechnung automatisiert werden kann. Einfach in der ersten Spalte eine neue oder leicht geänderte Funktion eintragen und das Spreadsheet neu auswerten. Zusätzlich können die Zellen des Spreadsheets von aussen angesprochen werden.
> restart:
>
>
>
Maple macht das so ähnlich: Es führt eine Tabelle über die Integrale, die während einer Session berechnet wurden:
op(4,eval(`int/int`));
>
>
Integrationsregeln
Die Integrationsregeln sind seit Maple eigentlich kein Thema mehr, deshalb stehen sie auch im Package für Studenten. Dennoch soll es ja vorkommen, dass auch Maple eine Stammfunktion, die es eigentlich geben müsste nicht findet. Dann kann man sich immerhin bei einer Substitution oder partiellen Integration beraten lassen:
> restart: with(student):
> changevar(x=sin(u), Int(sqrt(1-x^2), x=a...b), u);
> changevar(x=g(u), Int(f(x), x=a...b), u);
>
> intparts(Int(u(x)*v(x),x),u(x));
> int(diff(f(x),x)/f(x),x);
>
Kurvenintegrale können z.B. zur Berechnung krummlinig begrenzter Flächen oder zur Berechnung von Bogenlängen verwendet werden. Das Standardbeispiel ist die Ellipse.
>
Ellipsenfläche
> restart:
> kurvint:=-int(y(t)*diff(x(t),t),t=ta..tb);
> x:=t->a*cos(t)+3; y:=t->b*sin(t)+2;
> kurvint;
> eval(kurvint,{ta=0,tb=2*Pi});
>
Die Grafik darf nicht fehlen:
> with(plots): with(plottools):
Warning, the name changecoords has been redefined
> #implicitplot((x-3)^2/4+(y-2)^2=1,x=0..6,y=0..4,scaling=constrained,view=[0..6,0..4]);
> #solve((x-3)^2/4+(y-2)^2=1,y);
> a,b:=2,1;
> unten:=polygonplot([[1,0],seq([x(t),y(t)],t=seq(i*Pi/30,i=30..60)),[5,0]],color=grey):#unten;
>
elli:=display(ellipse([3,2], a, b, filled=true, color=yellow),scaling=constrained):
# Fehler beim Einfärben konkaver Polygone wird durch display überdeckt (bei richtiger Reihenfolge)
>
> display(elli,unten,plot([[1,2],[5,2]],thickness=2),view=[0..6,0..4],scaling=constrained);
> a,b:='a','b':
> repell:=eval(kurvint,{ta=0,tb=Pi});
> remell:=-eval(kurvint,{ta=Pi,tb=2*Pi});
> repell-remell;
>
Ellipsenumfang (oder Bogen für allgemeine Integrationsgrenzen)
> restart:
> bogen:=int(sqrt(diff(x(t),t)^2+diff(y(t),t)^2),t=0..2*Pi);
> x:=t->a*cos(t)+3; y:=t->b*sin(t)+2;
>
> bogen;
>
Leider scheint das nicht so einfach zu sein wie die Berechnung der Fläche: Mit diesem elliptischen Integral haben sich aber schon andere Köpfe geplagt...
> assume(b>0,a>0):
> simplify(bogen);
> eval(bogen,{a=2,b=1});
> evalf(%);
>
Aber seit es Maple gibt, kann es einem passieren, dass man wie der Reiter über den gefrorenen Bodensee kommt, jedenfalls mit festen Integrationsgrenzen. Mit einem allgemeinen Ansatz (unbestimmte Integrationsgrenzen) kann man dagegen ziemlich einbrechen:
>
> restart:
> bogen:=int(sqrt(diff(x(t),t)^2+diff(y(t),t)^2),t=ta..tb);
> x:=t->a*cos(t)+3; y:=t->b*sin(t)+2;
> simplify(bogen);
> a,b:=2,1:
> simpb:=simplify(bogen);
'Eigentlich sollte Maple doch sehen, dass man unter geeigneten Voraussetzungen mit sin(tb)*sin(ta) kürzen kann'. Aber im ganzen Arsenal der Befehle und Annahmen gibt es keine einfache Möglichkeit, das Maple mitzuteilen. Wer den Bleistift gerne durch die Maus ersetzt, löscht in obiger Ausgabe einfach die entsprechenden Terme und kopiert das Ganze wieder in eine Eingabezeile.
Wer mit Befehlen weiterjonglieren will, kann es so versuchen:
>
> simpb:=subs(sqrt(-cos(tb)^2+1)=sin(tb),sqrt(-cos(ta)^2+1)=sin(ta),simpb);
> simpb:=simplify(simpb);
> eval(simpb,{ta=0,tb=2*Pi});
>
Und nun?
Das liegt daran:
> plot(EllipticE(cos(tb),1/2*sqrt(3)),tb=0..2*Pi,numpoints=500);
> #plot(EllipticE((tb),1/2*sqrt(3)),tb=0..1,numpoints=500);
Also
> 2*eval(simpb,{ta=0,tb=Pi});
> 4*eval(simpb,{ta=0,tb=Pi/2});
>
So geht es sicher nicht:
> eval(bogen,{ta=0,tb=2*Pi});
Error, division by zero
Aber mit der Fußgängermethode bekommt man eine Idee:
> eval(bogen,{ta=0.0001,tb=2*Pi-0.0001});
Das ist für eine Ellipse mit den Halbachsen 2 und 1 etwas zu kurz
> eval(bogen,{ta=0.0001,tb=Pi-0.0001});
> eval(bogen,{ta=0.0001,tb=Pi/2-0.0001});
>
Oder mit einer Näherungsformel zur Kontrolle
> evalf(Pi*(1.5*(a+b)-sqrt(a*b)));
Aber wozu haben wir Grenzwerte?
> tab:=limit(bogen,ta=0,right);
> limit(tab,tb=Pi,left);
> 2*evalf(%);
>
So gesehen ist es also fast erstaunlich, dass Maple ohne allzu langes Nachdenken von einer festen Grenze zur anderen festen Grenze über den Bodensee kommt!
>
Integration komplexer Funktionen, Residuen
Analytische Funktionen können wie Funktionen einer reellen Veränderlichen integriert werden, da in diesem Fall der Wert des Integrals vom Weg unabhängig ist.
> restart:
> int(z^2,z=1..I);
>
int( z*cos(z^2), z=1..I);
>
Im allgemeinen Fall kann der Integrationsweg z.B. parametrisiert angegeben werden:
> kint:=int(f(z(t))*diff(z(t),t),t=ta..tb);
Erster Weg: Einheitskreis um den Ursprung
> z:=t->cos(t)+I*sin(t);
> kint;
> f:=z->z^2;
> kint;
> eval(kint,{ta=0,tb=Pi/2});
Zweiter Weg: geradlinige Verbindung:
> z:=t->t+I*(-t+1);
> kint;
> eval(kint,{ta=1,tb=0});
Diese Funktion ist nicht analytisch:
> f:=z->abs(z);
Geradliniger Weg:
> eval(kint,{ta=1,tb=0});
Auf dem Einheitskreis
> z:=t->cos(t)+I*sin(t);
> eval(kint,{ta=0,tb=Pi/2});
>
Nicht sehr hilfreich ist hier der Vorschlag von Maple, wenn man ohne die Angabe eines Wegs integriert:
> z:='z':
> int(abs(z),z=1..I);
>
Man kann übrigens eine Funktion so auf Analytizität testen:
> with(linalg):
Warning, the protected names norm and trace have been redefined and unprotected
> laplacian(evalc(abs(x+I*y)), [x,y]);
> laplacian((x+I*y)^n, [x,y]);
>
Geschlossener Weg
Wenn das Integral vom Weg unabhängig ist, sollte das Umlaufintegral verschwinden:
> f:=z->z^n;
> z:=t->cos(t)+I*sin(t);
> eval(kint,{ta=0,tb=2*Pi});
Auch für nicht analytische Funktionen kann das Umlaufintegral verschwinden:
> f:=z->abs(z);
> kint;
> eval(kint,{ta=0,tb=2*Pi});
>
Allerdings sollte das Umlaufintegral nicht verschwinden, wenn im Inneren eine Singularität liegt (und Maple sollte das bei z^n monieren):
> f:=z->1/z;
> eval(kint,{ta=0,tb=2*Pi});
So klappt es:
> int(f(z(t))*diff(z(t),t),t=0..2*Pi);
>
Warum klappt es mit eval nicht? Maple wendet bei der oben gewählten Formulierung von kint zuerst die Regel für die logarithmische Integration an
> kint;
> int(f(z(t))*diff(z(t),t),t);
und dann verschwindet das Integral für die Grenzen .
Mit der trägen Integration wird zuerst der Integrand ausgewertet und dann der richtige Wert berechnet
> eval(Int(f(z(t))*diff(z(t),t),t=ta..tb),{ta=0,tb=2*Pi});
> value(%);
>
Singularitäten
Wenn man die logarithmische Integration vor Maple versteckt, wird das Umlaufintegral um die Singularität von 1/z korrekt berechnet:
> restart:
> z:=cos(t) + I*sin(t); dz:=diff(z,t);
> f:=1/z;
> int( f*dz, t=0..2*Pi);
Maple kommt auch mit komplizierteren Funktionen zurecht
> f:=sin(z)/z^4;
> int(f *dz, t=0..2*Pi);
>
Residuen
Natürlich wird man bei Umlaufintegralen um Singularitäten den Residuensatz verwenden. Dennoch lohnt es sich, an dieser Stelle die Integration im Komplexen etwas näher zu beleuchten.
> restart: with(plots):
Warning, the name changecoords has been redefined
> f:=(2*z^3+3*z+50)/(z^3-3*z-52);
>
Mit discont bekommt man nur die reellen Singularitäten
> discont(f,z);
> solve(denom(f));
>
Die Residuen kann man an der Reihenentwicklung ablesen
> series(f,z=4,3);
>
> series(f,z=-2+3*I,3);
>
Oder mit einem fertigen Befehl
> residue(f,z=4);
> residue(f,z=-2+3*I);
> residue(f,z=-2-3*I);
>
Nähere Untersuchung
> z:=x+I*y;
> discont(f,y);
> solve(denom(f),y);
> solve(denom(f),x);
(Wenn man sich dazudenkt, dass x und y reell sein müssen, sind das die gleichen Ergebnisse wie oben).
>
Darstellung
> plr:=plot3d(Re(f),x=-8..8,y=-8..8,view=[-8..8,-8..8,-2..5],axes=framed,grid=[40,40],style=patchcontour,contours=15): plr;
> pli:=plot3d(Im(f),x=-8..8,y=-8..8,view=[-8..8,-8..8,-2..5],axes=framed,grid=[40,40]): pli;
>
Parameterdarstellung für die Integration
> r,x0,y0:='r','x0','y0':
> fp:=subs(x=r*cos(t)+x0, y=r*sin(t)+y0,f);
>
> dz:=diff(r*(cos(t)+x0+I*(sin(t)+y0)),t);
>
> r:=5: x0:=1: y0:=0:
> spr:=spacecurve([r*cos(t)+x0, r*sin(t)+y0,Re(fp),t=0..2*Pi],color=black, thickness=2,numpoints=500, axes=normal): spr;
>
> display(display(plr,color=yellow),spr,orientation=[100,30]);
>
> spi:=spacecurve([r*cos(t)+x0, r*sin(t)+y0,Im(fp),t=0..2*Pi],color=black, thickness=2,numpoints=500,axes=normal): spi;
>
> display(display(pli,shading=ZHUE),spi);
>
Noch einmal die Residuen
> z:='z':
> r1:=residue(f,z=4); r2:=residue(f,z=-2+3*I); r3:=residue(f,z=-2-3*I);
Umlaufintegrale für verschiedene Wege
a) Wie in obiger Darstellung (alle Singularitäten im Inneren)
> 2*Pi*I*(r1+r2+r3);
b)
> 2*Pi*I*(r2+r3);
c)
> 2*Pi*I*r1;
>
Explizite Berechnung der entsprechenden Umlaufintegrale (das dauert etwas länger):
a)
> x0,y0,r;
> int(fp*dz,t=0..2*Pi);
>
Ggf. Kontrollplots
plot(Re(fp*dz),t=0..2*Pi);
plot(Re(fp),t=0..2*Pi);
plot(Im(fp*dz),t=0..2*Pi);
plot(Im(fp),t=0..2*Pi);
>
b)
> evalf(sqrt(13));
> st:=time():
> x0:=0: y0:=0: r:=37/10:
>
int(fp*dz,t=0..2*Pi);
time()-st;
c)
> evalf(sqrt(36+9));
> x0:=4:r:=67/10;
> int(fp*dz,t=0..2*Pi);
> x0:=4:r:=68/10;
> int(fp*dz,t=0..2*Pi);
>
>
Weil die Welt nicht eindimensional ist, sind Mehrfachintegrale das tägliche Brot des Ingenieurs und Physikers: Die Gebiete und Räume, in denen Mehrfachintegrale eingesetzt werden, sind so umfassend, dass sie in dieser kurzen Einführung nur angedeutet werden können.
Wir beginnen mit einem einfachen Beispiel, der Berechnung des Volumens einer Pyramide:
> restart: with(plots):
Warning, the name changecoords has been redefined
> pyr:=polygonplot3d([[0,0,2],[1,0,0],[0,1,0] ,[0,0,2],[0,0,0],[1,0,0]],axes=normal,tickmarks=[2,2,2],labels=[x,y,z],color=yellow,thickness=2,orientation=[-20,70]):#pyr;
>
Mit einem 'Volumenelement'
> elem:=polygonplot3d([[1/2,0,1],[0,1/2,1],[0,0,1]],axes=normal,tickmarks=[2,2,2],labels=[x,y,z],color=red,thickness=5):
> display(elem,pyr,title=`Bitte drehen`);
>
Für Studenten gibt es eine Kurzfassung von int(int(int...)))
> with(student):
> Tripleint(1,z=0..2-2*x-2*y,y=0..1-x,x=0..1);
> value(%);
Das Doppelintegral kann man sich so ansehen:
> map(value,%%);
>
In jedem Fall kommt es auf die richtige Reihenfolge an:
> int(1,z = 0 .. 2-2*x-2*y);
> int(%,y=0..1-x);
> int(%,x=0..1);
>
Während man das Volumen einer Pyramide auch in der Formelsammlung nachschlagen kann, wird es beim Trägheitsmoment schon etwas komplizierter:
> Tripleint(y^2+z^2,z=0..2-2*x-2*y,y=0..1-x,x=0..1);
> map(value,%);
>
> value(%);
>
Allgemein werden in Maple also Dreifachintegrale so formuliert:
> Int(Int(Int(g(x,y,z),z=z1(x,y)..z2(x,y)),y=y1(x)..y2(x)),x=x1..x2);
>
Oder etwas bequemer
> Tripleint(g(x,y,z),z=z1(x,y)..z2(x,y),y=y1(x)..y2(x),x=x1..x2);
>
>
Krummlinige Koordinaten
Kartesische Koordinaten sind in der Praxis eher die Ausnahme. Meistens müssen für die Integration die Koordinaten dem Problem angepasst werden. Dazu benötigt man die Funktionaldeterminante der Koordinatentransformation. In Maple kann mit 'jacobian' die erforderliche Matrix aufgestellt werden:
> restart: with(linalg):
Warning, the protected names norm and trace have been redefined and unprotected
> xyz:=[x(u,v,w),y(u,v,w),z(u,v,w)];
> jacobian(xyz, [u,v,w]);
> fundet:=det(jacobian(xyz, [u,v,w]));
>
Ein bekanntes Beispiel (Kugelkoordinaten):
>
x:=(u,v,w)-> u*cos(v)*sin(w);
y:=(u,v,w)-> u*sin(v)*sin(w);
z:=(u,v,w)-> u*cos(w);
> fundet;
> simplify(%);
>
Weitere Koordinatensysteme finden Sie mit
> ?coords
>
Es gibt auch Integranden, die sich nicht symbolisch integrieren lassen
> restart:
> int( sin(1/x^3), x=1..2);
Dann ist immer noch eine numerische Berechnung möglich
> evalf(%);
Mit der trägen Variante Int sucht Maple erst gar nicht nach einer geschlossenen Ausdruck
> evalf(Int( sin(1/x^3), x=1..2));
Man kann die gewünschte Stellenzahl und verschiedene numerische Methoden angeben
> evalf(Int(sin(x)/x, x=1..100, 15, _NCrule));
> evalf(Int(sin(x)/x, x=1..100, 15));
>
Wenn die symbolische Integration nicht durchgeführt wird, kann das auch an RootOfs liegen
> f:=1/(1+x^7);
> int( f, x=1..2);
> value(%);
>
> evalf(%);
>
Oder direkt
> evalf( Int(f, x=1..2), 20);
>
Uneigentliche Integrale numerisch berechnen?
> int( 1/x^2, x=0..infinity);
> evalf( Int( 1/x^2, x=0..infinity) );
>
Man kann auch ein falsche Ergebnis provozieren:
> evalf( Limit(Int( 1/x^2, x=n..infinity), n=0) );
> Limit(Int( 1/x^2, x=n..infinity), n=0) ;
> value(%);
>
> Limit(Int( 1/x^2, x=n..infinity), n=0,right) ;
> value(%);
> evalf(%);
>
> evalf( Limit(Int( 1/x^2, x=n..infinity), n=0,right) );
>
Die Ableitung der Stammfunktion sollte wieder der Integrand sein. Aber manchmal ist dieser Nachweis mit Maple nicht ganz einfach, besonders wenn trigonometrische Funktionen im Spiel sind.
> restart:
> f:=sin(a+1/x);
> inte:=int(f,x);
> integrand:=diff(inte,x);
>
> simplify(integrand);
> expand(integrand);
> combine(%,trig);
>
Falls die Termumformung mit Maple beim besten Willen nicht gelingt (man kann Stunden damit zubringen, die passenden Befehle in der richtigen Reihenfolge abzusetzen), und die Terme so umfangreich sind, dass auch eine Rechnung von Hand weitere Stunden kosten würde, gibt es weitere Möglichkeiten:
>
> testexpr:=integrand-f;
> solve(testexpr);
Demnach ist testexpr für alle x und a gleich Null.
Man kann aber auch mit Zufallszahlen eine an Sicherheit grenzende Wahrscheinlichkeit berechnen:
>
> test:='5000-rand()/1e8';
> seq( evalf(subs(x=test, a=test, testexpr)), i=1..5);
> map(abs, [%] );
> max( op(%) );
>
>
Maple beim Integrieren zusehen
> restart:
> infolevel[int]:=3:
> int( 1/(1+ln(x)), x);
int/indef1: first-stage indefinite integration
int/indef2: second-stage indefinite integration
int/ln: case of integrand containing ln
int/indef1: first-stage indefinite integration
int/indef2: second-stage indefinite integration
int/exp: case of integrand containing exp
> infolevel[`evalf/int`]:=2:
> evalf(Int(sin(x)/x, x=1..2));
evalf/int/control: integrating on 1 .. 2 the integrand
evalf/int/control: Trying easyproc
evalf/int/control: from ccquad: error = .9167111514330e-12
integrand evals = 19
result = .6593299064355
>