Überblick

Da oft die explizite Lösung einer Differentialgleichung nicht möglich ist, bleibt man darauf angewiesen, numerische Näherungen zu berechnen. Im folgenden werden daher vier klassische Verfahren vorgestellt, die alle auf explizite Differentialgleichungen erster Ordnung anwendbar sind.

Alle vier Verfahren schätzen - mehr oder weniger- die Ableitung durch den Differenzenquotienten ab. Es gilt dann näherungsweise:

Dabei ist der Fehler derAbschätzung in erster Näherung eine infinitesimale Größe der Ordnung s, d.h. proportional zur Schrittweite s.

Bein Verfahren nach Heun und beim modifizierten Euler-Verfahren liegt der Fehler bei zweiter Ordnung , beim Runge-Kutta-Verfahren schließlich bei vierter Ordnung.

Zu Beginn werden zunächst die vier Verfahren erläutert und schließlich im letzten Teil miteinander verglichen.

Inhaltsverzeichnis

Beim Euler-Verfahren handelt es sich um eine Abschätzung erster Ordnung.

----> ---->

Ausgehend von der Anfangsbedingung wird der nächste Funktionswert nun berechnet mit Hilfe der Steigung an der Stelle . Dabei ist der Fehler derAbschätzung in erster Näherung eine infinitesimale Größe der Ordnung s, d.h. proportional zur Schrittweite s.

Geometrische Interpretation

Die Prozedur Euler_graf stellt das Euler-Verfahren schrittweise geometrisch dar. Dazu zeichnet sie ein Geradenstück mit der Steigung an der Stelle . Der nächste Funktionswert ergibt sich aus dem Schnittpunkt dieser Geraden und der Senkrechten .

> DGL1:=D(y)(x)=5-0.05*y(x):

> Euler_graf(DGL1,y(5)=20,y(x),8,0..100);

A nimation !

Die schwarze Kurve ist hier die von Maple berechnete explizite Lösung (wenn eine solche existiert), oder eine numerische Näherung höheren Grades!

> DGL2:=D(n)(t)=2*(n(t)/1200)*(1200-n(t)):

> Euler_graf(DGL2,n(1)=10,n(t),15,0..15);

A nimation !

Durch Angabe eines zusätzlichen Arguments an die Prozedur Euler_graf lässt sich der sichtbare y-Bereich einschränken. Somit sind Ausschnittsvergrößerungen zu erreichen

> DGL3:=D(y)(x)=1/(x+y(x)):

> Euler_graf(DGL3,y(-4)=1,y(x),5,-4..4,-1.5..1);

A nimation !

>

Animation zur Bedeutung der Schrittweite s

Die Prozedur Euler_ani demonstriert in einer Animation die Bedeutung der Schrittweite s. Dabei verringert sich s, wenn die Schrittanzahl n den angegebenen Wertebereich durchläuft.

> DGL2:=D(n)(t)=2*(n(t)/1200)*(1200-n(t)):

> Euler_ani(DGL2,n(0)=1,n(t),11..100,0..15,0..1200);

A nimation !

> DGL3:=D(y)(x)=1/(x+y(x)):

> Euler_ani(DGL3,y(-6)=3,y(x),1..15,-6..6);

A nimation !

> DGL4:=D(y)(x)=1-2*x*y(x):

> Euler_ani(DGL4,y(0)=1,y(x),10..40,0..2);

A nimation !

>

Beispiele

Im folgenden sollen einige Beispiele die Anwendungsmöglichkeiten aufzeigen. Die Prozedur Euler_verf entspricht Euler_graf , verzichtet aber auf die geometrische Konstruktion.

> DGL1:=D(y)(x)=5-0.05*y(x):

> Euler_verf(DGL1,y(-10)=140,y(x),10,-10..100,80..140);

> DGL2:=D(n)(t)=2*(n(t)/1200)*(1200-n(t)):

> Euler_verf(DGL2,n(0)=1300,n(t),40,0..6,1100..1300);

>

Beim modifizierten Eulerverfahren verwendet man zur Berechnung des nächsten Funktionswertes anstelle der Steigung im Punkt die des Zwischenpunktes an der Stelle . Dieses Verfahren ist genauer als das klassische Euler-Verfahren , da es die Ableitung in der Mitte des Intervalles verwendet, die oft eine bessere Näherung darstellt. Der Fehler ist von zweiter Ordnung, d.h. das Verfahren liefert schon bei kleineren Schrittzahlen bessere Werte als das klassische Euler-Verfahren.
Die Prozedur Euler_mod zeichnet die genäherte Lösung zusammen mit der 'expliziten' in ein Schaubild.

> DGL1:=D(y)(x)=5-0.05*y(x):

> Euler_mod(DGL1,y(-10)=0,y(x),10,-10..100);

> DGL2:=D(n)(t)=2*(n(t)/1200)*(1200-n(t)):

> Euler_mod(DGL2,n(0)=1,n(t),20,0..15,0..1200);

> DGL4:=D(y)(x)=1-2*x*y(x):

> Euler_mod(DGL4,y(0)=1,y(x),10,0..2);

>

Beim Verfahren nach Heun wird mit dem Euler-Verfahren ein geschätzter Wert ermittelt, ein sogenanter Prädiktor. Im Korrekturschritt mittelt man die Steigungswerte des alten Ortes und die des Prädiktorschrittes. Der neue Funktionswert wird über diesen Mittelwert der Steigungen berechnet. Der Fehler ist wie beim modifizierten Eulerverfahren ebenfalls von zweiter Ordnung.

Die Prozedur Heun zeichnet die genäherte Lösung zusammen mit der 'expliziten' in ein Schaubild.

> DGL1:=D(y)(x)=5-0.05*y(x):

> Heun(DGL1,y(0)=140,y(x),10,-10..100,80..140);

> DGL2:=D(n)(t)=2*(n(t)/1200)*(1200-n(t)):

> Heun(DGL2,n(0)=1,n(t),50,0..15,0..1200);

> DGL3:=D(y)(x)=1/(x+y(x)):

> Heun(DGL3,y(-4)=1,y(x),8,-4..6);

>

Das Prinzip des Runge-Kutta -Verfahrens beruht auf der Berechnung einer "repräsentativen" Steigung im Intervall . Dazu wird die Steigung an verschiedenen extrapolierten Punkten (beim Verfahren 4.Ordnung an vier Punkten) gemittelt. Der dabei entstehende Näherungsfehler ist von vierter Ordnung. Das klassische Runge-Kutta-Verfahren 4. Ordnung stellt den besten Kompromiss zwischen Programmieraufwand, Rechenzeit und Genauigkeit dar.

Die Prozedur Runge-Kutta zeichnet die genäherte Lösung zusammen mit der 'expliziten' in ein Schaubild.

> DGL1:=D(y)(x)=5-0.05*y(x):

> Runge_Kutta(DGL1,y(-10)=0,y(x),15,-10..100,0..130);

> DGL2:=D(n)(t)=2*(n(t)/1200)*(1200-n(t)):

> Runge_Kutta(DGL2,n(0)=1,n(t),25,0..15,0..1200);

Die Prozedur Vergleich vergleicht die vier hier vorgestellten Verfahren, indem sie die genäherten Lösungskurven zusammen mit der "expliziten Lösung" in einem Schgaublid darstellt.
Dabei wird die nach dem Euler-Verfahren genäherte Kurve in rot ,
die des modifizierten Euler-Verfahrens in blau ,
die zum Heun-Verfahren gehörige in grün ,
und die nach dem Runge-Kutta-Verfahren in magenta dargestellt.

Die schwarze Kurve stellt die "explizite Lösung" dar, sofern Maple diese berechnen konnte.

> DGL2:=D(n)(t)=2*(n(t)/1200)*(1200-n(t)):

> Vergleich(DGL2,n(0)=1,n(t),15,0..15);

> DGL1:=D(y)(x)=5-0.05*y(x):

> Vergleich(DGL1,y(0)=0,y(x),5,0..80);

> DGL3:=D(y)(x)=1/(x+y(x)):

> Vergleich(DGL3,y(-4)=1,y(x),5,-4..4,-4..1);

>

Nicht immer sind die numerischen Methoden ausreichend exakt. Selbst bei vielen Schritten ist die Näherung oft nur für x-Werte nahe der Anfangsbedingung zu gebrauchen. Die Abweichung hin zu größeren x-Werten ist signifikant. Dies liegt daran, dass der globale Fehler bei jedem Schritt mit einem Faktor multipliziert wird, der zum einen von der Schrittweite s und zum anderen aber über von x abhängt. Dies gilt für alle Verfahren, die mit einer konstanten Schrittweite arbeiten.

> DGL7:=D(y)(x)=y(x)-3*exp(-2*x):

> Euler_verf(DGL7,y(0)=1,y(x),1000,0..6,-0.5..1);

> DGL7:=D(y)(x)=y(x)-3*exp(-2*x):

> Runge_Kutta(DGL7,y(0)=1,y(x),100,0..6,-0.5..1);

Allerdings ist auch beim Runge-Kutta-Verfahren Vorsicht geboten, was die Glaubwürdigkeit der genäherten Lösung betrifft. Betrachtet man nämlich die Lösung der obigen Differentialgleichung in einem größeren Intervall, so fällt auf, dass die Abschätzung für x>6 nicht mehr gültig sein kann. Die zunächst stabile Lösung wird instabil.

> Runge_Kutta(DGL7,y(0)=1,y(x),100,0..12,-0.5..1);

Noch deutlicher wird dies im folgenden Beispiel. Eine zunächst stabile Lösung wird plötzlich instabil.

> DGL8:=D(y)(x)=-Pi*x*y(x);

> Euler_verf(DGL8,y(0)=1,y(x),120,0..16,-2..2);

Selbst mit Runge-Kutta bleibt die Stelle gleich, an der die Lösung instabil wird.

> DGL8:=D(y)(x)=-Pi*x*y(x);

> Runge_Kutta(DGL8,y(0)=1,y(x),120,0..16,-2..2);

>

Literatur

H.J. Brochhagen
Differentialgleichungen in der Schulmathematik
in: Der Mathematikunterricht , Jg 41, Heft 2 März 1995

Coombes, Hunt, Lipsman, Osborn, Stuck
Differential Equations with Maple
John Wiley & Sons , New York 1996

H. Stöcker
Taschenbuch mathematischer Formeln und Verfahren
Verlag Harri Deutsch, Frankfurt a.M. 1995