www.vorhilfe.de
- Förderverein -
Der Förderverein.

Gemeinnütziger Verein zur Finanzierung des Projekts Vorhilfe.de.
Hallo Gast!einloggen | registrieren ]
Startseite · Mitglieder · Impressum
Forenbaum
^ Forenbaum
Status VH e.V.
  Status Vereinsforum

Gezeigt werden alle Foren bis zur Tiefe 2

Navigation
 Startseite...
 Suchen
 Impressum
Das Projekt
Server und Internetanbindung werden durch Spenden finanziert.
Organisiert wird das Projekt von unserem Koordinatorenteam.
Hunderte Mitglieder helfen ehrenamtlich in unseren moderierten Foren.
Anbieter der Seite ist der gemeinnützige Verein "Vorhilfe.de e.V.".
Partnerseiten
Weitere Fächer:

Open Source FunktionenplotterFunkyPlot: Kostenloser und quelloffener Funktionenplotter für Linux und andere Betriebssysteme
Forum "Matlab" - Euler vs. Runge-Kutta
Euler vs. Runge-Kutta < Matlab < Mathe-Software < Mathe < Vorhilfe
Ansicht: [ geschachtelt ] | ^ Forum "Matlab"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien

Euler vs. Runge-Kutta: AWP
Status: (Frage) beantwortet Status 
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

        
Bezug
Euler vs. Runge-Kutta: Antwort
Status: (Antwort) fertig Status 
Datum: 18:02 So 05.05.2013
Autor: wieschoo


> 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.
 

Bezug
                
Bezug
Euler vs. Runge-Kutta: Frage (beantwortet)
Status: (Frage) beantwortet Status 
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

Bezug
                        
Bezug
Euler vs. Runge-Kutta: Antwort
Status: (Antwort) fertig Status 
Datum: 11:24 Mo 06.05.2013
Autor: wieschoo

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



Bezug
                                
Bezug
Euler vs. Runge-Kutta: Frage (beantwortet)
Status: (Frage) beantwortet Status 
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

Bezug
                                        
Bezug
Euler vs. Runge-Kutta: Antwort
Status: (Antwort) fertig Status 
Datum: 18:58 Mo 06.05.2013
Autor: wieschoo


> 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

Bezug
                                                
Bezug
Euler vs. Runge-Kutta: Frage (beantwortet)
Status: (Frage) beantwortet Status 
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

Bezug
                                                        
Bezug
Euler vs. Runge-Kutta: Antwort
Status: (Antwort) fertig Status 
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 []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

Bezug
                                                                
Bezug
Euler vs. Runge-Kutta: Mitteilung
Status: (Mitteilung) Reaktion unnötig Status 
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 ;-)

Bezug
Ansicht: [ geschachtelt ] | ^ Forum "Matlab"  | ^^ Alle Foren  | ^ Forenbaum  | Materialien


^ Seitenanfang ^
ev.vorhilfe.de
[ Startseite | Mitglieder | Impressum ]