Initialisierung

Die Eingaben dieser Sektion müssen ausgelöst werden!

Laden der Bibliothek:

`>` restart:

`>` with(numdgl);

`>`

Ü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

Euler-Verfahren

Modifiziertes Euler-Verfahren

Verfahren von Heun

Runge-Kutta-Verfahren 4. Ordnung

Vergleich der vier Verfahren

Grenzen der numerischen Verfahren

-----------------------

zurück zur Startseite

`>`

Bedienungserklärung

Die Berechnungen auf diesem Arbeitsblatt können unter MapleV durch Drücken der Enter-Taste zeilenweise oder aber komplett über den Menüpunkt Edit - Execute - Worksheet ausgelöst werden.

Über die Bildlaufleisten kann ein beliebiger Ausschnitt ausgewählt werden.

Die einzelnen Sektionen sind unabhängig voneinander. Deshalb kann über das Inhaltsverzeichnis an jede beliebige Sektion gesprungen werden. Die Befehle innerhalb einer Sektion sind jedoch nicht unbedingt unabhängig. Hier empfiehlt sich das schrittweise Abarbeiten der einzelnen Befehle.

Einige, entsprechend markierte Plots sind als Animationen vorbereitet. Diese können schrittweise ausgelöst werden, wenn man in der Symbolleiste auf klickt. Die Symbolleiste ist allerdings erst sichtbar, wenn vorher auf den Plot geklickt worden ist.

Euler-Verfahren

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),10,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 !

`>`

zurück zum Anfang

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);

`>`

zurück zum Anfang

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);

`>`

zurück zum Anfang

Modifiziertes Euler-Verfahren

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);

`>`

zurück zum Anfang

Verfahren von Heun

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);

`>`

zurück zum Anfang

Runge-Kutta-Verfahren 4. Ordnung

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);

zurück zum Anfang

Vergleich

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);

`>`

zurück zum Anfang

Grenzen der numerischen Verfahren

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.

Selbst bei 1000 Schritten ist im folgenden Fall die Näherung mit Hilfe des Euler-Verfahrens nur für sehr kleine x-Werte zu gebrauchen.

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

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

Hier zeigt sich die Leistungsfähigkeit des Runga-Kutta-Verfahrens . Während die Differentialgleichung vom Euler-Verfahren selbst bei 1000 Schritten nur für sehr kleine x-Werte in brauchbarer Näherung gelöst wurde, reichen beim Runge-Kutta-Verfahren schon 50 Schritte aus.

`>` 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);

`>`

zurück zum Anfang

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

`>`