# Lektion 8
# Differenzialrechnung und Taylor-Reihen
#  2017  Friedrich U. Mathiak, 
# mathiak@mechanik-info.de
# 
> restart:with(LinearAlgebra): with(plots):
# Die Ableitung von Ausdrcken oder Operatoren erfolgt in Maple mit dem  diff-Kommando  oder dem  D-Operator. Das Diff-Kommando ist unttig und schreibt nur den Befehl, die Ausfhrung selbst erfolgt mit diff. Beispiele hierzu sind:
> Diff(sin(x),x)=diff(sin(x),x);
> Diff(x*sin(cos(x)),x)=diff(x*sin(cos(x)),x);
# Hhere Ableitungen
> Diff(x*sin(cos(x)),x,x,x)=diff(x*sin(cos(x)),x,x,x);
# Das geht auch etwas krzer mit 
> Diff(x*sin(cos(x)),x$3)=diff(x*sin(cos(x)),x$3);
# Ebenfalls knnen partielle Ableitungen gebildet werden 
> Diff(x^2+x*y^2,x)=diff(x^2+x*y^2,x);
> Diff(2*x+y^2,y)=diff(2*x+y^2,y);
> Diff(x^2+x*y^2,y,x)=diff(x^2+x*y^2,y,x);
> diff(f(x,y),y,x);
# Ableitung transzendenter Funktionen:
> Diff(tan(x),x)=diff(tan(x),x);
> Diff(BesselJ(v,x),x)=diff(BesselJ(v,x),x);
# Die Ableitungen von Operatoren werden mit dem D-Operator durchgefhrt. Zum Unterschied zwischen D und diff  wird auf  operators[D] verwiesen.
> D(sin);D(sqrt);D(ln);
> D(tan);%(x);D(tan)(x);
> g:=unapply(x^4,x);
# Bildung der 1. Ableitung mit dem Operator D
> D(g);
> D(g)(x);D(g)(2);
# Ohne auf die Begriffe Geschwindigkeit und Beschleunigung nher einzugehen, wird als Beispiel der schiefe Wurf ohne Luftwiderstand betrachtet.  In den folgenden Gleichungen bezeichnet t e 0 die Zeit, v0 ~ 0  die positive Anfangsgeschwindigkeit und 0 d  d /2 den Abwurfwinkel einer Punktmasse gegenber der positiven x-Achse. Zur Zeit t  hat die Punktmasse die Koordinaten
> x:=unapply(v0*t*cos(alpha),t,v0,alpha); y:=unapply(-g*t^2/2+v0*t*sin(alpha),t,v0,alpha);
#  Eliminieren wir aus der zweiten Gleichung fr y die aus der ersten Gleichung fr x folgende Zeit t, also  t = x /(v0 cos) , dann erhalten wir folgende explizite Darstellung der Wurfparabel
> ye:=unapply(subs(t=x/(v0*cos(alpha)),y(t,v0,alpha)),x,v0,alpha);
# Die Koordinate xS des Scheitelpunktes der Wurfparabel erhalten wir aus der Forderung
> xS:=solve(D[1](ye)(x,v0,alpha),x);
# Die maximale Wurfhhe 
> yS:=ye(xS,v0,alpha);
# wird damit zu folgendem Zeitpunkt erreicht:
> tS:=xS/v0/cos(alpha);
# Die grte Wurfweite  ermitteln wir aus der Bedingung  ye = 0. Wir erhalten zwei Lsungen, wobei wir hier nur an xmax > 0 interessiert sind:
> solve(ye(x,v0,alpha),x);
> xmax:=%[2];
# Bei festem  Zielpunkt xmax  und fester Anfangsgeschwindigkeit  v0  existieren zwei Abwurfwinkel : 
> alpham:=solve(diff(xmax,alpha),alpha);
# Wir interessieren uns fr den Wurf nach rechts ( < /2) und whlen deshalb
> alphamax:=alpham[1];
# Die grte Wurfweite wird also bei einem Abwurfwinkel von  = /4 ( = 45) erreicht, und die Wurfzeit betrgt 
> solve(subs(alpha=alphamax,y(t,v0,alpha)),t); tmax:=%[2];
# Wir beschaffen uns eine Animation der Wurfbahnen fr unterschiedliche Abwurfwinkel 
> g:=10: v0:=15: alpha1:=Pi/6: alpha2:=Pi/4: alpha3:=Pi/3: xm:=eval(subs(alpha=alphamax,xmax)): ym:=subs(alpha=Pi/3,yS):
> pl1:=animatecurve(ye(x,v0,alpha1),x=0..xm,frames=20,color=black):   # alpha=30
> pl2:=animatecurve(ye(x,v0,alpha2),x=0..xm,frames=20,color= gold):   # alpha=45
> pl3:=animatecurve(ye(x,v0,alpha3),x=0..xm,frames=20,color=  red):   # alpha=60
;
> display([pl1,pl2,pl3],axes=boxed,gridlines,view=0..ym,title="\nWurfparabeln fr unterschiedliche Abwurfwinkel\n",titlefont=["ROMAN", 15],labels=["Wurfweite","Wurfhhe"],labeldirections=["horizontal", "vertical"], labelfont = ["HELVETICA", 10]);
# Die Abwurfwinkel 1 = /6 (Flachwurf)  und 3 = /3 (Steilwurf)  fhren zu gleichen Wurfweiten xmax = v*`0`^2*sqrt(3)/(2*g); .
# Als weiteres Beispiel betrachten wir die Biegelinie eines Balkens der Lnge , der links eingespannt und rechts drehbar gelagert ist. Im Einzelnen bedeuten (q0: Konstante Linienkraft, : Lnge des Balkens, E: Elastizittsmodul, Iyy: Axiales Flchentrgheitsmoment, B = EIyy: Biegesteifigkeit,   = x/: Normierte Stabachskoordinate) 
> K:=q0*l^4/(48*B);
> w:=unapply(K*(3*xi^2-5*xi^3+2*xi^4),xi);
# Aus der Biegelinie lassen sich durch Differenziationsoperationen folgen Gren berechnen:
# 1.)  w'                  Neigung der Tangente an die Biegelinie
# 2.)  M = - Bw''    Biegemoment 
# 3.)  Q  = - Bw'''   Querkraft 
# Achtung: In den folgenden Ableitungen ist die Kettenregel diff(w(x), x) = (diff(w(xi), xi))*(diff(xi(x), x)) and (diff(w(xi), xi))*(diff(xi(x), x)) = (diff(w(xi), xi))/`&ell;`; zu beachten.
> wst:=unapply(diff(w(xi),xi)/l,xi);
> M:=unapply(-B*diff(w(xi),xi$2)/l^2,xi);
> Q:=unapply(-B*diff(w(xi),xi$3)/l^3,xi);
# Die Durchbiegung wird dort extremal, wo deren 1. Ableitung verschwindet
> loe:=solve(wst(xi),xi);evalf(loe);
# Der physikalisch sinnvolle Wert im Bereich 0 <  < 1 ist
> xiw:=loe[3];
# Dazu gehrt die grte Durchbiegung im Feld
> maxw:=simplify(w(xiw));evalf(%);
# Das Schnittlasten (Biegemoment und Querkraft) am eingespannten Rand (x = 0) sind
> ME:=M(0);QE:=Q(0);
# Von Interesse ist noch das grte Feldmoment. Es wird dort extremal, wo die Querkraft verschwindet. 
> xst:=solve(Q(xi),xi);MFm:=simplify(M(xst));
# Wir konkretisieren unser Problem und plotten die normierten Zustandsgren fr folgendes Zahlenbeispiel
> q0:=1;B:=1;l:=1;
> par:=xi=0..1,titlefont=["ROMAN",14],color="NavyBlue",thickness=3,filled=[color = "Blue",transparency = .5],gridlines,axes=boxed:
> p1:=plot(w(xi),par,title="\nNormierte Durchbiegung\n"):
> p2:=plot(wst(xi),par,title="\nNormierte Tangentenneigung\n"):
> p3:=plot(M(xi),par,title="\nNormiertes Biegemoment\n"):
> p4:=plot(Q(xi),par,title="\nNormierte Querkraft\n"):
> plotmatrix:=Matrix(1,4,[p1,p2,p3,p4]):
> plots[display](plotmatrix);
# Die grte (normierte) Durchbiegung im Feld ist
> maxw:=simplify(w(xiw));evalf(maxw);
# maxw ist eine irrationale Zahl, die durch eine Folge rationaler Zahlen dargestellt werden kann und gegen den Grenzwert maxw konvergiert. Ein solche konvergente Folge bildet die Kettenbruchentwicklung von maxw, die in Maple mit dem Befehl cfrac  aus der Bibliothek  numtheory  erzeugt wird:
> numtheory[cfrac](maxw,6);
# oder auch weniger umfangreich mit Verwendung einer Zusatzoption confrac
> convert(maxw,confrac,liste);
# Wir geben die Liste der Kettenbrche aus
> liste;
> evalf(%);
# In Tabellenwerken der Ingenieurliteratur findet man den Nherungswert maxw = 2/369 q0 4/B. Wir lassen uns die obige Liste grafisch ausgeben und stellen fest, dass sich die Werte  fr n > 1 nur wenig unterscheiden, dennoch ist der Vorfaktor 1/185 den Ingenieuren noch zu ungenau.
> p1:=listplot(liste,style=point,color=red,symbolsize=10): display(p1);

# Maple gestattet uns mit dem Befehl  map  das Differenzieren von Matrix- und Vektorkomponenten. Wir konstruieren dazu eine Matrix A:
> f := unapply((x-y)^(i-j),i,j);
> A:=Matrix(3, f): Ax:=map(diff,A,x): Axy:=map(diff,A,x,y):
> print(A,Ax,Axy);
# Das funktioniert  auch mit Vektoren. Wir beschaffen  uns dazu die dritte Spalte von A:
> V3_A := Column(A,3): 
# und differenzieren partiell
> V3_Ax:=map(diff,V3_A,x): V3_Ay:=map(diff,V3_A,y): V3_Axy:=map(diff,V3_A,x,y):
> print(V3_A, V3_Ax, V3_Ay, V3_Axy);
# Taylor-Reihen
# Die Taylor-Reihe ist eine Potenzreihe, deren Glieder Potenzen und damit Funktionen einer unabhngigen Variablen (hier x) sind.
# P(x) = sum(f(x[0])^n*(x-x[0])^n/factorial(n), n = 0 .. infinity);
# Der Punkt x0 heit Entwicklungspunkt, und  ((D@@n)(f))(x[0]); bezeichnet die n-te Ableitung der Funktion f(x) an der Stelle x = x[0];. Wird die Reihe nach dem n-ten Glied abgebrochen, dann sprechen wir von einem Taylor-Polynom der Ordnung n und erhalten
# P[n](x) = sum(f(x-x[0])^nu*(x-x[0])^nu/factorial(n), nu = 0 .. n);
# Die Konstruktion des Taylor-Polynoms  P[n](x); erfolgt so, dass an der Stelle x[0]; die Taylor-Reihe denselben Funktionswert und dieselben Ableitungen bis zur Ordnung n besitzt wie die Funktion f(x) . 
# Als Beispiel betrachten wir den Hyperbelsinus 
> f:=sinh(x);
# Die folgenden Befehle liefern uns die Taylor-Polynome ersten  bzw. vierten Grades, entwickelt an der  Stelle x0 = 1. 
> x0:=1:
> n:=1: p1:=convert(series(f,x=x0,n+1),polynom); 
> n:=4: p4:=convert(series(f,x=x0,n+1),polynom); 
> plot([f,p1,p4],x=-3..3,-4..5,color=[black,blue,red],legend=["sinh","p1","p4"],axes=normal,thickness=2,gridlines);
# Die blaue Linie zeigt die Tangente an der Stelle x = 1. Das Polynom hheren Grades (n = 4) fhrt im positiven Bereich offensichtlich zu einer besseren Anpassung. 
# Wir betrachten die Funktion
> f:=1/(1-x); plot(f,x=-2..4,-5..5,axes=boxed,gridlines);
# und entwickeln sie in eine Potenzreihe an der Stelle x = 0
> series(f,x=0,6);
# Die obige Reihe wird geometrische Reihe genannt. Sie konvergiert nur fr Werte |x| < 1 und hat dann den Summenwert 1/(1-x);
> n:='n':
# Das folgende Beispiel zeigt die Potenzreihenentwicklung der binomischen Reihe um den Punkt x[0] = 0;. 
> f:=(1+x)^n;       series(f,x=0,5);
# Ist n eine nichtnegative ganze Zahl, dann bricht die Reihe mit der hchsten Potenz xn ab:
> n:=3: series(f,x=0,5);
> n:=1/2:series(f,x=0,5);
# Reihenentwicklungen von Funktionen werden mit groem Erfolg im gesamten Ingenieurwesen eingesetzt. Wollen wir beispielsweise Werte der Kosinusfunktion im Intervall [0, /4] nherungsweise berechnen, dann beschaffen wir uns zunchst die entsprechende Reihenentwicklung, indem wir cos(x) um den Punkt x[0] = 0; in eine Reihe entwickeln. 
> series(cos(x),x=0,10);
# Wir verwenden folgende Nherungspolynome
> TP_6:=convert(series(cos(x),x=0,8),polynom);
> TP_4:=convert(series(cos(x),x=0,6),polynom);
# und stellen die Funktion cos(x) und ihre Nherungen im Intervall 0  d x d  grafisch dar
> plot([cos(x),TP_6,TP_4],x=0..Pi,-1..1,color=[black,blue,red],legend=["cos","TP_6","TP_4"],axes=boxed,thickness=2,gridlines);
# Ein Blick auf die Grafen zeigt, dass fr Werte 0 < x < /2 die Kosinusfunktion durch beide Nherungen recht gut wiedergegeben wird. Aufschlureich ist auch eine Darstellung des wahren relativen Fehlers fr die Approximation TP_6 im Intervall [0, /4]:
> plot((TP_6-cos(x))/cos(x),x=0..Pi/4,axes=boxed,gridlines);
# Fr die Wahl x = /4 vergleichen wir den Nherungswert mit dem exakten Wert cos(/4) =  1/2 sqrt(2); und finden bereinstimmung auf fnf Stellen hinter dem Komma:
> evalf(subs(x=Pi/4,TP_6)),1/sqrt(2.);
# Schlechter wird das Ergebnis, wenn wir den Kosinus des Winkels /2 mit der Nherung TP_6 berechnen, der exakte Wert ist Null.
> evalf(subs(x=Pi/2,TP_6));
# Partielle Ableitungen
# Wir betrachten die normierte Biegeflche einer durch eine konstante Flchenkraft beanspruchte dnne Platte im Intervall [-1 <= xi and xi <= 1, -1 <= eta and eta <= 1];, die an ihren Ecken punktfrmig gelagert ist.
> w:=unapply(11/24-(5/24)*xi^2-(5/24)*eta^2+(1/24)*xi^4+(1/24)*eta^4-(1/8)*xi^2*eta^2,xi,eta);
> plot3d(w(xi,eta),xi=-1..1,eta=-1..1,axes=boxed,labels=[xi,eta,w],grid=[60, 60],orientation=[125,-60,180],color=xi,lightmodel=light1);
# Von dieser Funktion bilden wir die partiellen Ableitungen nach  und :
> Diff(w(xi,eta),xi) = D[1](w)(xi,eta);
> Diff(w(xi,eta),eta) = D[2](w)(xi,eta);
# Nun bilden wir noch die drei zweiten partiellen Ableitungen. 
> Diff(w,xi  ,xi)=D[1,1](w)(xi,eta);
> Diff(w,eta,eta)=D[2,2](w)(xi,eta);
> Diff(w,xi ,eta)=D[1,2](w)(xi,eta);
> Diff(w,eta ,xi)=D[2,1](w)(xi,eta);
# Maple besttigt mit den letzten zwei Zeilen die Schwarzsche Vertauschungsregel. 
# Die partiellen Ableitungen der Biegeflche hngen eng mit den Schnittlasten der Platte zusammen. Im Fall verschwindender Querdehnung ist beispielsweise -bis auf eine Konstante- das Biegemoment m[`&xi;&xi;`];  gegeben durch
# m[xixi]=-((&PartialD;)^(2) w(xi,eta))/(&PartialD; xi^(2)) ;
> mxixi:=-D[1,1](w)(xi,eta);  
> plot3d(mxixi,xi=-1..1,eta=-1..1,style=Patch,axes=boxed,color=xi,lightmodel=light1,scaling=constrained,orientation=[-135,55,0]);
# Wir lassen uns die Konturlinien anzeigen, das sind Linien gleicher Funktionswerte, die in der Statik zur nummerischen Auswertung von Einflussflchen bentigt werden.
> plot3d(mxixi,xi=-1..1,eta=-1..1,axes=boxed,style=patchcontour,contours=10,scaling=constrained,orientation=[-90,0,0]);
# Zur Bildung der Ableitung von Funktionsoperatoren kommt der D -Operator zum Einsatz. Damit stellen sich die ersten und zweiten Ableitungen wie folgt dar:
> D[1](w); D[2](w);
> D[1,1](w); D[1,2](w); D[2,2](w);
# Wir ermitteln die Gleichung der Tangentialebene an die Flche w(, ) im Punkt (0,0) , die wir aus der zweidimensionalen Taylor-Reihe vom Grade 1 erhalten. Dazu bentigen wir das Paket MultivariateCalculus  aus der Bibliothek  Student
> with(Student[MultivariateCalculus]):
> TF1:=unapply(TaylorApproximation(w(xi,eta),[xi,eta]=[xi0,eta0],1),xi,eta);
# Der folgende Befehl liefert die zweidimensionale quadratische Approximation der Funktion w(, ) im Punkt (0,0) 
> TF2:=unapply(TaylorApproximation(w(xi,eta),[xi,eta]=[xi0,eta0],2),xi,eta);
# Wir stellen die Flche  w(, )  und deren Tangentialebene fr den Entwicklungspunkt P = (0 = 0.5, 0= 0.)  in einer Grafik dar.
> xi0:=0.5: eta0:=0.: 
> plot3d([w(xi,eta),TF1(xi,eta)],xi=-1..1,eta=-1..1,axes=framed,color=[blue,green],style=[patchcontour,patchnogrid],lightmodel=light1,transparency=[0,.6],orientation=[-120,-60,-180]);
# Die Approximation der Funktion durch ein Taylor-Polynom zweiten Grades, also die Annherung der Flche durch eine Flche zweiten Grades, erfordert bereinstimmungen nicht nur in den nullten und ersten, sondern auch in den zweiten partiellen Ableitungen. Wir stellen die Flche w zusammen mit ihrer Nherung zweiten Grades grafisch dar.
> plot3d([w(xi,eta),TF2(xi,eta)],xi=-1..1,eta=-1..1,style=[patchcontour,patchnogrid],axes=framed,color=[blue,red],lightmodel=light1,transparency=[0,0.6],orientation=[-50,-85]);
# Man sieht, dass sich die Flchennherung zweiten Grades in der Umgebung des Entwicklungspunktes bereits gut an die Ursprungsflche anschmiegt. Um den Approximationsfehler genauer beurteilen zu knnen, plotten wir den Betrag der Differenz beider Funktionen aus.
> plot3d(abs(w(xi,eta)-TF2(xi,eta)),xi=-1..1,eta=-1..1,style=patchcontour,axes=boxed,shading=z,lightmodel=light1,grid=[50,50],orientation=[-65,60,0]);
> restart:
# Der Zusammenhang zwischen zwei Variablen x und y  kann in folgenden Formen gegeben werden:
# 1. Explizite Funktion:  y = f (x)                      Beispiel: y = 1/x
# 2. Implizite Funktion: F(x,y) = 0                    Beispiel: x2 + y2 - 1 = 0
# 
# Wir interessieren uns fr die Ableitung einer in impliziter Form gegebenen Funktion F(x,y) = 0.  Als Beispiel whlen wir die als Kartesisches Blatt bezeichnete Funktion
> F:=unapply(x^3+y^3=3*a*x*y,x,y,a);
#  Die Gerade 
> g:=unapply(x+y+a,x,y,a);
# ist Asymptote dieser  Kurve. Wir whlen a = 2 und geben den Grafen der Kurve aus:
> plots[implicitplot]([F(x,y,2),g(x,y,2)],x=-5..4,y=-5..4,linestyle=[solid,longdash],coloring=["SteelBlue","DarkGreen"],filledregions=true,gridrefine=2,crossingrefine=2,resolution=1000);
# Sei y = y(x), dann erhalten wir aus  (&PartialD;)/(&PartialD; x) F(x,y) = 0=(&PartialD;)/(&PartialD; x) (x^(3)+y^(3)-3 a x y)=3 x^(2)+3 y^(2)y'-3 ay-3 axy'.;
# Lsen wir diese Beziehung nach  (diff(y(x), x))*auf, dann;erhalten wir diff(y(x), x); =(-x^2+ay)/(y^2-ax); .
# Dieses Ergebnis liefert uns auch Maple mit dem Befehl  implicitdiff  
> ystr:=unapply(implicitdiff(F(x,y,a),y,x),x,y,a);
# Mit  a = 2 liegt der Punkt  P0  (x0 = 3, y0 = 3) auf der Kurve:
> F(3,3,2);
# Dort besitzt die Kurve die Tangentenneigung
> ystr(3,3,2);
> 
;
# 
# 
# 
