Numerische Lösung des mathematischen Pendels mit ...

Numerische Lösung des mathematischen
Pendels mit verschiedenen Verfahren
Geneviève Grunert (171756)
Paul Ebermann (165588)
2. September 2003
Zusammenfassung
Die Differentialgleichung des mathematischen Pendels wird mit
dem expliziten Euler-Verfahren und der impliziten Mittelpunktsregel
gelöst und die Ergebnisse mit der exakten Lösung verglichen.
Es zeigt sich, dass beim expliziten Euler-Verfahren ein ” Energiegewinn“
vorliegt, während die Mittelpunktsregel dieses Problem nicht
hat.

Inhaltsverzeichnis
Aufgabenstellung 2
Physikalische Interpretation der Aufgabenstellung 3
Exakte Lösung 4
Analyse der Differentialgleichung . . . . . . . . . . . . . . . . . . . 4
Näherungslösung für kleine Winkel . . . . . . . . . . . . . . . . . . 5
Allgemeiner Lösungsansatz . . . . . . . . . . . . . . . . . . . . . . 5
Periodendauer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Verfahrensbeschreibung 7
Allgemeines . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Explizites Eulerverfahren . . . . . . . . . . . . . . . . . . . . . . . 7
Implizite Mittelpunktsregel . . . . . . . . . . . . . . . . . . . . . . 7
Automomer Fall . . . . . . . . . . . . . . . . . . . . . . . . . 8
Einzelschritte per Newton . . . . . . . . . . . . . . . . . . . . 8
Einzelschritte nach Banach . . . . . . . . . . . . . . . . . . . 8
Implementation 9
Rahmenwerk . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
Verfahren . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Weitere Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Exakte Lösung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Graphen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Ergebnisse 23
Lösungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Beobachtung der Hamiltonfunktion und Erklärung . . . . . . . . . 29
Quellenangaben 32
1

Aufgabenstellung – Aufgabe 20
Die Gleichungen
˙p = − sinq
˙q = p
beschreiben die Bewegung des mathematischen Pendels (mit der Ortskoordinate
q := x und p := ˙x).
Die Hamiltonfunktion
H(p,q) := 1
2 p2 − cos q
beschreibt die Gesamtenergie des Systems. Integrieren Sie das System mit
• dem expliziten Eulerverfahren und
• der impliziten Mittelpunktsregel
mit konstanter Schrittweite auf einem hinreichend großen Zeitintervall.
Überprüfen Sie die numerischen Werte der Hamiltonfunktion für beide Verfahren
und erklären Sie das beobachtete Verhalten.
Stellen Sie die numerischen Lösungen, die exakte Lösung und die Differenzen
geeignet graphisch dar.
2

Physikalische Interpretation der Aufgabenstellung
Bei unserem mathematischen Pendel ist x = q die aktuelle Auslenkung des
Pendels (als Winkel im Bogenmaß) und p = ˙x die aktuelle Winkelgeschwindigkeit.
l
m
q
Ftang
Fgrav
Abbildung 1: Das mathematische Pendel
Bei einer Fadenlänge l und einer Masse m sowie der Fallbeschleunigung
g ergibt sich bei Auslenkungswinkel q und Winkelgeschwindigkeit p eine
absolute Auslenkung von l · sin q, eine tangentiale Geschwindigkeit von l · p.
Es wirkt eine Gravitations-Kraft von Fgrav = m · g auf das Massestück, die
sich in einen tangentialen sowie einen radialen Bestandteil aufspaltet. Dabei
ist
Frad = F · cos q
= m · g · cos q
(der radiale Anteil wird vom Faden aufgefangen) und
Ftang = −F · sin q
= −m · g · sin q
Wegen der Newtonschen Gleichung F = m·a haben wir also eine tangentiale
Beschleunigung von
atang = −g · sinq
3

Da für die tangentiale Beschleunigung aber auch atang = l · ˙p gilt, ergibt
sich schließlich
˙p = − g
l
· sin q
Die Masse m geht in die Gleichung gar nicht ein. Normiert man nun Zeit-
gerade eins ergibt, so erhält man die Gleichung
und Wegeinheiten so, dass g
l
˙p = − sin q.
Da p aber auch die Ableitung von q ist, erhalten wir durch diese Überlegungen
unser Differentialgleichungssystem
Exakte Lösung
˙p = − sinq
˙q = p.
Analyse der Differentialgleichung
Unsere Differentialgleichung ist eine autonome gewöhnliche Differentialgleichung
der Form
x ′ (t) = f(x(t)).
Bei uns ist hier
f : R 2 → R 2
f(p,q) = (− sin q,p)
Dabei ist f überall stetig differenzierbar mit
f ′ (p,q) =
� �
0 − cos(q)
1 0
Offensichtlich ist �f ′ (p,q)� 1 = �f ′ (p,q)� ∞ = 1, die Funktion f also global
lipschitzstetig mit Lipschitzkonstante 1 (bezüglich dieser Normen).
Das Differentialgleichungssystem erster Ordnung
˙p = − sinq
˙q = p
lässt sich in eine Differentialgleichung zweiter Ordnung umschreiben, wobei
q := x und p := ˙x gesetzt werden (wie in der Interpretation gesehen). Die
Differentialgleichung
¨x = − sinx
hat natürlich die triviale Lösung x = 0. Da diese Lösung nicht besonders
interessant ist, versuchen wir andere zu finden.
4

Näherungslösung für kleine Winkel
Für kleine Winkel q geht die Differentialgleichung durch die Näherung
sin x ≈ x über in die Differentialgleichung
¨x = −x.
Dies ist eine homogene Differentialgleichung mit konstanten Koeffizienten.
Man kann sie also lösen, und die allgemeine reelle Lösung ist
x(t) = c1 · sin t + c2 · cos t,
wobei für die Konstanten gilt: c1 = ˙x(0), c2 = x(0). Natürlich kann man die
Konstanten bestimmen, sobald man irgendwelche Anfangswerte hat. Nur
wenn man die Anfangswerte bei t = 0 gegeben hat, so lassen sie sich besonders
leicht ablesen.
Allgemeiner Lösungsansatz
Die Differentialgleichung lässt sich umschreiben zu:
�
d 1
dt 2 ˙x2 �
− cos x = 0.
Damit ist 1
2 · ˙x2 − cos x = E eine Konstante. Diese gibt die gesamt Energie
des Pendels an. Für die exakte Lösung ist damit die Hamiltonfunktion
H(p,q) := 1
2 p2 − cos q
konstant. Hat man Anfangswerte gegeben, so ist die Konstante durch diese
bestimmt. Eine Lösung der Differentialgleichung löst also in einer Umgebung
J eines Anfangswertes t0, in der die Ableitung nicht Null ist, eine der
Differentialgleichungen
˙x = � 2(E + cos x) oder ˙x = − � 2(E + cos x),
abhängig vom Vorzeichen von ˙x(t0). Beide sind Differentialgleichungen mit
getrennten Variablen. Nehmen wir an, dass die Ableitung positiv ist. Damit
ergibt sich als Lösungsansatz:
� x(t)
x(t0)
dξ
� 2(E + cos ξ) =
Dieses Integral ist nicht geschlossen lösbar. Die exakte Lösung ist also die
Umkehrfunktion zu
t = H(x) = t0 +
� x(t)
x(t0)
5
� t
t0
dt.
dξ
� 2(E + cos ξ) .

Setzt man t0 = 0 und bestimmt E dadurch, daß man man einen Wert q0 für
x(t) einsetzt, an dem die Ableitung verschwindet, so ist E = − cos q0. Dann
erhält man für H die Form
H(x) =
� x(t)
x(0)
dξ
� 2(− cos q0 + cos ξ) .
Die lokale Lösung kann periodisch auf ganz R fortgesetzt werden (siehe [1]).
Die Umkehrfunktion dieses elliptischen Integrals erster Gattung heißt Jacobische
Amplitudenfunktion.
Periodendauer
Als Periode ergibt sich
2 ξ
Setzt man cos ξ = 1 − 2sin 2
elliptischen Integrals
� q0 dξ
T = 4 √ .
0 cos ξ − cos q0
� π
2
T = 4
0
ein, so ergibt sich die Standardform eines
dξ
�
2 q0 1 − sin 2 · sin2 .
ξ
Dies kann man in einer Reihe entwickeln. Denn es gilt:
1
�
2 q0 1 − sin 2 · sin2 =
ξ
∞�
(−1) n ·
n=0
� − 1
2
n
�
2n q0
· sin
2 · sin2n ξ
Diese Reihe kann man gliedweise integrieren, da sie absolut konvergiert.
Dann ergibt sich schließlich
� � �2 1 2 q0
T = 2π · 1 + · sin
2 2 +
� � �
2
1 · 3 4 q0
· sin + · · · .
2 · 4 2
6

Verfahrensbeschreibung
Allgemeines
Wir betrachten hier allgemein die gewöhnliche Differentialgleichung mit Anfangswertproblem
x ′ (t) = f(x(t),t), x(t0) = x0,
sowie den Spezialfall einer autonomen gewöhnlichen Differentialgleichung,
x ′ (t) = f(x(t)), x(t0) = x0.
(In unserem Fall des mathematischen Pendels haben wir es ja mit einer
autonomen Gleichung zu tun.)
Unsere Verfahren bestimmen nun für ein Intervall [t0,tN] eine (endliche)
Folge {xi} N
i=0 von Näherungswerten der Funktionswerte der exakten
Lösung {x(ti)} N
i=0 , wobei wir hier die äquidistanten Stützstellen
, betrachten.
ti = ti−1 + h = t0 + h · i, h = tN −t0
N
Explizites Eulerverfahren
Das explizite Eulerverfahren gehört zur Klasse der k-Schritt-Verfahren, es
ist nämlich das einzige explizite 1-Schritt-Verfahren. Die Verfahrensformel
ist allgemein
xl+1 = xl + h · f(xl,tl)
und im autonomen Fall
Implizite Mittelpunktsregel
xl+1 = xl + h · f(xl). (1)
Die implizite Mittelpunktsregel gehört nicht zur Klasse der in der Vorlesung
behandelten k-Schrittverfahren, ist aber de facto auch ein 1-Schritt-
Verfahren, da für jeden Schritt nur das Ergebnis des vorherigen Schrittes
notwendig ist, keine früheren Schritte.
Die Verfahrensformel ist hier
�
xl + xl+1
xl+1 = xl + h · f ,
2
tl
�
+ tl+1
2
Offensichtlich ist das kein explizites Verfahren, da die Funktion am Mittelpunkt
zwischen dem (schon bekannten) xl und (noch zu bestimmenden)
xl+1 ausgewertet wird (ebenfalls mit Mittelpunkt der Parameter-Werte).
7

Automomer Fall
Da wir es in unserem Fall mit einer autonomen Differentialgleichung zu tun
haben, vereinfachen sich die Formeln etwas. Die implizite Mittelpunktsregel
wird zu
� �
xl + xl+1
xl+1 = xl + h · f
(2)
2
Da wir es mit einem impliziten Verfahren zu tun haben, können wir nicht
die Ergebnisse xl+1 der Einzelschritte nicht einfach hinschreiben, sondern
müssen die Gleichung (2) numerisch lösen. Dafür bieten sich zwei Varianten
an.
Einzelschritte per Newton
Da sich unsere Funktion f leicht differenzieren lässt, könnten wir das Newtonverfahren
verwenden.
Mit g(y) := xl − y + h · f �xl+y �
müssten wir also eine Nullstelle von g
2
finden. Hierbei könnten wir y0 := xl als Startwert nehmen, und verwendeten
dann die normale Newtoniteration
yj+1 = yj + zj, wobei zj Lösung von g ′ (yj) · zj = −f(yj).
Auch eine Variante des Newtonverfahrens, wie ein Sekantenverfahren, wäre
denkbar.
Einzelschritte nach Banach
Eine einfachere Variante ist eine Fixpunkt-Iteration nach Banach: Wir betrachten
die Funktion
k : R n → R n
� �
xl + y
k(y) := xl + h · f
2
Offensichtlich ist jeder Fixpunkt dieser Funktion eine Lösung für (2) und
umgekehrt.
Da unser f lipschitzstetig war, ist dies ebenso für k der Fall. Für h < 2
ist k kontraktierend, und die Iteration
yi+1 := k(yi)
� �
xl + yi
= xl + h · f
2
konvergiert (bei beliebigem Startwert) gegen den einzigen Fixpunkt (also
xl+1).
In unserem Programm wurde die Banach-Iteration verwendet, die zwar
langsamer ist, aber leichter implementierbar (man muss keine Inverse einer
Matrix bestimmen, das Ableiten kann man sich auch sparen).
8

Implementation
Wir haben uns für die Lösung autonomer Differentialgleichungen mit verschiedenen
1-Schritt-Verfahren ein Framework erstellt.
Rahmenwerk
Ein Verfahren muss jeweils das Interface Verfahren implementieren.
101 package semesterarbeit.programme;
102
103 /**
104 * Ein 1-Schritt-Verfahren zur Lösung von Autonomen
105 * Differentialgleichungen.
106 *
107 * @author Paul Ebermann, Geneviève Grunert
108 * @version 1.0
109 */
110 public interface Verfahren
111 {
112
113 /**
114 * Setzt die Schrittweite fest.
115 */
116 public void setSchrittweite(double h);
117
118 /**
119 * Setzt die Funktion der Differentialgleichung fest.
120 */
121 public void setDGL(AutonomeDGL f);
122
123 /**
124 * Berechnet aus einem alten Wert einen neuen nach
125 * der Verfahrensgleichung.
126 * @param x der alte reelle Wertevektor
127 * @return der neue relle Vektor, der sich aus der
128 * Verfahrensvorschrift ergibt.
129 */
130 public double[] verfahrensSchritt(double[] x);
131
132 } // Verfahren
Eine zu lösende Differentialgleichung (ohne Anfangswert) dagegen hat
das Interface AutonomeDGL zu implementieren – das ist ein Subinterface von
RHochNFunktion.
9

201 package semesterarbeit.programme;
202
203 /**
204 * Eine Funktion R^n --> R^n.
205 * In anderer Betrachtungsweise ein Vektorfeld
206 * auf dem R^n.
207 *
208 * @author Geneviève Grunert, Paul Ebermann
209 * @version PPS 1.1.5
210 */
211 public interface RHochNFunktion
212 {
213
214 /**
215 * Berechnet den Wert des Vektorfeldes
216 * an der angegebenen Stelle.
217 *
218 * @param x ein reller Vektor, möglichst im
219 * Definitionsbereich der Funktion
220 * @return der Funktionwert an der Stelle x
221 */
222 public double[] berechne(double[] x);
223
224 }// RHochNFunktion
301 package semesterarbeit.programme;
302
303 /**
304 * Diese Schnittstelle modelliert eine
305 * autonome Differentialgleichung. Dies ist eine
306 * Differentialgleichung der Form
307 *
308 * x’(t) = f(x(t)),
309 *
310 * wobei wir nur differenzierbare Funktionen
311 * f : R^n --> R^n
312 * betrachten. Diese Schnittstelle stellt die Funktion
313 * f (vererbt von {@link RHochNFunktion})
314 * und deren Ableitung Df zur Verfügung.
315 *
316 * Man kann eine solche Differentialgleichung z.B. als
317 * differenzierbares Vektorfeld auffassen, die Lösungen
318 * sind dann Flüsse des Vektorfeldes.
319 *
10

320 * @author Paul Ebermann, Geneviève Grunert
321 * @version PPS 1.1.5
322 */
323 interface AutonomeDGL extends RHochNFunktion
324 {
325
326 /**
327 * Die ableitung()-Methode stellt
328 * das Differential des Vektorfeldes zur Verfügung.
329 *
330 * (Dies ist hilfreich, um etwa das Newton-Verfahren
331 * anwenden zu können ...)
332 */
333 public double[][] ableitung(double[] x);
334 }
335
Außerdem kann man noch verschiedene Ausgabeeinheiten benutzen - um
etwa daraus eine Animation zu erstellen oder eine Grafik. Wir nutzen das,
um einmal die Auslenkung und einmal die Werte der Hamilton-Funktion
auszugeben.
401 package semesterarbeit.programme;
402
403 /**
404 * Ausgabe - Schnittstelle, welche von
405 * {@link Verfahrensanwender#berechneMit} verwendet wird,
406 * um die Ergebnisse eines Verfahrens auszugeben.
407 *
408 * Eine Implementation dieser Schnittstelle bekommt
409 * jeden Zwischenwert durch Aufruf der output-Methode
410 * gemeldet. Was sie damit anfängt, ist Privatsache ...
411 */
412 public interface Ausgabe
413 {
414
415 /**
416 * Gibt einen Datensatz aus.
417 *
418 * @param t der Zeitpunkt
419 * @param xVonT der Funktionswert zu diesem Zeitpunkt.
420 */
421 public void output(double t, double[] xVonT);
422
11

423 /**
424 * Beendet die Ausgabe.
425 */
426 public void close();
427
428 }// Ausgabe
Den Kern unseres Systems bildet die Klasse Verfahrensanwender.
Sie löst eine Anfangswertaufgabe (bestehend aus Problem, Anfangswert,
Schrittweite und Intervall) mit einem gegebenen Verfahren und gibt Ergebnisse
an eine Ausgabeeinheit. Alle diese Parameter können unabhängig
voneinander gewählt werden.
501 package semesterarbeit.programme;
502
503 /**
504 * Verfahrensanwender - wendet Verfahren auf ein Problem an
505 * und sorgt für eine Ausgabe der Ergebnisse.
506 *
507 * Im Konstruktor wird Problem, Intervall
508 * und Schrittweite angegeben, danach kann mehrfach mit
509 * verschiedenen Verfahren und Ausgabeeinheiten eine Lösung
510 * berechnet werden.
511 *
512 * @author Paul Ebermann, Geneviève Grunert
513 * @version 1.0
514 */
515 public class Verfahrensanwender {
516
517 /**
518 * Die Differentialgleichung
519 */
520 private final AutonomeDGL dgl;
521 /**
522 * Der Anfangswert
523 */
524 private final double[] anfang;
525 /**
526 * Das Problem soll im Intervall [0, zeit] gelöst
527 * werden.
528 */
529 private final double zeit;
530 /**
531 * Die Schrittweite.
12

532 */
533 private final double h;
534
535 /**
536 * Dieser Konstruktor erstellt einen Verfahrensanwender
537 * für ein gegebenes Anfangswertproblem, Intervall und
538 * Schrittweite.
539 */
540 public Verfahrensanwender(AutonomeDGL dgl,
541 double[] anfangswert,
542 double zeitdauer,
543 double schrittweite)
544 {
545 this. dgl = dgl;
546 this.anfang = anfangswert;
547 this.zeit = zeitdauer;
548 this.h = schrittweite;
549 }
550
551 /**
552 * Berechnet eine Lösung (bzw. eine Approximation
553 * an eine solche) mittels des gewählten Verfahrens
554 * und gibt die Lösung an die gewählte Ausgabeeinheit
555 * aus.
556 *
557 * Es wird dem Verfahren mitgeteilt, um welche
558 * Differentialgleichung es sich handelt, sowie welche
559 * Schrittweite verwendet werden soll.
560 *
561 * Dann wird wiederholt die verfahrensSchritt()-Methode
562 * des Verfahrens ausgeführt, als Parameter jeweils
563 * das Ergebnis des vorherigen Schrittes (am Anfang
564 * der Anfangswert).
565 *
566 * Nach jedem Verfahrens-Schritt (und vor dem ersten)
567 * wird die aktuelle Zeit sowie das Ergebniss des
568 * Schrittes an die output()-Methode der
569 * Ausgabe-Einheit übergeben.
570 * Am Ende wird noch deren close()-Methode aufgerufen.
571 */
572 void berechneMit(Verfahren verf, Ausgabe ausgabe)
573 {
574 verf.setDGL(dgl);
575 verf.setSchrittweite(h);
13

576 double[] werte = anfang;
577
578 // Anfangswert ausgeben
579 ausgabe.output(0, werte);
580
581 for (double t = 0; t < zeit; t += h)
582 {
583 // Einen Schritt ausführen ...
584 werte = verf.verfahrensSchritt(werte);
585
586 // Ergebnis ausgeben
587 ausgabe.output(t+h, werte);
588 }
589
590 // Abschluss der Ausgabe
591 ausgabe.close();
592 }
593
594 }
Durch diese Konstruktion ist unser Rahmenwerk flexibel einsetzbar. Man
kann sowohl die Differentialgleichung als auch die Verfahren austauschen,
gleiches gilt für die Ausgabeeinheiten.
Verfahren
Die Klasse Eulerverfahren implementiert das explizite Eulerverfahren.
601 package semesterarbeit.programme;
602
603 /**
604 * Implementation des expliziten Eulerverfahrens.
605 *
606 * Die Methoden sind im Interface {@link Verfahren}
607 * spezifiziert (und ansonsten ist auch der Name
608 * recht aussagekräftig).
609 *
610 * @author Geneviève Grunert, Paul Ebermann
611 * @version 1.0
612 */
613 public class Eulerverfahren implements Verfahren
614 {
615
616 private double h;
617 private AutonomeDGL f;
14

618
619 public void setSchrittweite(double h)
620 {
621 this.h = h;
622 }
623
624 public void setDGL(AutonomeDGL dgl)
625 {
626 this.f = dgl;
627 }
628
629 /**
630 * Verfahrensvorschrift:
631 *
632 * x_(l+1) = x_l + h * f(x_l)
633 */
634 public double [] verfahrensSchritt(double[] a)
635 {
636 // f(x_l)
637 double[] ergF = f.berechne(a);
638
639 // x_l + h * f(x_l)
640 return VektorTools.plus(a,
641 VektorTools.mal(h, ergF));
642 }
643
644 }
Die Klasse MittelpunktBanach implementiert die Mittelpunktsregel über
eine Banach-Fixpunkt-Iteration.
701 package semesterarbeit.programme;
702
703 /**
704 * Implizite Mittelpunktsregel mittels
705 * Banach-Iteration.
706 *
707 * Die Methoden sind in {@link Verfahren} beschrieben.
708 *
709 * @author Geneviève Grunert, Paul Ebermann
710 */
711 public class MittelpunktBanach implements Verfahren
712 {
713
714 private double h;
15

715 private AutonomeDGL dgl;
716 private BanachIteration banach;
717
718 public void setSchrittweite(double d)
719 {
720 this.h = d;
721 this.banach = new BanachIteration(0.000001*d);
722 }
723
724 public void setDGL(AutonomeDGL autonomeDGL)
725 {
726 this.dgl = autonomeDGL;
727 }
728
729 public double[] verfahrensSchritt(final double[] alt)
730 {
731 // Funktion erstellen, deren Fixpunkt
732 // zu finden ist.
733 RHochNFunktion k = new RHochNFunktion() {
734 public double[] berechne(double[] y)
735 {
736 // fMitte = f( (alt+y)/2 )
737 double[] fMitte =
738 dgl.berechne(VektorTools.mittelwert
739 (alt, y));
740
741 // k(y) := alt + h * fMitte
742 return
743 VektorTools.plus
744 ( alt,
745 VektorTools.mal(h, fMitte)
746 );
747 }
748 };
749 // Banachverfahren auf k ansetzen
750 return banach.findeFixpunkt(k, alt);
751 }
752
753 }
Die Banach-Fixpunkt-Iteration wird dabei durch die Klasse
BanachIteration übernommen.
801 package semesterarbeit.programme;
802
16

803 /**
804 * Das Fixpunktverfahren nach Banach.
805 *
806 * @author Geneviève Grunert, Paul Ebermann
807 */
808 public class BanachIteration
809 {
810
811 final double epsilon;
812
813 /**
814 * @param epsilon Eine Iteration wird abgebrochen,
815 * sobald der Fixpunkt (bezüglich oo-Norm) besser
816 * als epsilon approximiert ist (für diese
817 * Abschätzung wird die Kontraktivität der
818 * Abbildung benötigt).
819 */
820 public BanachIteration(double epsilon)
821 {
822 this.epsilon = epsilon;
823 }
824
825
826 /**
827 * Ermittelt einen Fixpunkt durch Banach-Iteration.
828 * Damit das konvergiert, sollte die Abbildung
829 * kontraktierend (d.h. Lipschitzkonstante < 1)
830 * sein.
831 *
832 * @param f die Funktion, deren Fixpunkt gefunden
833 * werden soll
834 * @param startwert der Startwert der Iteration
835 * @return eine Approximation des Fixpunktes
836 */
837 public double[] findeFixpunkt(RHochNFunktion f,
838 double[] startwert)
839 {
840 double[] alt;
841 double[] neu = startwert;
842 do
843 {
844 alt = neu;
845 neu = f.berechne(alt);
846 } while(abstandGrößer(alt, neu));
17

847 return neu;
848 }
849
850 /**
851 * Testet, ob der Abstand zweier reeller Vektoren
852 * bezüglich der oo-Norm größer als epsilon ist.
853 * @param a ein reeller Vektor
854 * @param b ein weiterer reeller Vektor
855 * @return wahr oder falsch
856 */
857 private boolean abstandGrößer(double[] a, double[] b)
858 {
859 for (int i = 0; i < a.length; i++)
860 {
861 if (Math.abs(a[i] - b[i]) > epsilon)
862 {
863 return true;
864 }
865 }
866 return false;
867 }
868
869 }
Weitere Klassen
Wir brauchen natürlich noch unsere Differentialgleichung, damit das Programm
weiß, was gelöst werden soll:
901 package semesterarbeit.programme;
902
903 /**
904 * Die Differentialgleichung eines mathematischen
905 * (Faden-)Pendels im einfachsten Fall.
906 *
907 * p’ = - sin q
908 * q’ = p
909 *
910 * @author Geneviève Grunert, Paul Ebermann
911 */
912 public class PendelGleichung
913 implements AutonomeDGL {
914
915 /**
18

916 * Die Funktion der Pendel-Gleichung.
917 *
918 * f(p, q) = ( - sin(q), p)
919 *
920 */
921 public double[] berechne(double[] x)
922 {
923 return new double[]{ - Math.sin(x[1]), x[0] };
924 }
925
926
927 /**
928 * Die Ableitung der Pendel-Gleichung.
929 *
930 * Das ist die Matrix
931 *
932 * f’(p,q) = ( 0 -cos(q) )
933 * ( 1 0 ).
934 */
935 public double[][] ableitung(double[] x)
936 {
937 return new double[][]
938 {
939 { 0, - Math.cos(x[1]) },
940 { 1, 0},
941 };
942 }
943
944
945 } // PendelGleichung
Weiterhin gibt es 2 Ausgabe-Klassen, um Zeit-Auslenkung bzw. Zeit-
Hamilton in Dateien zu schreiben und eine Beispiel-Klasse, um alles zusammenzuführen
(es wird ein spezielles Anfangswertproblem und Intervall
gewählt, und mit verschiedenen Schrittweiten und Verfahren gelöst). Diese
Klassen nehmen wir jetzt nicht im Quelltext auf, da die Implementation
kanonisch ist (und nichts mit dem eigentlichen Problem zu tun hat).
Exakte Lösung
Die exakte Lösung sowie die Differenzen der exakten Lösung zu unseren
Näherungslösungen haben wir von Mathematica berechnen lassen. Hier die
Eingabedaten:
1 (***********************************************
19

2 ( Mathematica-Eingabedatei, um die exakte
3 ( Lösung der Pendelgleichung sowie die
4 ( Differenzen der exakten Lösung zu unseren
5 ( Näherungslösungen zu bestimmen.
6 (
7 ( Anwendung per
8 (
9 ( math < mathinput.m
10 (
11 ***********************************************)
12
13 (*********** Anfangswert *********************)
14
15 phi0 := 0.3
16
17 (************ die exakte Lösung ****************)
18
19 kappa := 1/Sin[phi0/2]
20 f[t_] := Re[2 JacobiAmplitude[t/kappa +
21 EllipticF[phi0/2, kappa^2],
22 kappa^2]]
23 (*** Re[] ist notwendig, weil sonst immer *)
24 (*** ein (kleiner) imaginärer Anteil entsteht, *)
25 (*** womit unser Plot-Programm nicht klarkommt. *)
26
27 (*** Das Intervall (mit Schrittweite 0.5) *)
28
29 r := Range[0, 60, 0.5]
30
31 (********** Ausgabe der exakten Lösungen **********)
32
33 (** Verzeichnis wechseln ****)
34
35 SetDirectory["plots"];
36
37 g[t_] := {t, f[t]}
38 SetAttributes[g, Listable]
39 Export["exakt2.plot", N[g[r]], "List"]
40
41 (*** Jetzt noch der Hamilton-Operator davon - *)
42 (*** der ist natürlich konstant. *)
43
44 h[t_] := {t, - Cos[phi0] }
45 SetAttributes[h, Listable]
20

46 Export["hamExakt.plot", N[h[r]], "List"]
47
48 (*** Jetzt wollen wir noch die exakte Lösung *)
49 (*** mit den Näherungen vergleichen. *)
50
51 (** Unsere Differenz-Funktion *)
52 d[t_, x_] := { t, x - f[t] }
53
54 dateien := FileNames[{"euler*.plot", "banach*.plot"}]
55
56 (*** Jetzt eine Schleife über alle Dateien ... *)
57 Do[
58
59 name = dateien[[i]];
60 liste = Import[name, "List"];
61
62 (* Das ist jetzt eine Liste mit abwechselnd
63 Zeit und Näherung dazu *)
64
65 liste = Partition[liste, 2];
66
67 (* Jetzt haben wir eine Liste aus
68 zweielementigen Listen, jeweils Zeit und
69 Näherung *)
70
71 (*** Ersetze die Einzel-Listen (Tiefe: 1)
72 durch eine Anwendung von d. *)
73 liste = Apply[d, liste, {1}];
74
75 (* Jetzt haben wir eine Liste aus
76 zweielementigen Listen, jeweils Zeit
77 und Differenz *)
78
79 (* Beim Dateinamen wird einfach vorne
80 ein D angehängt. **)
81
82 Export["D" name, liste, "List"]
83
84 (* Das ganze machen wir für alle i
85 von 1 bis Anzahl der Dateien. *)
86
87 , {i, Length[dateien] }]
88
89 (* Wieder zurückwechseln *)
21

90
91 ResetDirectory[];
92
93 (*
94 *** Local Variables:
95 *** mode: fundamental
96 *** End:
97 *)
Graphen
Die Ausgabe der Graphen (sowohl der exakten Lösung als auch der numerischen)
erfolgte jeweils als Wertetabelle und wurde in dieses Dokument
mittels des PSTricks-\fileplot-Befehls eingebunden.
Das komplette Dokument kann mit dem createPS-Skript aus den Quelltexten
erstellt werden (zumindest auf den Computern im Mathe-Pool).
22

Ergebnisse
Lösungen
In den folgenden Bildern ist jeweils ein Plot der p-Werte der exakten Lösung
(dünn gepunktet), der Lösung des impliziten Mittelpunktverfahrens (durchgezogen)
und der Lösung des expliziten Eulerverfahrens 1 (gestrichelt) zu
sehen, jeweils mit Startwert q(0) = 0.3, p(0) = 0 im Intervall [0,60] (auf der
t-Achse sind also die Einteilungen mit 10 zu multiplizieren).
1
0
−1
−2
1 2 3 4 5 6
Abbildung 2: Lösungen mit h = 0.1
Die Schrittweiten variieren zwischen den Bildern, wir fangen an mit
Schrittweite h = 0.1 (Abbildung 2). Man erkennt, dass die Lösung nach
Mittelpunktsregel auch auf langen Intervallen gut mit der exakten Lösung
übereinstimmt, während das explizite Eulerverfahren sowohl eine wachsende
Amplitude als auch eine wachsende Periodendauer aufweist.
Abbildung 3 zeigt die Differenzen 〈Verfahrenslösung〉−〈exakte Lösung〉.
Betrachten wir die gleichen Verfahren bei h = 0.05 (Abbildung 4).
Bei der Mittelpunktsregel ist kein Unterschied zu bemerken, während das
explizite Eulerverfahren sich deutlich verbessert. Dies erkennt man auch gut,
wenn man sich die Differenzen zur exakten Lösung ansieht (Abbildung 5).
Betrachten wir das Eulerverfahren mit noch einmal kleinerer Schrittweite
h = 0.01 (Abbildung 6, Differenz in Abbildung 7), dann erkennt man, dass
1 Im folgenden wird nur noch ” Mittelpunktsregel“ und ” Eulerverfahren“ verwendet, das
Wort ” implizit“ bzw. ” explizit“ sei hier implizit enthalten.
23

1
0
−1
−2
1
0
−1
−2
1 2 3 4 5 6
Abbildung 3: Differenzen bei h = 0.1
1 2 3 4 5 6
Abbildung 4: Lösungen bei h = 0.05
24

1
0
−1
−2
1
0
−1
−2
1 2 3 4 5 6
Abbildung 5: Differenzen bei h = 0.05
1 2 3 4 5 6
Abbildung 6: Euler bei h = 0.01
25

1
0
−1
−2
1 2 3 4 5 6
Abbildung 7: Euler-Differenz bei h = 0.01
es um einiges besser wird.
Vergrößern wir dagegen die Schrittweite auf h = 0.2, so gerät Euler völlig
außer Kontrolle (es gibt einen ” Überschlag“), während unsere Mittelpunktsregel
sich friedlich verhält (Abbildung 8).
Bei noch größeren Schrittweiten (Abbildung 10, durchgezogen: h = 0.5,
gestrichelt: h = 0.8) merkt man allerdings auch der Mittelpunktsregel an,
dass sie nur Näherungen berechnet - die Lösungen geraten etwas aus dem
Takt, die Periodendauer vergrößert sich. Die Differenzen (Abbildung 11)
übersteigen in der Amplitude die der Original-Funktion. Dagegen bleibt die
Amplitude der Lösungen im richtigen Bereich.
26

1
0
−1
−2
1
0
−1
−2
1 2 3 4 5 6
Abbildung 8: Lösungen bei h = 0.2
1 2 3 4 5 6
Abbildung 9: Differenzen bei h = 0.2
27

1
0
−1
−2
1
0
−1
−2
1 2 3 4 5 6
Abbildung 10: Mittelpunktsregel bei h = 0.5 und 0.8
1 2 3 4 5 6
Abbildung 11: Differenzen der Mittelpunktsregel bei h = 0.5 und 0.8
28

Beobachtung der Hamiltonfunktion und Erklärung
Schauen wir uns nun das Verhalten des Hamilton-Operators für die Lösungen
an. Da dieser (physikalisch betrachtet) gerade die Energie des Systems
ausdrückt, muss er (wegen dem Energieerhaltungssatz) konstant bleiben.
Dies wurde ja auch beim Herleiten der exakten Lösung aus der Differentialgleichung
hergeleitet.
1
0
−1
−2
1 2 3 4 5 6
Abbildung 12: Hamilton-Funktion bei h = 0.1
Betrachten wir nun unseren ” Standardfall“ mit h = 0.1, und betrachten
dafür den Hamilton-Operator, so können wir folgendes beobachten:
Die recht gute Näherung durch die implizite Mittelpunktsregel gibt den
physikalischen Sachverhalt richtig wieder. Setzt man die Näherung in die
Hamiltonfunktion ein, so erhält man auch hier eine konstante Funktion.
Aber die Näherung durch das explizite Eulerverfahren ist sehr schlecht. Das
erkennt man schon, wenn man die Energie betrachtet. Denn setzt man die
Lösung des expliziten Eulerverfahrens in die Hamiltonfunktion ein, so gewinnt
man im Laufe der Zeit Energie, was physikalisch unmöglich ist. Der
Energiegewinn resultiert daraus, dass beim expliziten Eulerverfahren die
Amplitude des Pendels vergrößert wird.
Bei kleineren Schrittweiten verringert sich dieser Effekt, bei größeren
verstärkt er sich, wie in den weiteren Abbildungen zu sehen ist. Das Mittelpunktsverfahren
dagegen erhält bei jeder Schrittweite die richtige Energie.
29

1
0
−1
−2
1
0
−1
−2
1 2 3 4 5 6
Abbildung 13: Hamilton-Funktion bei h = 0.05
1 2 3 4 5 6
Abbildung 14: Hamilton-Funktion für Euler bei h = 0.01
30

1
0
−1
−2
1
0
−1
−2
1 2 3 4 5 6
Abbildung 15: Hamilton-Funktion bei h = 0.2
1 2 3 4 5 6
Abbildung 16: Hamilton-Funktion für Mittelpunktsverfahren bei h = 0.5
und h = 0.8
31

Quellenangaben
[1] Konrad Königsberger:
Analysis 1, Springer-Lehrbuch,
Springer-Verlag, 3. Auflage 1995. (Seiten 230, 295ff )
[2] Physikalisches Institut der Universität Basel:
Versuchsbeschreibung für das Anfängerpraktikum
http://www.unibas.ch/phys-ap/vers08/anl08.htm
[3] Hendrik van Hees:
de.sci.physik-FAQ – Klassische Mechanik
http://theory.gsi.de/~vanhees/faq-pdf/mech.pdf (Seiten 59ff )
[4] Knut Petras:
Vorlesungsskript – Numerik gewöhnlicher Differentialgleichungen
http://www-public.tu-bs.de:8080/~petras/lva/dgl00/vorl.ps
(Seite 33)
32