Mathematik von T. Arens, F. Hettlich, Ch. Karpfinger, U. Kockelkorn, K. Lichtenegger, H. Stachel (zu Kapitel 24: Funktionen mehrerer Variablen)restart;Vektorwertige Funktionen in mehreren VeraenderlichenSkalarwertige Funktionen in mehreren Variablen koennen wie gewohnt entweder in Form von Ausdruecken oder als Funktionen in Maple eingeben werden, etwa f:=(x,y)->x^2+y^2-x*y;Der Befehl plot3d zeigt uns den Graphen dieser Funktion.plot3d(f,-2..2,-2..2,axes=normal);Drehen wir das Bild, so erhalten wir eine gute Vorstellung von der Flaeche. Durch die verschiedenen Optionen (hier z.B. axes = fuer die Darstellung des Koordinatinesystems) bieten sich Moeglichkeiten an, das Bild den eigenen Wuenschen entsprechend zu erstellen. Durch Umlenken der Ausgabe (interface) oder die Auswahl Export, bei Verwendung der rechten Maustaste auf dem Bild, koennen solche Bilder in verschiedenen Formaten gespeichert werden.
Die Konturlinien einer Funktion in mehreren Variablen koennen wir uns auch anzeigen lassen, mit dem Befehl contourplot , der im plots Paket implementiert ist.with(plots):
contourplot(f(x,y),x=-2..2,y=-2..2,contours=10,scaling=constrained, thickness=2);Mit Optionen, lassen sich die Anzahl der Konturlinien oder die Niveaus, die Linienstaerke, die Skalierung, die Farbe und vieles mehr einstellen.Der Befehl fieldplot liefert uns eine anschauliche Darstellung von Vektorfeldern g: KiRJIlJHNiIiIiM=-> KiRJIlJHNiIiIiM=g1:=(x,y)->-y/(x^2+y^2)^(5/8);
g2:=(x,y)->x/(x^2+y^2)^(5/8);
fieldplot([g1,g2],-1..1,-1..1,scaling=constrained);Um die partiellen Ableitungen von f zu ermitteln, koennen wir wiederum den Operator D bzw bei Ausdruecken diff verwenden. Selbsverstaendlich muss angegeben werden, nach welcher Variablen differenziert werden soll. Beim Operator D durch den Index der Variablen und bei Ausdruecken durch den Namen der Variablen. Auch hoehere Ableitungen lassen sich so bestimmen. D[2](f); D[1,2](f);bzw.diff(f(x,y),y); diff(f(x,y),x,y);Nun laesst sich etwa in den Konturplot der Funktion auch der Gradient mit einzeichnen.p1:=contourplot(f,-2..2,-2..2,thickness=1):
p2:=fieldplot([D[1](f),D[2](f)],-2..2,-2..2,thickness=1,color=blue,scaling=constrained):
display(p1,p2);
und wir bekommen einen Eindruck davon, dass der Gradient stets senkrecht auf den Hoehenlinien steht. Im Paket linalg sind einige Differentialoperatoren fest implementiert. So koennen wir etwa den Gradienten von f durch folgenden Befehl berechnen lassen.with(linalg):
grad(f(x,y),[x,y]);Dabei muss das erste Argument der Funktionsausdruck sein und das zweite Argument enthaelt eine Liste oder einen Vektor der Variablen. Beachten Sie, dass im Gegensatz zur Konvention im Buch Vektoren in Maple im allgemeinen als Zeile notiert werden. Sobald die betrachteten Funktionen vektorwertig werden, koennen wir entweder komponentenweise vorgehen oder wir nutzen Felder um die Funktionen einzugeben, etwaf:=(x)->vector([x[1]^2+x[2]^2,x[1]*x[2]]);f(vector([2,3]));Analog zum Gradienten ist auch die Jakobimatrix im linalg Paket schon als Operation vorgegeben. J:=jacobian(f(x),[x[1],x[2]]);Dabei ist das erste Argument ein vektorwertiger Ausdruck und das zweite Argument wiederum eine Liste der Variablen. Das Ergebnis ist nun vom Typ Matrix.type(J,matrix);Moechten wir den Vektor bestehend aus den Ableitungen nach einer bestimmten Variablen erzeugen, so koennen wir den Befehl map verwenden, der die angegebene Operation auf jede Komponente anwendet.map(diff,f(x),x[1]);Das erste Argument bezeichnet den Operator, das zweite das komponentenweise zu differenzierende Feld, und das dritte Argument gibt das zweite Argument fuer diff an, die Variable nach der differenziert werden soll. Implizit gegebene FunktionenWir versuchen uns den Satz ueber implizit gegebene Funktionen mit den graphischen Moeglichkeiten von Maple klar zu machen. Als Beispiel dient die Funktion f:=(x,y)-> -y*sin(x)-x*cos(y)+Pi/2;
mit ihrem Graphenplot3d(f,-2..2,-2..2,axes=boxed);Nun betrachten wir das Niveau L0kiZkc2IiIiIQ==, also den Schnitt des Graphen mit der Ebene LyZJInhHNiI2IyIiJCIiIQ==. g:=(x,y)-> 0;with(plots):
with(plottools):
p1:=plot3d(f,-2..2,-2..2,axes=boxed,style=patchnogrid):
p2:=plot3d(g,-2..2,-2..2,color=gray,style=patchnogrid):
p3:=plot3d(f,-2..2,-2..2,style=contour,contours=[0.0],thickness=3,color=black):
p4:=sphere([Pi/2,Pi/2,0],0.1,style=patchnogrid,color=red):
display(p1,p2,p3,p4);Als Punkt auf diesem Niveau sei LzYlJkkieEc2IjYjIiIhJkkieUdGJkYnRig2JSwkSSNQaUclKnByb3RlY3RlZEcjIiIiIiIjRixGKA== gegeben. Zur Kontrolle:f(Pi/2,Pi/2);DaD[1](f)(Pi/2,Pi/2);
D[2](f)(Pi/2,Pi/2);gilt, liefert der Satz ueber implizit gegebene Funktionen, dass lokal um den Punkt (JkkieEc2IjYjIiIh , JkkieUc2IjYjIiIh) die schwarz eingezeichnete Niveaulinie als Funktion L0kieUc2Ii1GIzYjSSJ4R0Yk geschrieben werden kann. Da Ly0mSSJERzYkJSpwcm90ZWN0ZWRHSShfc3lzbGliRzYiNiMiIiI2I0kiZkdGKSIiIQ== gilt, kann es aber keine Funktion L0kieEc2Ii1GIzYjSSJ5R0Yk geben. Dies ist anschaulich offensichtlich, wenn das obige Bild so gedreht wird, dass wir von oben auf die SSJ4RzYi,SSJ5RzYi - Ebene sehen, und wir den Verlauf der schwarzen Kurve beim roten Punkt betrachten.Weiter koennen wir implizit differenzieren, um die Ableitungen der Funktion y(x) in der Stelle (NiQmSSJ4RzYiNiMiIiEmSSJ5R0YlRiY=) zu bestimmen. Damit laesst sich die schwarz gezeichnete Niveaulinie, die wir explizit nicht kennen, zumindest in einer Umgebung des roten Punktes durch ein Taylorpolynom approximieren. Im naechsten Plot ist der Graph des Taylorpolynoms vom Grad zwei gezeigt (blaue Kurve),LUkiVEc2IjYjSSJ4R0Yk = LUkieUc2IjYjJkkieEdGJDYjIiIh + SSJ5RzYi'(JkkieEc2IjYjIiIh) (LCZJInhHNiIiIiImRiM2IyIiISEiIg==) + IyIiIiIiIw==SSJ5RzYi''(JkkieEc2IjYjIiIh) KiQsJkkieEc2IiIiIiZGJDYjIiIhISIiIiIj .Zunaechst berechnen wir die Ableitungen aus den Gleichungendy:=solve(D[1](f)(Pi/2,Pi/2) + D[2](f)(Pi/2,Pi/2)*dy=0,dy);undddy:=solve(D[1,1](f)(Pi/2,Pi/2) + 2*D[1,2](f)(Pi/2,Pi/2)*dy + D[2,2](f)(Pi/2,Pi/2)*dy^2 +
D[2](f)(Pi/2,Pi/2)*ddy=0,ddy);Somit erhalten wirp1:=plot3d(f,-2..2,-2..2,axes=boxed,style=patchnogrid):
p2:=plot3d(g,-2..2,-2..2,color=gray,style=patchnogrid):
p3:=plot3d(f,-2..2,-2..2,style=contour,contours=[0.0],thickness=3,color=black):
p4:=sphere([Pi/2,Pi/2,0],0.1,style=patchnogrid,color=red):
p5:=spacecurve([t,Pi/2+Pi/(4-2*Pi)*(t-Pi/2)^2,0],t=Pi/2-1/2..Pi/2+1/2,color=blue,thickness=3):
display(p1,p2,p3,p4,p5);Bemerkung: Der Befehl implictdiff bietet die Moeglichkeit einen Ausdruck implizit zu differenzieren. Das Newton-VerfahrenUm etwa beim Minimieren die Nullstellen des Gradienten zu finden, sind Nullstellen von vektorwertigen Funktionen gesucht. Wie im Buch gezeigt, laesst sich das Newton-Verfahren auf diese Situation verallgemeinern. Wir erweitern unser Programm zum Newton-Verfahren. Da die allgemeine vektorwertige Formulierung aufw\303\244ndiger ist, behandeln wir den eindimensionalen Fall separat. Im folgenden Vorschlag ist dies durch eine Fallunterscheidung realisiert.newtappr := proc (f, x0, N)
local i, n, xn, fp, fpxn, h, lall;
xn := x0;
if (type(x0,'float') or type(x0,'algnum')) then
fp := D(f);
lall := xn;
for i to N do
xn := xn - f(evalf(xn))/fp(evalf(xn));
lall := lall, xn
od;
elif (type(x0,'vector')) then
n := linalg[vectdim](x0);
fp := linalg[jacobian](f(x),vector([seq(x[j],j=1..n)]));
lall := [evalf(evalm(xn))];
for i to N do
fpxn := subs({seq(x[j]=evalf(xn[j]),j=1..n)},evalm(fp));
h := linalg[linsolve](fpxn,evalm(-f(evalf(xn))));
xn := evalm(xn + h);
lall := [op(lall), evalm(xn)];
od;
else
print(`wrong type of variable`)
end if;
lall;
end:Nun testen wir das Programm im vektorwertigen Fall. Dazu waehlen wir das Gleichungssytem LywmKiQmSSJ4RzYiNiMiIiIiIiNGKSokJkYmNiNGKkYqRikiIiU=, LyomJkkieEc2IjYjIiIiRigmRiU2IyIiI0YoRig=in der Menge D =[1,2] x [0,1] . Wir schreiben das System als Nullstellenproblem, etwaf:=x->vector([x[1]^2+x[2]^2-4, x[1]*x[2]-1]);Anschaulich bedeutet die Aufgabe, dass wir einen bestimmten Schnittpunkt von zwei Kurven suchen.p1:=contourplot(f(vector([x,y]))[1],x=-2..2,y=-2..2,contours=[0.0],thickness=3,color=blue,scaling=constrained):
p2:=contourplot(f(vector([x,y]))[2],x=-2..2,y=-2..2,contours=[0.0],color=blue,thickness=3):
p3:=circle([sqrt(2+sqrt(3)),1/sqrt(2+sqrt(3))],0.05,color=red,thickness=3):
p4:=line([1,0],[1,1],color=red,linestyle=DASH):
p5:=line([1,1],[2,1],color=red,linestyle=DASH):
p6:=line([2,1],[2,0],color=red,linestyle=DASH):
p7:=textplot([1.4,0.3,'D'],font=[COURIER,BOLD,22]):
display(p1,p2,p3,p4,p5,p6,p7);Mit dem Startpunkt (1,0) und dem Newton-Verfahren ergibt sichnewtappr(f,vector([1.,0.]),10);Auch wenn das Newton-Verfahren sicherlich die verbreiteste und in vielen Faellen sinnvollste Methode zur numerischen Loesung nichtlinearer Gleichungssysteme ist, sprechen wir hier noch einen anderen Weg an. Im Kapitel 28 wird der Banachsche Fixpunktsatz bei Differenzialgleichungssystemen genutzt. Die Aussage zur sukzessiven Approximation koennen wir aber auch einfach nutzen um Gleichungssysteme zu loesen. Dazu formulieren wir das Problem der Nullstellen von SSJmRzYi um zu einer Fixpunktgleichung, etwa fuer die Funktiong:=x->vector([x[1]-1/4*(x[1]^2+x[2]^2-4), x[2]-1/4*(x[1]*x[2]-1)]);In dem oben rot eingezeichneten Quadrat ist SSJnRzYi eine Selbstabbildung und kontrahierend. Eine sukkzessive Approximation approximiert somit auch die Loesungsukzappr := proc (g, x0, N)
local i, xn, lall;
xn := x0;
lall:=[evalf(evalm(xn))];
for i to N do
xn := evalf(evalm(g(xn)));
lall := [op(lall), evalm(xn)];
od;
lall;
end:sukzappr(g,vector([1,1]),20);Offensichtlich konvergiert diese Methode erheblich langsamer (es handelt sich nur um eine Konvergenz erster Ordnung). Andererseits ist eine Fixpunktiteration allgemeiner, da keine Ableitungen benoetigt werden und solche Verfahren mit nur groben Naeherungen als Startwerte auskommen, um zu konvergieren. ExtremaBei der Suche nach Extrema einer Funktion in mehreren Variablen, sind Nullstellen des Gradienten gesucht. Mit dem Newton-Verfahren koennen wir nun auch zum Beispiel bei der Funktion f mit Ly1JImZHNiI2JEkieEdGJUkieUdGJSomLCYqJEYoIiIjIiIiKiRGJ0YsISIiRi0tSSRleHBHNiQlKnByb3RlY3RlZEdJKF9zeXNsaWJHRiU2IywkLUkiKkdGMzYkLCZGLkYtRitGLSNGLUYsRi9GLQ==aus Aufgabe 25.23 die Extrema berechnen.f:=(x,y)->(y^2-x^2)*exp(-(x^2+y^2)/2); Dazu betrachten wir den Gradienten:g:=linalg[grad](f(x[1],x[2]),[x[1],x[2]]);
g1 := g[1];
g2 :=g[2];und definieren uns dieses Vektorfeld als eine Funktiong:=unapply([g1,g2],x);MIt dem oben geschriebenen Programm zum Newton-Verfahren ergibt sichnewtappr(g,vector([1.,0.]),10);Starten wir an einer anderen Stelle, so wird eventuell eine der anderen Nullstellen approximiert. Das Verfahren divergiert, wenn mit einem ungeigneten Startwert begonnen wird. Dies ist nicht ueberraschend, denn die Theorie sichert nur eine lokale Konvergenz in einer Umgebung einer Nullstelle. newtappr(g,vector([0,1.0]),10);
newtappr(g,vector([-1.,1.]),30);
Maple bietet mit dem solve Befehl auch die Moeglichkeit algebraisch Loesungen zu mehrdimensionalen Gleichungen zu suchen. Wir erhalten:solve({g1=0,g2=0},{x[1],x[2]});Beachten Sie die Syntax. Es muessen die Gleichungen und die Variablen als Mengen angeben werden. Mit evalf koennen wir uns die Wurzeln anzeigen lassen:evalf(%); Aufgaben1. Bestimmen Sie die Jakobimatrizen zu folgenden Funktionen
a) Ly1JImZHNiI2JSZJInhHRiU2IyIiIiZGKDYjIiIjJkYoNiMiIiQsJComRi5GKi1JJHNpbkc2JCUqcHJvdGVjdGVkR0koX3N5c2xpYkdGJTYjLChGJyEiIkYrRi1GLkYqRjpGMA== b) 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Loesung a) f:=x-> 3*x[3] / sin(-x[1]+2*x[2]+x[3]);df:=linalg[grad](f(x),[x[1],x[2],x[3]]);b)f:=x-> vector([sin(x[1])+ln(1-x[2]^2),exp(-x[2]^2),cosh(x[1]*x[3])]);df:=linalg[jacobian](f(x),[x[1],x[2],x[3]]);2. Bestimmen Sie mit dem Newton-Verfahren eine Stelle x mit x=g(x) (einen Fixpunkt) der Funktion Ly1JImdHNiI2I0kieEdGJS1JIipHJSpwcm90ZWN0ZWRHNiQ3JCwmLUkkY29zRzYkRipJKF9zeXNsaWJHRiU2IyZGJzYjIiIiRjUtSSRzaW5HRjA2IyZGJzYjIiIjISIiLCZGLkY1RjYhIiMjRjUiIiU= .LoesungWir schreiben das Problem als Nullstellenaufgabe mitf:=x->vector([cos(x[1])-sin(x[2])/4,(cos(x[1])-2*sin(x[2]))/4])-vector([x[1],x[2]]);und erhalten mit dem Newton-Verfahrennewtappr(f,vector([1.0,1.0]),6);