# Lektion 9
# Integralrechnung
#  2017  Friedrich U. Mathiak, 
# mathiak@mechanik-info.de
# 
> restart: with(LinearAlgebra): with(plots): with(plottools):
# Die Integration  (ein Ganzes ausmachend) ist die Umkehrung der Differenziation.  
# Differenzialrechnung:  y=f(x)      ->    y'=f '(x);
# Integralrechnung:        y'=f '(x)    ->     y=f (x);
# Im Zusammenhang mit der Integration nehmen wir noch folgende Umbenennung vor: f(x): Vorgegebene  1. Ableitung einer noch unbekannten Funktion. 
# Dann wird als Integral- oder Stammfunktion  F(x) einer gegebenen Funktion  f(x) eine Funktion bezeichnet, fr die gilt:   F'(x)=f(x).;
# Bei der Integration einer Funktion  f(x)  wird eine  Stammfunktion  F(x) von  f(x) gesucht, deren Ableitung wieder die ursprngliche Funktion  f(x) ergibt.;
# Schreibweise: F(x)+C  =  &int;f(x)&DifferentialD;x   mit  F'(x)=f(x). Die Funktion  f(x) wird als Integrand  bezeichnet und  x  heit  Integrationsvariable. ;
# Zu jeder integrierbaren Funktion  f(x); gibt es unendlich viele Stammfunktionen  F(x) + C, die sich nur durch eine (additive)  Konstante  C  unterscheiden. 
# &int;f(x) &DifferentialD;x  =  &int;F'(x) &DifferentialD;x  =  &int;dF(x)=F(x)+C;
# Hinweis:  Alle Stammfunktionen  F(x)+C  besitzen an der festen Stelle  x =x[0]   dieselbe Steigung F'(x[0]). Sie gehen durch Parallelverschiebung ineinander ber.;
# Ein Integral, dessen  Integrationskonstante  C  unbestimmt und damit nicht festgelegt ist, wird unbestimmtes Integral genannt. 
#  Beispiel: f(x);=2x    F(x)+C;  =int(f(x), x);=  x^2; ,  da  F'(x) = f(x) = 2x  ist.  In Maple wird, hnlich wie in vielen Tabellenbchern der Ingenieurliteratur, die Konstante  C  nicht  ausgegeben.
> f:=2*x;
> Int(f,x)=int(f,x);
# Hufig ist es nicht mglich, die Stammfunktion einer Funktion  f(x)  in  geschlossener  Form anzugeben. Beispiele dazu sind:
> I1:=Int(exp(-x^2),x)=int(exp(-x^2),x):I2:=Int(sin(x)/x,x)=int(sin(x)/x,x):
> I3:=Int(cos(x)/x,x)=int(cos(x)/x,x):  I4:=Int(1/ln(x),x)=int(1/ln(x),x):
> print(I1,I2,I3,I4);
# Kann Maple keine geschlossene Form des Integrals berechnen, dann wird der Integralausdruck zurckgegeben:
> Int(exp(-x^2)*ln(x),x)=int(exp(-x^2)*ln(x),x);
# Das bestimmte Integral der Funktion  f(x)  lsst sich anschaulich deuten als Flcheninhalt A zwischen der Funktion f(x), der x-Achse und den zur y-Achse parallelen Geraden x = a und x = b. Das bestimmte Integral der Funktion  f(x)  wird symbolisch mit dem Zeichen   (&int;)[a]^(b)f(x) &DifferentialD;x   abgekrzt.;
> f:=x^2;
> Int(f,x=a..b)=int(f,x=a..b);
# Das inerte (unttige) Ojekt  Int  kann mit dem Befehl  value  berechnet werden:
> Int(f,x=a..b); value(Int(f,x=a..b));
> a:=1:b:=5:
> Int(f,x=a..b)=int(f,x=a..b);
> plot(f,x=a..b,title = "\nf(x) = x^2\n",titlefont = ["ROMAN", 15],color="NavyBlue",thickness=3,axes=boxed,gridlines,filled=[color="Blue",transparency =.5]);
# Zerlegt man die Flche  A  in  n  Steifen der Breite  Delta*x = (b-a)/n;  und ersetzt  jeden Streifen durch ein Rechteck, dann ergibt sich fr n = 5 folgendes Bild
> n:=5:
> plfn:=plot([seq(seq([a+(i+j)*(b-a)/n,(a+i*(b-a)/n)^2],j=0..1),i=0..n-1),[b,0]],color=red):
> plf:=plot(f,x=a..b,color=blue,thickness=2):
> plots[display]([plf,plfn],axes=frame,gridlines);
# Summieren wir nun ber smtliche Rechteckflchen, dann fhrt das auf die Untersumme
> i:='i':n:='n':
> USUM:=(b-a)/n*Sum((a+i*(b-a)/n)^2,i=0..n-1);
# Der Grenzbergang n  , der hier existiert, liefert 
> A:=simplify(limit(value(USUM),n = infinity));
# Die Untersumme konvergiert - allerdings sehr schlecht, wie die folgende Grafik zeigt - gegen einen Grenzwert, der geometrisch als Flcheninhalt  A  unter der Kurve  y = f (x)   gedeutet werden kann. Wir stellen den Fehler grafisch dar:
> s1:=seq(10*j,j=1..10):USUMJ:=subs(n=j*10,USUM): s2:=seq(A-value(USUMJ),j=1..10):
> p:=plot([s1],[s2],x=0..100,y=0..5,style=point,symbol=asterisk,color=blue):
> display(p,axes=frame,gridlines,labels=[n,Fehler]);
# Ist man am nummerischen Wert des Integrals interessiert, dann ist der Befehl
> Int(f,x=a..b)=int(f,x=a..b,numeric);
# zu verwenden. Ist eine der Grenzen des bestimmten Integrals eine Dezimalzahl, dann berechnet Maple das Integral nummerisch
> b:=5.;Int(f,x=a..b)=int(f,x=a..b);
# Um Maple anzuweisen, trotzdem eine symbolische Berechnung durchzufhren, ist der Parameter numeric = false zu setzen. 
> Int(f,x=a..b)=int(f,x=a..b,numeric = false);
# Ist die  obere oder untere  Grenze eines bestimmten Integrals variabel, so hngt der Integralwert noch von dieser (oberen oder unteren) Grenze ab und ist damit eine Funktion der (oberen oder unteren) Grenze. Um die (obere oder untere) Integrationsgrenze nicht mit der Integrationsvariablen zu verwechseln, wird die Integrationsvariable x formal in  t  umbenannt. 
> a:='a':f:=unapply(t^2,t);
> I1:=Int(f(t),t=a..x)=int(f(t),t=a..x):I2:=Int(f(t),t=x..a)=int(f(t),t=x..a):
> print(I1,I2);
> diff(I1,x);diff(I2,x);
# Maple kann auch uneigentliche Integrale lsen, das sind Integrale von folgender Form
# 1. Integrale mit unendlichem Integrationsintervall 
# 2. Integrale mit Unstetigkeitsstellen (Pole) im Integranden.
# Zu 1.: Man berechnet zunchst mit endlichen Grenzen und bildet dann den Grenzwert (das macht natrlich Maple fr uns):
# int(f(x), x = a .. infinity) = limit(int(f(x), x = a .. b), b = infinity), int(f(x), x = -infinity .. b) = limit(int(f(x), x = -a .. b), a = infinity), int(f(x), x = -infinity .. infinity) = limit(int(f(x), x = -a .. a), a = infinity);
# Dazu ein Beispiel: f(x) = 1/(x^2+1); , (&int;)[0]^(infinity)f(x) &DifferentialD;x=(lim)(&int;)[0]^(b)f(x) &DifferentialD;x=(lim) arctan(b)=(Pi)/(2). ;
# Maple liefert korrekt:
> f:=1/(1+x^2);Int(f,x=0..infinity)=int(f,x=0..infinity);
# Zu 2.: Vorsicht ist geboten, wenn zur Berechnung des bestimmten Integrals ber einen Pol hinwegintegriert werden soll. Wir zeigen das am Beispiel des Integranden  f(x) = 1/x^3; , der an der Stelle  x = 0  eine Polstelle besitzt.
> b:='b':f:=1/x^3;
> plot(f,x=-1..2,-10..10,title = "\nf(x) = 1/x^3\n",titlefont = ["ROMAN", 15],color="NavyBlue",thickness=2,filled=[color=blue,transparency =.5],axes=boxed,gridlines);
# Soll beispielsweise das uneigentliche  Integral   (int(f(x), x = -1 .. b))*berechnet*werden, dann*liefert*uns*Maple;
> Int(f,x=-1..b)=int(f,x=-1..b) assuming b::positive;
# In solchen Fllen ist wie folgt vorzugehen: Besitzt der Integrand an der Stelle x = u  eine Unstetigkeitsstelle (Pol), dann berechnet man zunchst die Integrale  links- und rechtsseitig davon und bildet dann, folgende Grenwerte, von denen man hofft, dass sie existieren.
# int(f(x), x = a .. b) = limit(int(f(x), x = a .. u-varepsilon), varepsilon = 0); + limit(int(f(x), x = u+varepsilon .. b), varepsilon = 0);
# Dazu ein Beispiel:   Wir integrieren f(x) zwischen x = -1 und x = b > 0:
#  (&int;)[-1]^(b)f(x) &DifferentialD;x= (lim)(&int;)[-1]^(-varepsilon)f(x) &DifferentialD;x +(lim) (&int;)[varepsilon]^(b)f(x) &DifferentialD;x = (lim) (1)/(2)(varepsilon^(2)-1)/(varepsilon^(2))+(lim) (1)/(2)(b^(2)-varepsilon^(2))/(varepsilon^(2)b^()) .;
> I1:=int(f,x=-1..-epsilon) assuming epsilon::positive;
> I2:=int(f,x=epsilon..b) assuming epsilon::positive, b::positive;
# Die Grenzwertbildung an den Einzelintegralen liefert: 
> limit(I1,epsilon=0); limit(I2,epsilon=0);
# Die Grenzwerte der einzelnen Integrale existieren leider nicht. Allerdings existiert der als Cauchy  Hauptwert  (CH) bezeichnete Grenzwert
# CH int(f(x), x = -1 .. b) = limit([int(f(x), x = -1 .. -varepsilon)+int(f(x), x = varepsilon .. b)], varepsilon = 0) and limit([int(f(x), x = -1 .. -varepsilon)+int(f(x), x = varepsilon .. b)], varepsilon = 0) = limit([(1/2)*(varepsilon^2-1)/varepsilon^2+(1/2)*(b^2-varepsilon^2)/(varepsilon^2*b^2)], varepsilon = 0) and limit([(1/2)*(varepsilon^2-1)/varepsilon^2+(1/2)*(b^2-varepsilon^2)/(varepsilon^2*b^2)], varepsilon = 0) = (1/2)*(b^2-1)/b^2;
# Der Cauchy Hauptwert existiert und berechnet sich zu
> limit(I1+I2,epsilon=0);
# Dieses Ergebnis liefert uns auch Maple mit der Zusatzinformation  CauchyPrincipalValue  
> int(f,x=-1..b,CauchyPrincipalValue) assuming b::positive;
# Wir betrachten einen weiteren Integranden, 
> f:=unapply(1/(x+a)^2,x,a);
# der an der Stelle x = -a eine Polstelle besitzt. Integrieren wir von x = 0  bis  x = 2, dann macht  Maple darauf aufmerksam, dass im Falle -2 < a < 0 eine Diskontinuitt im Integranden vorliegt, und damit der Wert des Integrals  wird.  
> Int(f(x,a),x = 0..2)=int(f(x,a),x = 0..2);
# Mit der Zusatzoption continuous teilen wir Maple mit, dass innerhalb des gewhlten Integrationsbereiches der Integrand stetig verluft. 
> Int(1/(x+a)^2,x = 0 .. 2)=int(1/(x+a)^2,x = 0 .. 2,'continuous');
# Wir betrachten das uneigentliche Integral   Typesetting[delayDotProduct]((int(ln*x/(x^2+1), x = 0 .. infinity)) . Der, Graf, true)*des*Integranden, (der*an*der)*Stelle*x = verschwindet, zeigt*F*olgendes;
> f:=ln(x)/(1+x^2);
> plot(f,x=0..5,y=-2..0.5,color="NavyBlue",thickness=2,filled=[color="Blue",transparency =.5],gridlines);
> Int(f,x=0..1)=int(f,x=0..1); Int(f,x=1..infinity)=int(f,x=1..infinity);
# Die Catalansche Konstante  Catalan hat den nummerischen Wert
> evalf(Catalan);
# Damit folgt
> Int(f,x=0..infinity)=int(f,x=0..infinity);
# Mittels der Heaviside-Funktion lassen sich Integranden abschnittsweise definieren. Maple kann damit rechnen:
> Int(g(x)*Heaviside(x-1),x =-1..3)=int(g(x)*Heaviside(x-1),x =-1..3);
# Als weiteres Beispiel eines uneigentlichen Parameterintegrals betrachten wir die Laplace-Transformierte der Funktion f(t);. Die Laplace-Transformation ist in der Schwingungslehre von groer Bedeutung.
> f:='f': t:='t':
> p:=unapply(Int(f(t)*exp(-s*t),t=0..infinity),s);
# Wir berechnen die Laplace-Transformierte des Einheitssprungs an der Stelle  t = 2
> f(t):=Heaviside(t-2);
> plot(f(t),t=0..5,axes=boxed,color=blue,thickness=2,gridlines);
> value(p(s));
# Bequemer erfolgt die Transformation mit dem Befehl  laplace  aus der Bibliothek inttrans: 
> with(inttrans):
> LT:=laplace(f(t),t,s);
# Die Umkehrung der Laplace-Transformation in den Originalbereich erfolgt durch den Befehl  invlaplace  
> invlaplace(LT,s,t);
# Ein weiteres Beispiel
> f:=piecewise(t>0 and t<3,1,t>3,0);
> f:=convert(f,Heaviside);
> p(s)=value(%);
> laplace(f,t,s);
# Wie bereits erwhnt, lassen sich nicht zu allen Funktionen f(x) die Stammfunktionen in geschlossener Form angeben. Hierzu als weiteres Beispiel die von  Euler mittels eines uneigentlichen Parameterintegrals  definierte  Gamma-Funktion: 
> Int(t^(x-1)*exp(-t),t=0..infinity)=int(t^(x-1)*exp(-t),t=0..infinity);
# Die  Gamma-Funktion besitzt die Eigenschaft, dass die Werte von  GAMMA(x+1); fr ganzzahlige  x  gleich  x!  (x-Fakultt) sind. Ein Zahlenbeispiel besttigt das
> GAMMA(3)-2!;
> plot(GAMMA(x),x=-5..5,-5..5,axes=boxed,color=blue,gridlines);
# Ein weiteres Beispiel:
> f:=unapply(x^(-1/2)*cos(x),x);
# Wir stellen die Funktion  f(x)  grafisch dar.;
> plot(f(x),x=0..5*Pi,y=-1..2,color="NavyBlue",thickness=2,filled=[color="Blue",transparency =.5],axes=framed,gridlines);
# Maple liefert uns folgendes Integral
> Int(f(t),t=0..x)=int(f(t),t=0..x);
# Das FresnelCosinus-Integral ist in Maple wie folgt definiert:  FresnelC(x)=(&int;)[0]^(x)cos(1/2 Pi t^( 2)) &DifferentialD;t.   ;
> INTA:=unapply(int(f(t),t=0..x),x);
> plot(INTA(x),x=0..2*Pi,axes=boxed,gridlines,thickness=2,color=blue);
# Wir werten das Integral an der Stelle  x = 5/4  nummerisch aus und erhalten
> evalf(INTA(5/4*Pi));
# Entwickeln wir den Integranden  f(t);  an der Stelle t = 0  in eine Potenzreihe 
> ser:=convert(series(f(t),t=0,10),polynom);
# und integrieren anschlieend gliedweise, was im betrachteten Intervall  absolute  Konvergenz voraussetzt, dann liefert Maple
> INTR:=unapply(int(ser,t=0..x),x);
# Ein Vergleich mit der (analytisch) berechneten Stammfunktion ergibt  an der Stelle x = 5/4
> evalf(INTR(5/4*Pi));
# Wir vergleichen grafisch die Nherung der Stammfunktion mit der nummerisch ermittelten Kurve
> pl1:=plot(INTA(x),x=0..2*Pi,y=0..2,thickness=2,color=blue,thickness=2):
> pl2:=plot(INTR(x),x=0..2*Pi,y=0..2,thickness=1,color=red,thickness =1):
> display([pl1,pl2],gridlines,axes=boxed);
# Wir lassen uns den wahren Fehler grafisch ausgeben, der fr x < Pi;  immerhin kleiner als 0,42% ist
> plot(abs(INTA(x)-INTR(x)),x=0..Pi,thickness=2,color=blue,gridlines,axes=boxed);
# Auch Vektor- und Matrizenfunktionen knnen mit Maple integriert werden. Das funktioniert wieder mit dem Befehl map. Wir erzeugen uns zunchst einen Vektor und eine Matrix, deren Komponenten von x und y abhngen:
> j:='j':i:='i':
> f:= unapply(y^j*x^(j-1),j):  g:= unapply(y^(i)*x^(i-j+1),i,j):
> A:=Vector(3,f):B:=Matrix(3,3,g): print(A,B);
> AI:=map(Int,A,y) = map(int,A,y);
> BI:=map(Int,B,x) = map(int,B,x);
# Mit Maple lassen sich auch  Mehrfachintegrale  berechnen. Wir betrachten die folgenden Doppelintegrale
> Int(x*y^2,[x,y])=int(x*y^2,[x,y]);
> Int(x*y^2,[y,x])=int(x*y^2,[y,x]);
> Int(Int(x*y^2,y=0..sqrt(1-x)),x=0..1)= int(int(x*y^2,y=0..sqrt(1-x)),x=0..1);
> Int(x*y^2,[y=0..sqrt(1-x),x=0..1])= int(x*y^2,[y=0..sqrt(1-x),x=0..1]);
# Enthalten die Integrationsgrenzen Dezimalzahlen, dann wertet Maple das Integral nummerisch aus:
> Int(Int(x*y^2,y=0..sqrt(1-x)),x=0..1.)= int(int(x*y^2,y=0..sqrt(1-x)),x=0..1.);
# Die gemeine Schraublinie (Helix) hat die Parameterdarstellung x = a cos t,  y = a sin t, z = p t. 
> r:='r': t:='t': a:='a': p:='p': n:='n':
> r:=Vector([a*cos(t),a*sin(t),p*t]):rp:=map(diff,r,t):
> print(r,rp);
# Die Bogenlnge dieser Raumkurve berechnet sich zu:  L(t) = int(sqrt((diff(r(tau), tau))^2), tau = 0 .. t);     NULL;
> rpq:=simplify(DotProduct(rp,rp,conjugate=false),trig);
> L:=int(sqrt(rpq),tau=0..t);
# Ist h die Ganghhe und n die Windungszahl, dann gilt p = h/(2)  und  t = 2 n  
> simplify(subs(p=h/2/Pi,t=2*n*Pi,L));
# Der Durchhang eines schweren  Seils wird beschrieben durch die Kettenlinie  y = a cosh(x/a)   a > 0
> y:=unapply(a*cosh(x/a),x,a);
> plot(y(x,1),x=-1..1,gridlines,axes=boxed,color="NavyBlue",thickness=2);
# Die Neigung der Tangente  an die  Kettenlinie ist 
> ystr:=unapply(diff(y(x,a),x),x,a);
# Die Seillnge L im Interval [0...x] ermitteln wir aus der Beziehung  L(x)=(&int;)[0]^(x)sqrt(1+y^('2)(t)) &DifferentialD;t; .
> L:=unapply(int(sqrt(1+ystr(t,a)^2),t=0..x),x,a) assuming x::positive;
> simplify(L(x,a)) assuming x::positive, a::positive;
# Mit Maple lassen sich auch Ableitung von Parameterintegralen vornehmen:
> restart:
# Das von einem Parameter (hier x) abhngige Integral 
> g:=int(f(x,u),u=a(x)..b(x));
# wird  als Parameterintegral bezeichnet. Der Parameter x  tritt  im Integranden und an der oberen und unteren  Grenze des Integrals auf. Die Ableitung eines solchen Integrals nach dem Parameter  x  erfolgt mittels der Leibnizregel. Maple liefert korrekt:
> Diff(g,x)=diff(g,x);
# Hinweis: Solche Integrale treten beispielsweise im Zusammenhang mit der Berechnung der Knicklasten von Sttzen mit vernderlichem Querschnitt unter Eigengewichtsbelastung (spezifisches Gewicht ) auf  (s.h. Technische Mechanik 2, Festigkeitslehre mit Maple-Anwendungen, Kap. 10).
> h:=hu+(ho-hu)/l*x;  #linear vernderliche Querschnittshhe ber die Sttzenlnge l
;
> A:=unapply(b*h,x);  #Querschnittsflche
;
> int(gamma*A(u)*(w(x)-w(u)),u=x..l); 
> simplify(diff(%,x));
> 
;
