# Lösung Differentialgl. mit RungeKutta + Kurve zeichnen



## Dunair1612 (18. Mai 2010)

Hallo liebe Forenschreiber und Java-Programmierer/Profis!

Ich schau hier oft mal rein, da es echt gute Lösungen und Beispiele dazu gibt, dafür schonmal ein Danke, hat mir schon öfter etwas gebracht!

Nun hab ich selbst ein (oder mehrere?) Probleme, mit einem kleinen Projekt.

Ich will (wie in der Themenüberschrift beschrieben) eine logistische Differentialgleichung mit Hilfe des RungeKutta Verfahrens lösen und die erhaltenen Punkte, verbunden durch eine Kurve, in einem Koordinatensystem darstellen. Der Startwert, die Schrittweite, das Intervall und eine Störfunktion werden dabei durch den Benutzer eingegeben.

Da ich natürlich nur etwas Hilfe möchte und keinen vollständigen Code etc (kann man ja auch schlecht erwarten ), hier mal mein bisheriger Code:

1. Klasse Virus (Name gewählt, weil Differentialgl. eine Virenausbreitung darstellen soll) mit 2 Methoden zur Berechnung des RungeKutta-Verfahrens, ich denke hier muss ein Fehler stecken, da ich im Array punkte[] nur Werte rausbekomm, die so nicht stimmen können (auch infinity werte!). Ich komm einfach nicht drauf, warum ich da so falsche Werte rausbekomm, vllt seh ich vor lauter Bäumen den Wald nicht mehr? ???:L



```
//punkte nimmt gerade falsche und infinity werte (unendlich etc) an! warum?? :/


public class Virus {

	public static double [] classicRungeKutta() {

            double xn = 0.0d;
            double yn = Zeichnenbsp.startwert; //z.b. 50.0
            double interval = Zeichnenbsp.intervall; //z.b. 5000.0
            double h = Zeichnenbsp.schrittweite; // z.b. 20.0
	      

              double [] punkte = new double[(int)(interval/h)];
	      
	      double K1, K2, K3, K4;
	      
	      for (int i = 0; interval > xn; xn = xn + h , i++) { //Schleife zur Berechnung des RungeKutta Verfahrens
	         
	         K1 = diffFkt(xn, yn);
	         K2 = diffFkt(xn + 0.5*h, yn + 0.5*h*K1);
	         K3 = diffFkt(xn + 0.5*h, yn + 0.5*h*K2);
	         K4 = diffFkt(xn + h, yn + h*K3);
	         yn = yn + h/6.0*(K1 + 2.0*K2 + 2.0*K3 + K4);
                 punkte[i]=yn;
                // System.out.println("Punkte[i] hat den Wert: " + punkte[i]);  // nur zu Test-Zwecken, welche falschen Werte ich erhalte
	      }
              return punkte;
	   }

	  
	   private static double diffFkt(double t, double y) {
	      // s'= a*t+v ... hier muss meine Differentialgleichung rein!
		   if(Zeichnenbsp.anfStfkt <= t && Zeichnenbsp.endStfkt >= t)
		   {
			   return t*y - t + Math.sin(t); //hier muss Differentialgleichung und die Störfunktion rein
		   }
		   else
		   {
			   return t*y - t ;  //hier muss die Differentialgleichung rein
		   }
	   } 
}
```


damit es vollständig ist 2. die Klasse Zeichnenbsp, in der ich die Lösungskurve darstellen möchte, da könnten natürlich auch noch Fehler drinstecken, aber ich denke die Klasse Virus ist erstmal das primäre Problem!


```
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
import javax.swing.*;

public class Zeichnenbsp extends Applet implements ActionListener
{
TextField YachseMin,YachseMax,XachseMin,XachseMax,startwertTxt,intervallTxt,schrittweiteTxt,anfangstfktTxt, endestfktTxt;					//Deklarieren der Variablen
Panel north,east,west,gwest,south,center,gridrechts;				
PaintPanel paintpanel;
Label header,yLabel,xLabel,startwertLabel,intervallLabel,schrittweiteLabel, anfangstfktLabel, endestfktLabel;
Button go;

// FELD GR�SSE
final static int PAINTX = 250; 													//Pixel in x- ...
final static int PAINTY = 250; 													//... und y-Richtung

// MIN MAX ACHSEN EINGABEN
double xmin,xmax,ymin,ymax;
static double  startwert, intervall, schrittweite, anfStfkt, endStfkt;

// NULLPUNKTE in pixeln
int nullpunktX,nullpunktY;

//Einheiten auf x- bzw y-Achse
double xstep,ystep;																	//Variablen f�r die eingabe der fkt.

int iks;
int ef[]= new int[PAINTX+1];

boolean alles_berechnet = false;

//korrektes Umrechnen von double in int (incl. runden)
int convert (double wert)
{
if (wert>=0)
return (int)(wert+0.5);
else
return (int)(wert-0.5);
}

    @Override
public void init()
{
setSize(PAINTX+600,PAINTY+80); 													// setzt Fenstergr��e
setLayout(new BorderLayout()); 													// setzt Standartlayout

//Textfields
XachseMin = new TextField("-2000",6);
XachseMax = new TextField("5000",6);
YachseMin = new TextField("-2000",6);
YachseMax = new TextField("5000",6);
startwertTxt = new TextField("50",4);
intervallTxt = new TextField("5000",6);
schrittweiteTxt = new TextField("20",3);
anfangstfktTxt = new TextField("2000",6);
endestfktTxt = new TextField("3000",6);

//Panels
 

north = new Panel(new FlowLayout(FlowLayout.CENTER));
east = new Panel(new FlowLayout(FlowLayout.CENTER));
south = new Panel(new FlowLayout(FlowLayout.CENTER));
west = new Panel(new FlowLayout(FlowLayout.LEFT));
center = new Panel(new FlowLayout(FlowLayout.CENTER));
gwest = new Panel(new GridLayout(7,1));
paintpanel = new PaintPanel();
gridrechts = new Panel(new GridLayout(2,1));


//Hintergrundfarben
north.setBackground(Color.GRAY);
east.setBackground(Color.GRAY);
south.setBackground(Color.GRAY);
center.setBackground(Color.GRAY);
gwest.setBackground(Color.GRAY);
west.setBackground(Color.GRAY);

//Button
go = new Button("GO");
go.addActionListener(this);


//Labels

header = new Label("FunctionPlotter");
xLabel = new Label("<x<",Label.CENTER); // hier stellt man ein, welcher Bereich dargestellt werden soll!
yLabel = new Label("<y<",Label.CENTER);
startwertLabel = new Label("Startwert");
intervallLabel = new Label("Intervall");
schrittweiteLabel = new Label("Schrittweite"); 
anfangstfktLabel = new Label("Beginn Störfunktion");
endestfktLabel = new Label("Ende Störfunktion");

//ADDS
add(north ,BorderLayout.NORTH);
add(east, BorderLayout.EAST);
add(west, BorderLayout.WEST);
add(south, BorderLayout.SOUTH);
add(center, BorderLayout.CENTER);

east.add(gridrechts);
				
north.add(header);
gridrechts.add(go);
center.add(paintpanel);



south.add(startwertLabel);
south.add(startwertTxt);
south.add(intervallLabel);
south.add(intervallTxt);
south.add(schrittweiteLabel);
south.add(schrittweiteTxt);
south.add(anfangstfktLabel);
south.add(anfangstfktTxt);
south.add(endestfktLabel);
south.add(endestfktTxt);

west.add(gwest);

gwest.add(XachseMin);
gwest.add(xLabel);
gwest.add(XachseMax);
gwest.add(new Label());
gwest.add(YachseMin);
gwest.add(yLabel);
gwest.add(YachseMax);

}

public void actionPerformed(ActionEvent e)
{
xmin = Double.parseDouble(XachseMin.getText()); //Eingabe Graphen
xmax = Double.parseDouble(XachseMax.getText());
ymin = Double.parseDouble(YachseMin.getText());
ymax = Double.parseDouble(YachseMax.getText());

startwert = Double.parseDouble(startwertTxt.getText());			//Eingabe der Funktion
intervall = Double.parseDouble(intervallTxt.getText());
schrittweite = Double.parseDouble(schrittweiteTxt.getText());
anfStfkt = Double.parseDouble(anfangstfktTxt.getText());
endStfkt = Double.parseDouble(endestfktTxt.getText());

AchsenKreuzBerechnen();
Virus.classicRungeKutta();
FunktionBerechnen();
AchsenBeschriftungBerechnen();

alles_berechnet = true;

paintpanel.repaint();
}

// Achsenkreuz Berechnen
public void AchsenKreuzBerechnen()
{
nullpunktX = convert((PAINTX * (0-xmin))/ (xmax-xmin));
nullpunktY = PAINTY-convert((PAINTY * (0-ymin))/ (ymax-ymin));
}

// Achsenkreuz Zeichnen
public void AchsenKreuzZeichnen(Graphics g)
{
g.drawLine(0,nullpunktY,PAINTX,nullpunktY); //x achse
g.drawLine(nullpunktX,0,nullpunktX,PAINTY); //y achse
}

// Funktion Berechnen
public void FunktionBerechnen()
{
double x, y;

//Pixel in x-Richtung durchlaufen ...
for(iks = 0; iks<Virus.classicRungeKutta().length; iks++)
{
//...aus Pixel ein double ...
x = xmin + iks*(xmax-xmin)/PAINTX;
//...dazu den Funktionswert ...
y = Virus.classicRungeKutta()[iks];
//... und daraus wieder ein Pixel machen
ef[iks] = PAINTY - convert(PAINTY*(y-ymin)/(ymax-ymin));
}
}

// Funktion Zeichnen
public void FunktionZeichnen(Graphics g)
{
//Pixel in x-Richtung durchlaufen ...
for(iks=0; iks<PAINTX; iks++)
{
//...und je 2 benachbarte Punkte verbinden
g.drawLine(iks,ef[iks],iks+1,ef[iks+1]);
}
}

// AchsenBeschriftung Berechnen
public void AchsenBeschriftungBerechnen()
{
// x step
int ixrange = convert(Math.log(xmax-xmin)/Math.log(10)-1);
xstep = Math.pow(10,ixrange);

// y step
int iyrange = convert(Math.log(ymax-ymin)/Math.log(10)-1);
ystep = Math.pow(10,iyrange);
}

// AchsenBeschriftung Zeichnen
public void AchsenBeschriftungZeichnen(Graphics g)
{
int i=0, xpunkt=0, ypunkt=0;

for(i=convert(xmin/xstep); i<convert(xmax/xstep); i++)
{
xpunkt = convert((PAINTX * ((xstep*i)-xmin))/ (xmax-xmin));
g.drawLine(xpunkt,nullpunktY,xpunkt,nullpunktY+2);
}

g.drawString(""+xstep*(i-1),xpunkt,nullpunktY+14);

for(i=convert(ymin/ystep); i<convert(ymax/ystep); i++)
{
ypunkt = convert(PAINTY-(PAINTY * ((ystep*i)-ymin))/ (ymax-ymin));
g.drawLine(nullpunktX,ypunkt,nullpunktX-2,ypunkt);
}
g.drawString(""+ystep*(i-1),nullpunktX+4,ypunkt);
}


// Innere Paint Klasse
public class PaintPanel extends Panel
{
public PaintPanel()
{
setPreferredSize(new Dimension(PAINTX,PAINTY));									// Gr��e der Paintfl�che
setBackground(Color.WHITE);														//Hintergrund der Paintfl�che
}

        @Override
public void paint(Graphics g)
{
g.drawRect(0,0,PAINTX-1,PAINTY-1); 												// Zeichne Umrandung
if(alles_berechnet)
{
AchsenKreuzZeichnen(g);
FunktionZeichnen(g);
AchsenBeschriftungZeichnen(g);
}
}
}

}
```

weiß mir gerade nicht zu helfen und hoffe ihr habt ein paar Ideen, für blöde und offensichtliche Fehler muss ich mich schonmal entschuldigen, ich komm einfach nicht drauf. 

Im übrigen nutze ich Net Beans IDE 6.8 bzw habs auch schon mit Eclipse versucht.

Falls ich das Thema im falschen Bereich gepostet hab, bitte ich das auch zu entschuldigen!

Also, euch schonmal vielen Dank im Voraus!

Mfg
Benny


----------



## madboy (18. Mai 2010)

Zum eigentlichen Problem, warum falsche Werte auftreten kann ich dir leider nicht weiter helfen aber eine Empfehlung, wie du dem Problem auf die Schliche kommst hätte ich anzubieten 

nicht gut:

```
public static double [] classicRungeKutta() {
 
            double xn = 0.0d;
            double yn = Zeichnenbsp.startwert; //z.b. 50.0
            double interval = Zeichnenbsp.intervall; //z.b. 5000.0
            double h = Zeichnenbsp.schrittweite; // z.b. 20.0
```

gut:


```
public static double [] classicRungeKutta(double yn, double interval, double h) {
 
            double xn = 0.0d;
```

Das macht die Sache übersichtlicher und außerdem hast du keine zirkulären Abhängigkeiten (A ruft B auf während B A aufruft).

Dann schreibe eine Testmethode, die nur 
	
	
	
	





```
classicRungeKutta
```
 aufruft und vergleiche dann die Werte, die du erwartest mit denen, die die Methode liefert.
Damit kannst du schon mal schauen, ob die Methode das Problem ist oder vielleicht doch das Zeichnen der Funktion.


----------



## Dunair1612 (19. Mai 2010)

Hey, danke für die schnelle Antwort!

hab das jetzt mal gemacht und die Werte sind eigentl auch nicht mehr soo das Problem denke ich, da sie jetzt stimmen, nur komm ich mit meiner Skalierung etc von meiner Zeichnung überhaupt nicht zu Recht, Kurve wird bei mir nicht toll dargestellt usw, vllt hat da ja jemand Erfahrung und noch ein paar Tipps für mich!?

Hier nochmal der geänderte Code:

Runge-Kutta Verfahren:


```
public class Virus {

  public static double [] classicRungeKutta(double y, double interv, double schritt, double anfstfkt, double endstfkt) {

            double xn = 0.0d;
            double yn = y; //z.b. 50.0
            double interval = interv; //z.b. 5000.0
            double h = schritt; // z.b. 20.0
            double a = anfstfkt;
            double e = endstfkt;
        

            double [] punkte = new double[(int)(interval/h)];
        
            double k1, k2, k3, k4;
        
        for (int i = 0; interval > xn; xn = xn + h , i++) { //Schleife zur Berechnung des RungeKutta Verfahrens
           
           k1 = diffEquation(xn, yn, a, e);
           //System.out.println(k1);       //Auskommentiert: Optionale Bildschirmausgaben  zur Kontrolle der Zwischenergebnise mit Hilfe der Main-Methode
           k2 = diffEquation(xn + 0.5*h, yn + 0.5*h*k1, a, e);
           //System.out.println(k2);
           k3 = diffEquation(xn + 0.5*h, yn + 0.5*h*k2, a, e);
           //System.out.println(k3);
           k4 = diffEquation(xn + h    , yn + h*k3, a, e);
           //System.out.println(k4);
           yn = yn + h/6.0*(k1 + 2.0*k2 + 2.0*k3 + k4);
           //System.out.println(yn);
                 punkte[i]=yn;
        }
              return punkte;
     }

     
     /**
      * This is the first derivation of path-time-low needed by Runge-Kutta
      * s(t)  = 1/2 * a * t^2
      * s'(t) = t*a
      *
      * @param   double   time
      * @param   double   not needed for our derivation
      * @return   double   gradient of s(t) in point t
      */
     private static double diffEquation(double t, double y, double anfst, double endst) {
        // s'= a*t+v ... hier muss meine Differentialgleichung rein!
    double zeitp = t;
    double fwert = y;
    double astfkt = anfst;
    double estfkt = endst;




       if(astfkt <= t && estfkt >= t)
       {
         return 2*zeitp - zeitp + Math.sin(zeitp); //hier muss Differentialgleichung und die StÃ¶rfunktion rein
       }
       else
       {
         return 2*zeitp - zeitp ;  //hier muss die Differentialgleichung rein
       }
     } 
     
     /*public static void main(String[]args)      //Main Methode zur Anzeige/Überprüfung ob meine Punkte stimmen
     {
       double [] zahlen = new double [250];
       zahlen = classicRungeKutta(50.0, 5000.0, 20.0, 2000.0, 3000.0);
       
       for (int i=0; i<zahlen.length; i++)
       {
       System.out.println(zahlen[i]);
       }
     }
	*/
}
```



Lösungskurve zeichnen:


```
import java.awt.*;
import java.awt.event.*;
import java.applet.Applet;
import javax.swing.*;

public class Zeichnenbsp extends Applet implements ActionListener
{

  // Anfang Attribute
TextField YachseMin,YachseMax,XachseMin,XachseMax,startwertTxt,intervallTxt,schrittweiteTxt,anfangstfktTxt, endestfktTxt;         //Deklarieren der Variablen
Panel north,east,west,gwest,south,center,gridrechts;        
PaintPanel paintpanel;
Label header,yLabel,xLabel,startwertLabel,intervallLabel,schrittweiteLabel, anfangstfktLabel, endestfktLabel;
JCheckBox cb;
Button go;

// FELD GR�SSE
final static int PAINTX = 250;                          //Pixel in x- ...
final static int PAINTY = 250;                          //... und y-Richtung

// MIN MAX ACHSEN EINGABEN
double xmin,xmax,ymin,ymax;
static double  startwert, intervall, schrittweite, anfStfkt, endStfkt;

// NULLPUNKTE in pixeln
int nullpunktX,nullpunktY;

//Einheiten auf x- bzw y-Achse
double xstep,ystep;

//double a,b,c,d;                                 //Variablen f?r die eingabe der fkt.

int iks;
int ef[]= new int[PAINTX+1];

boolean alles_berechnet = false;
  // Ende Attribute


//korrektes Umrechnen von double in int (incl. runden)
int convert (double wert)
{
if (wert>=0)
return (int)(wert+0.5);
else
return (int)(wert-0.5);
}

    @Override
public void init()
{
setSize(PAINTX+600,PAINTY+80);                          // setzt Fenstergr??e
setLayout(new BorderLayout());                          // setzt Standartlayout

//Textfields
XachseMin = new TextField("-2000",6);
XachseMax = new TextField("5000",6);
YachseMin = new TextField("-2000",6);
YachseMax = new TextField("5000",6);
startwertTxt = new TextField("50",4);
intervallTxt = new TextField("5000",6);
schrittweiteTxt = new TextField("20",3);
anfangstfktTxt = new TextField("2000",6);
endestfktTxt = new TextField("3000",6);

//Panels
 

north = new Panel(new FlowLayout(FlowLayout.CENTER));
east = new Panel(new FlowLayout(FlowLayout.CENTER));
south = new Panel(new FlowLayout(FlowLayout.CENTER));
west = new Panel(new FlowLayout(FlowLayout.LEFT));
center = new Panel(new FlowLayout(FlowLayout.CENTER));
gwest = new Panel(new GridLayout(7,1));
paintpanel = new PaintPanel();
gridrechts = new Panel(new GridLayout(2,1));


//Hintergrundfarben
north.setBackground(Color.GRAY);
east.setBackground(Color.GRAY);
south.setBackground(Color.GRAY);
center.setBackground(Color.GRAY);
gwest.setBackground(Color.GRAY);
west.setBackground(Color.GRAY);

//Button
go = new Button("GO");
go.addActionListener(this);

//Checkbox
//cb = new JCheckBox("f'(x)",false);

//Labels

header = new Label("FunctionPlotter");
xLabel = new Label("<x<",Label.CENTER); // hier stellt man ein, welcher Bereich dargestellt werden soll!
yLabel = new Label("<y<",Label.CENTER);
startwertLabel = new Label("Startwert");
intervallLabel = new Label("Intervall");
schrittweiteLabel = new Label("Schrittweite"); 
anfangstfktLabel = new Label("Beginn Störfunktion");
endestfktLabel = new Label("Ende Störfunktion");

//ADDS
add(north ,BorderLayout.NORTH);
add(east, BorderLayout.EAST);
add(west, BorderLayout.WEST);
add(south, BorderLayout.SOUTH);
add(center, BorderLayout.CENTER);

east.add(gridrechts);
        
north.add(header);
gridrechts.add(go);
gridrechts.add(cb);
center.add(paintpanel);



south.add(startwertLabel);
south.add(startwertTxt);
south.add(intervallLabel);
south.add(intervallTxt);
south.add(schrittweiteLabel);
south.add(schrittweiteTxt);
south.add(anfangstfktLabel);
south.add(anfangstfktTxt);
south.add(endestfktLabel);
south.add(endestfktTxt);

west.add(gwest);

gwest.add(XachseMin);
gwest.add(xLabel);
gwest.add(XachseMax);
gwest.add(new Label());
gwest.add(YachseMin);
gwest.add(yLabel);
gwest.add(YachseMax);


    // Anfang Komponenten
    // Ende Komponenten
}

  // Anfang Methoden

public void actionPerformed(ActionEvent e)
{
xmin = Double.parseDouble(XachseMin.getText()); //Eingabe Graphen
xmax = Double.parseDouble(XachseMax.getText());
ymin = Double.parseDouble(YachseMin.getText());
ymax = Double.parseDouble(YachseMax.getText());

startwert = Double.parseDouble(startwertTxt.getText());     //Eingabe der Funktion
intervall = Double.parseDouble(intervallTxt.getText());
schrittweite = Double.parseDouble(schrittweiteTxt.getText());
anfStfkt = Double.parseDouble(anfangstfktTxt.getText());
endStfkt = Double.parseDouble(endestfktTxt.getText());

AchsenKreuzBerechnen();
FunktionBerechnen();
AchsenBeschriftungBerechnen();

alles_berechnet = true;

paintpanel.repaint();
}

// Achsenkreuz Berechnen
public void AchsenKreuzBerechnen()
{
nullpunktX = convert((PAINTX * (0-xmin))/ (xmax-xmin));
nullpunktY = PAINTY-convert((PAINTY * (0-ymin))/ (ymax-ymin));
}

// Achsenkreuz Zeichnen
public void AchsenKreuzZeichnen(Graphics g)
{
g.drawLine(0,nullpunktY,PAINTX,nullpunktY); //x achse
g.drawLine(nullpunktX,0,nullpunktX,PAINTY); //y achse
}

// Funktion Berechnen
public void FunktionBerechnen()
{
double x;
double [] erg = new double[(int) (intervall/schrittweite)];

//Pixel in x-Richtung durchlaufen ...
for(iks = 0; iks<Virus.classicRungeKutta().length; iks++)
{
//...aus Pixel ein double ...
x = xmin + iks*(xmax-xmin)/PAINTX;
//...dazu den Funktionswert ...
erg = Virus.classicRungeKutta(startwert, intervall, schrittweite, anfStfkt, endStfkt);
//System.out.println(Virus.classicRungeKutta()[iks]);
//... und daraus wieder ein Pixel machen
ef[iks] = PAINTY - convert(PAINTY*(erg[iks]-ymin)/(ymax-ymin));
}
}

// Funktion Zeichnen
public void FunktionZeichnen(Graphics g)
{
//Pixel in x-Richtung durchlaufen ...
for(iks=0; iks<PAINTX; iks++)
{
//...und je 2 benachbarte Punkte verbinden
g.drawLine(iks,ef[iks],iks+1,ef[iks+1]);
}
}

// AchsenBeschriftung Berechnen
public void AchsenBeschriftungBerechnen()
{
// x step
int ixrange = convert(Math.log(xmax-xmin)/Math.log(10)-1);
xstep = Math.pow(10,ixrange);

// y step
int iyrange = convert(Math.log(ymax-ymin)/Math.log(10)-1);
ystep = Math.pow(10,iyrange);
}

// AchsenBeschriftung Zeichnen
public void AchsenBeschriftungZeichnen(Graphics g)
{
int i=0, xpunkt=0, ypunkt=0;

for(i=convert(xmin/xstep); i<convert(xmax/xstep); i++)
{
xpunkt = convert((PAINTX * ((xstep*i)-xmin))/ (xmax-xmin));
g.drawLine(xpunkt,nullpunktY,xpunkt,nullpunktY+2);
}

g.drawString(""+xstep*(i-1),xpunkt,nullpunktY+14);

for(i=convert(ymin/ystep); i<convert(ymax/ystep); i++)
{
ypunkt = convert(PAINTY-(PAINTY * ((ystep*i)-ymin))/ (ymax-ymin));
g.drawLine(nullpunktX,ypunkt,nullpunktX-2,ypunkt);
}
g.drawString(""+ystep*(i-1),nullpunktX+4,ypunkt);
}
  // Ende Methoden


// Innere Paint Klasse
public class PaintPanel extends Panel

  // Anfang Attribute1
  // Ende Attribute1

{
public PaintPanel()
{
setPreferredSize(new Dimension(PAINTX,PAINTY));                 // Gr??e der Paintfl?che
setBackground(Color.WHITE);                           //Hintergrund der Paintfl?che

    // Anfang Komponenten1
    // Ende Komponenten1
}

  // Anfang Methoden1

        @Override
public void paint(Graphics g)
{
g.drawRect(0,0,PAINTX-1,PAINTY-1);                        // Zeichne Umrandung
if(alles_berechnet)
{
AchsenKreuzZeichnen(g);
FunktionZeichnen(g);
AchsenBeschriftungZeichnen(g);
}
}
  // Ende Methoden1
}

}
```

Danke schonmal!

Gruß


----------



## Marco13 (19. Mai 2010)

Hab's jetzt nicht nachvollzogen, aber zum Zeichnen von Funktionen kommen hier öfter mal Fragen - z.B. sowas...


----------

