# EulerVerfahren, Differentialgleichung mit JAVA



## kriizz (2. Dez 2008)

Guten Abend,

ich bin hier am verzweifeln.
Ich sitze seit ca. 1 Woche am gleichen Problem und habe google auch schon durch. Ich verstehe es einfach nicht.
Ich hoffe hier kann mir einer sagen, was ich falsch mache.

Ich habe eine Differentialgleichung : y'(t) = k*y(t)*(s-y(t)) -g(t)
k ist ein Faktor. S die Schranke ( logistische Diffgl.) g(t) eine Störgröße die hier irrelevant ist.

Diese Diffgl. soll ich mit dem Eulerverfahren lösen. 
Ich habe auch verstanden, wie das Eulerverfahren funktioniert. Nur wird meine DGL nicht so gezeichnet wie sie es soll.
Mein Prof hat aus dieser Gleichung f(t,y) = t*y(t) - y²(t) -y(t).
Ich verstehe den Grundsatz aber nicht, wieso ich hier en t einbauen soll, obwohl ich oben nur eine konstante habe.

HIer mein Quellcode von den Methoden die rechnen:


```
private double function(double x, double y) {
        return k*y*(s-y); // a*Math.pow(Math.sin((2*Math.PI*f/n)*x/2),2)*Math.sin(2*Math.PI*f*x);        
    }
    
    public double[][] calculate() {
        double h = 0.1;//(stunden-intervallStart)/n;
        xy[0][0] = x0;
        xy[0][1] = y0;
        for(int i = 0; i <= stunden; i++) {
           xy[i+1][0] = xy[i][0] + h;
           xy[i+1][1] = xy[i][1]+h*function(xy[i][0],xy[i][1]);
        }
        return xy;
    }
```

Kann mir bitte jemand meinen Fehler sagen?? 
Oder mir zumindest einen Ansatz geben, mit dem ich weiter machen kann.

MfG

Chris


----------



## 0x7F800000 (2. Dez 2008)

hmm, irgendwie ist mir momentan schleierhaft, was


> Mein Prof hat aus dieser Gleichung f(t,y) = t*y(t) - y²(t) -y(t).


bedeuten soll, kommt drauf an, was er da mit f(t,y) gemeint hat...

ebenso unklar ist mir, was dieses "x" in der ersten zeile deines quellcodes bedeuten soll...

so wie ich das verstehe, willst du doch so etwas wie:
y'(t)=k y(t) (s-y(t))-g(t) =:f(y,t)
mit dem einfachsten eulerverfahren lösen.

Also diskretesierst du das alles:

dy(t)/dt=f(y(t),t) 
=> dy(t)=dt*f(y(t),t)

diskretesieren:
y(t+h)-y(t)=h*f(y(t),t)
=> y(t+h)=y(t)+h*f(y(t),t)
wobei h>0 einfach so eine willkürlich nicht zu groß gewählte schrittweite ist.

im code würde das in etwa so aussehen:

```
private static double f(double y, double t){
   return k*y*(s-y)+g(t);
}

public double[][] calculate(double y, double h, double maxTime){
   
   // punkte zum malen soll's doch ausgeben, oder was?   
   double[][] result=new double[(int)(maxTime/h)+1][2];
   
   int i=0;
   for(double t=0; t<maxTime; t+=h){
      result[i][0]=t;
      result[i][1]=y;
      y+=h*f(y,t);
      i++;
   }
   return result;
}
```
wobei y den startwert, h die schrittweite, maxTime die endzeitpunkt bedeuten soll. was g und k und s sind, musst du selbst sonstwo definieren.

(nicht getestet, nicht kompiliert, nicht ausgeführt, weil ja ein funktionierender beispielcode fehlt)


----------



## Guest (3. Dez 2008)

wow.. danke 
Endlich kann ich weiter machen... es tut...
vielen Dank und das obwohl ich mich so unklar ausgedrückt hab  :toll:


----------

