Euler vs. Runge-Kutta < Matlab < Mathe-Software < Mathe < Vorhilfe
|
| Status: |
(Frage) beantwortet  | | Datum: | 15:24 So 05.05.2013 | | Autor: | Lemma_01 |
| Aufgabe | Es soll numerisch die Lösung des AWPs der Form [mm] \vec{y}'(t)=\vec{f}(t, \vec{y}(t)) [/mm] untersucht werden.
Dazu soll das Euler-Verfahren implementiert. Die Funktion sollte dabei die folgende Gestalt haben:
function [tout, yout] = Euler(fun, [tstart, tend], ya, delta).
Dabei ist fun ein function handle auf die Funktion f, tstart und tend bezeichnen Start- und Endzeitpunkt, ya die Anfangsbedingung bei tstart und delta gibt die Schrittweite an. |
Hallo, weiss jemand wie man hier das Programm dazu schreiben muss?
Wäre sehr dankbar für Unterstützungen!
Vielen Dank voraus!
Grüße
|
|
| |
|
> Es soll numerisch die Lösung des AWPs der Form
> [mm]\vec{y}'(t)=\vec{f}(t, \vec{y}(t))[/mm] untersucht werden.
>
> a) Implementieren Sie dazu das Euler-Verfahren sowie
> Runge-Kutta II. und IV. Ordnung in Matlab. Schreiben Sie
> dazu Funktionen der Gestalt
>
> function [tout, yout] = Euler(fun, [tstart, tend], ya,
> delta),
> function [tout, yout] = rk2(fun, [tstart, tend], ya,
> delta),
> function [tout, yout] = rk4(fun, [tstart, tend], ya,
> delta),
>
> Dabei ist fun ein function handle auf die Funktion f,
> tstart und tend bezeichnen Start- und Endzeitpunkt, ya die
> Anfangsbedingung bei tstart und delta gibt die Schrittweite
> an.
> Hallo, weiss jemand wie man hier das Programm für alle
> drei Verfahren schreiben muss?
Ja
> Ich muss zugeben, bin selber
> mit Numerik nicht so sehr vertraut.
Kam ide Aufgabe aus dem Briefkasten, oder warum musst du Aufgaben lösen, die auf Wissen zurück greifen, mit denen du nicht vertraut bist.
> Wäre sehr dankbar für Unterstützungen!
> Vielen Dank voraus!
> Grüße
Wir helfen und unterstützen gerne! Aber es wird keiner für die Aufgaben machen.
Vielleicht formulierst du erst einmal das Eulerverfahren (wohlmöglich das einfachste) als Algorithmus. Das Umsetzen ist einfach, wenn man erst einmal den Ablauf des Algorithmus mit sich geklärt hat.
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 18:27 So 05.05.2013 | | Autor: | Lemma_01 |
Hi, danke erstmal. Ich wollte jetzt nicht alles vorgelöst bekommen. Ich will ja schon selber versuchen. Ich habe Euler etwas vorgemacht, aber ich denke es ist erstmal nicht ganz und dazu noch bestimmt fehlerhaft
function[tout, yout] = Euler(fun, [tstart, tend], y0, delta)
y(0)=y0; %Anfangsbedingung
;t = tstart; % Zeitintervall;
for n=1:(tend-tstart)./delta
y(n+1) = y(n)+delta.*fun(t,y);
t=t(n+1) = t(n) + n.* delta;
end
Kann das vielleicht jemand überprüfen und mir evt. sagen was machen noch machen müsste?
Grüße
|
|
|
| |
|
Moin,
sieht doch schon gar nicht mal so schlecht aus
> Hi, danke erstmal. Ich wollte jetzt nicht alles vorgelöst
> bekommen. Ich will ja schon selber versuchen. Ich habe
> Euler etwas vorgemacht, aber ich denke es ist erstmal nicht
> ganz und dazu noch bestimmt fehlerhaft
>
> function[tout, yout] = Euler(fun, [tstart, tend], y0,
> [color=blue]delta)[/color]
> y(0)=y0; %Anfangsbedingung
> ;t = tstart; % Zeitintervall;
> for n=1:(tend-tstart)./delta
> [color=blue] y(n+1) = y(n)+delta.*fun(t,y);[/color]
> t=t(n+1) = t(n) + n.* delta;
> [color=blue] end[/color]
Die Schleife ist etwas umständlich. Da machst du es dir zu kompliziert.
Wie wärs mit:
| 1: |
| | 2: | function[tout, yout] = euler(fun, tstart, tend, y0, delta)
| | 3: | tout = (tstart:delta:tend)'; % Zeitleiste
| | 4: | yout = zeros(size(tout,1),size(y0,1)); % Funktionswertspeicher
| | 5: | yout(1,:)=y0; % Anfangsbedingung
| | 6: | pos = 2; % interner Zähler
| | 7: | for t=tstart:delta:tend
| | 8: | y0 = y0+delta.*fun(t,y0); % update
| | 9: | yout(pos,:) = y0; % Funktionswert speichern
| | 10: | pos = pos + 1; % internen Zähler inkrementieren
| | 11: | end
|
Ich habe auch mal die Vektorschreibweise bei den Funktionsargumenten weggelassen, da sonst bei mir ein Fehler auftritt.
>
> Kann das vielleicht jemand überprüfen und mir evt. sagen
> was machen noch machen müsste?
> Grüße
Du kannst du selber Werte eingeben:
| 1: |
| | 2: | f=@(y,t) y.^2/(2*t-1);
| | 3: | [tt,yy]=euler(f,1,15,1,.5);
| | 4: | plot(tt,yy,'.')
|
gruß
wieschoo
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 12:16 Mo 06.05.2013 | | Autor: | Lemma_01 |
Hi, ich hätte gerne ein paar Verständnisfragen, was die Bedeutungen von Notationen angehen.
Wie meinst du das genau mit diesen beiden Zeilen?
1. yout(1,:)=y0;
2. pos = 2;
Grüße, Lemma_01
|
|
|
| |
|
> Hi, ich hätte gerne ein paar Verständnisfragen, was die
> Bedeutungen von Notationen angehen.
Dann ist es wohl eher ein Matlab spefizisches Problem und kein Inhaltliches?
> Wie meinst du das genau mit diesen beiden Zeilen?
>
> 1. yout(1,:)=y0;
"Setze y0 in die erste zeile von yout".
Mittels A(i,j) kann auf das i,j-te Elemente zugegriffen werden. Schreibst man für eine Korrdinate stattdessen ":" so wird die ganze Spalte, bzw. Zeile genommen.
In deinem Fall könnte ja y0 mehrdimensional sein. Somit schiebt sich y0 als Zeilenvektor in die erste Zeile. Bei Skalen ist das egal.
> 2. pos = 2;
Um immer auf den nächsten Eintrag in "yout" durchgängig zu zeigen speichert der Algo einfach die nächste Position ab. In jedem Schleifendurchgang wird pos um eins erhöht, damit man die nächste Zeile beschreiben kann.
Es geht natürlich auch etwas anders. Aber wenn du vorher weiß, wie viele Einträge generiert werden, so ist es wesentlich schneller im vorhinein bereits eine Matrix mit entsprechender Größe anzulegen.
>
> Grüße, Lemma_01
Gruß
wieschoo
|
|
|
| |
|
| Status: |
(Frage) beantwortet | | Datum: | 19:20 Mo 06.05.2013 | | Autor: | Lemma_01 |
Ok soweit verstanden! Wenn das leider alles wäre, was zu verstehen gibt. Naja da ist jetzt noch die Implementierung für Runge-Kutta II. und IV. Ordnung nur mit den Funktionsnamen rk2 und rk4. Hier komme ich jetzt überhaupt nicht weiter. Wie könnte ich rk2 angehen?
Grüße, yahya
|
|
|
| |
|
| Status: |
(Antwort) fertig  | | Datum: | 09:17 Di 07.05.2013 | | Autor: | meili |
Hallo,
> Ok soweit verstanden! Wenn das leider alles wäre, was zu
> verstehen gibt. Naja da ist jetzt noch die Implementierung
> für Runge-Kutta II. und IV. Ordnung nur mit den
> Funktionsnamen rk2 und rk4. Hier komme ich jetzt überhaupt
> nicht weiter. Wie könnte ich rk2 angehen?
Dich mit ![[]](/images/popup.gif) Runge-Kutta-Verfahren beschäftigen.
Für rk2 (von der Ordnung 2) hast Du zwei Verfahren zur Auswahl:
Heun-Verfahren oder
Runge-Kutta-Verfahren der Ordnung 2.
Für rk4 bietet sich das klassische Runge-Kutta-Verfahren an.
Im Vergleich zum Euler-Verfahren musst Du nur die Berechnung von [mm] $y_{n+1}$ [/mm] anpassen.
Für das klassische Runge-Kutta-Verfaren ist das etwas verschachtelt:
[mm] $y_{n+1} [/mm] = [mm] y_n [/mm] + [mm] h*\bruch{1}{6}\left(f\left(t_0+n*h,y_n\right)+2*\left(f\left(t_0+n*h+\bruch{h}{2},y_n+\bruch{h}{2}*f\left(t_0+n*h,y_n\right)\right)+f\left(t_0+n*h+\bruch{h}{2},y_n*f\left(t_0+n*h+\bruch{h}{2},y_n+\bruch{h}{2}*f(t_0+n*h,y_n\right)\right)\right)+f\left(t_0+(n+1)*h,y_n+h*f\left(t_0+n*h+\bruch{h}{2},y_n+\bruch{h}{2}*f\left(t_0+n*h+\bruch{h}{2},y_n+\bruch{h}{2},y_n+\bruch{h}{2}*f\left(t_0+n*h,y_n\right)\right)\right)\right)\right)$
[/mm]
h entspricht bei deinem Program delta.
Ist ziemlich verschachtelt. (und ohne Gewähr)
Vielleicht zerlegt man es besser in mehrere Zwischenschritte wie bei Wikipedia.
> Grüße, yahya
Gruß
meili
|
|
|
| |
|
| Status: |
(Mitteilung) Reaktion unnötig  | | Datum: | 12:06 Di 07.05.2013 | | Autor: | wieschoo |
Oder man tippt es in Maple im 2d Mathemodus und lässt sich automatisch Matlab-Code erzeugen 
|
|
|
|
