# Berechnung Kurvendiskussion



## peterpan7 (28. Apr 2009)

Ich habe ein Problem mit meinem Programm welches einen vorher wählbaren Term in ein Koordinatensystem zeichnen soll.

Hier mal die zwei Funktionen aus dem Programm:


```
public void f(double x)
		{
		
				double summe = 0.;
				double term, abl1, abl2;
				Zahlreset();
					try
					{
				a = Integer.valueOf(tex1.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}
					
					try
					{
				b = Integer.valueOf(tex2.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}
					
					try
					{
				c = Integer.valueOf(tex3.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}
					
					try
					{
				d = Integer.valueOf(tex4.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}
					
					try
					{
				e = Integer.valueOf(tex5.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}
					
					try
					{
				f = Integer.valueOf(tex6.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}
					
					try
					{
				g = Integer.valueOf(tex7.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}
					
					try
					{
				h = Integer.valueOf(tex8.getText());
					}
					catch(NumberFormatException nfe)
					{
						System.out.println("fehler");
					}

				
				
				summe = a*Math.pow(x,(double)grad);
				if (grad > 1) 
				{
					summe = summe + b*Math.pow(x,(double)grad-1);
					if (grad > 2) 
					{
						summe = summe + c*Math.pow(x,(double)grad-2);
						if (grad > 3)
						{
							summe = summe + d*Math.pow(x,(double)grad-3);
							if (grad > 4)
							{
								summe = summe + e*Math.pow(x,(double)grad-4);
								if (grad > 5)
								{
									summe = summe + f*Math.pow(x,(double)grad-5);
									if (grad > 6)
									{
										summe = summe + g*Math.pow(x,(double)grad-6);
										if (grad > 7)
										{
											summe = summe + h*Math.pow(x,(double)grad-7);
										}
										else
										{
											summe = summe + h;
										}
									}
									else
									{
										summe = summe + g;
									}
								}
								else
								{
									summe = summe + f;
								}
							}
							else
							{
								summe = summe + e;
							}
						}
						else
						{
							summe = summe + d;
						}
					}
					else
					{
						summe = summe + c;
					}
				}
				else
				{
					summe = summe + b;
				}
					
				
		}
```
und...

```
public void paint(Graphics g)
   		{
   	
	  xsa = 400;
	  xse = 700;
	  ysa = 150;
	  yse = 450;
	  
	  xwa = -10;
	  xwe = 10;
	  ywa = 10;
	  ywe = -10;
	 
      // Zeichnen der Rahmens
      g.setColor(Color.green);
      g.drawRect(xsa-rand,ysa-rand,xse-xsa+2*rand,yse-ysa+2*rand);
      // Konstruktion der x-Achse
      g.setColor(Color.blue);
      g.drawLine(transx(xwa),transy(0),transx(xwe),transy(0));
      g.drawString("x",transx(xwe)+5,transy(0)+5);
      // Pfeil an die x-Achse
      g.drawLine(transx(xwe),transy(0),transx(xwe)-5,transy(0)-5);
      g.drawLine(transx(xwe),transy(0),transx(xwe)-5,transy(0)+5);
      // Skalierung der x-Achse
      int ischritt = 1;
      if (xwe-xwa > 20) ischritt = 5;
      if (xwe-xwa > 100) ischritt = 10;
      for (int i = (int)xwa; i < (int)xwe; i+=ischritt)
      {
      	if (i != 0)
      	{
      		g.drawLine(transx(i),transy(0)-5,transx(i),transy(0)+5);
      		g.drawString(""+i,transx(i),transy(0)+15);
      	}
      }
      
     
      // Konstruktion der y-Achse
      g.setColor(Color.red);
      g.drawLine(transx(0),transy(ywa),transx(0),transy(ywe));
      g.drawString("y",transy(ywe)+5,transx(0)+5);
      // Pfeil an die y-Achse
      g.drawLine(transx(0),transy(ywe),transx(0)-5,transy(ywe)+5);
      g.drawLine(transx(0),transy(ywe),transx(0)+5,transy(ywe)+5);
       // Skalierung y-Achse
      int ischrit = 1;
      if (ywe-ywa > 20) ischrit = 5;
      if (ywe-ywa > 100) ischrit = 10;
      for (int k = (int)ywa; k < (int)ywe; k+=ischrit)
      {
      	if (k != 0)
      	{
      		g.drawLine(transx(0)-5,transy(k),transx(0)+5,transy(k));
      		g.drawString(""+k,transx(0)-15,transy(k));
      	}
       }
       
              
       
       double graphschrw = (xwe-xwa)/1000;
       double x= 0;
       int x1,x2,y1,y2;
       for(x=xwa;x<xwe;x+=graphschrw)
       {
       		x1=transx(x);
       		y1=transy(m*x+u);
       		x2=transx(x+graphschrw);
       		y2=transy(m*(x+graphschrw)*u);
       		if(y1>=ysa && y1<=yse && y2>=ysa && y2<=yse)
       		{
       			g.drawLine(x2,y2,x1,y1);	
       		}
       	
       }
       
   }

   // Koordinatentransformation Welt- in Screenkoordinaten
   int transx(double xw)
   {
      int xs = (int)((xse-xsa)/(xwe-xwa)*(xw-xwa)+xsa);
      // Testprint
      System.out.println("transx: xw = "+xw+"\t --> xs = "+xs);
      return xs;
   }
   int transy(double yw)
   {
      int ys = (int)((ysa-yse)/(ywe-ywa)*(yw-ywa)+yse);
      // Testprint
      System.out.println("transy: yw = "+yw+"\t --> ys = "+ys);
      return ys;
   }


}
```

...ich komm absolut nicht weiter.
Ich weiß nicht wie ich die Werte die in "public void f(double x)" berechnet werden in den Graphen einfügen kann.

Ich wäre sehr dankbar über eure Hilfe !!!


----------



## SlaterB (28. Apr 2009)

was genau möchtest du denn tun?
einen Graphen zeichnen, also zu einer Funktion ca. 70.000 Werte ausrechnen und dann malen?

wo genau passiert das in paint, Zeile 63? da wird doch ne ganze Menge gemacht, hat das was damit zu tun?

du brauchst jedenfalls eine Schleife, die über alle x-Werte läuft, und f() aufruft, dann hast du neben vielen x-Werten auch viele y und könntest sie direkt zeichnen, speichern oder was immer erforderlich ist,





-------

Optimierungen:
wenn du sehr oft f() aufrufst, dann wäre es schon etwas unnötig, jedesmal wieder die Textfelder-Inhalte zu parsen, berechne dir lieber einmal ein double[8] der 8 Grade und rechne damit die Funktionswerte aus,

mit einem solchen Array ließe sich die Summe auch viel leicher berechnen als mit dem großen if/else-Berg

und 8x 8 Zeichen für jeden Parse-Durchgang ist auch unnötige Wiederholung, 
wie viel schöne sähe der Code mit
b = parse(tex2);
c = parse(tex3);
d = parse(tex4);
e = parse(tex5);
...

aus, mit einer entsprechenden Hilfsmethode parse, die ein TextFeld als Parameter akzeptiert,
mit Arrays und Schleifen noch kürzer


```
int anz = 8;
for(i bis anz) {
  grad[i] =  parse(tex[i]);
}
```


----------



## peterpan7 (28. Apr 2009)

> was genau möchtest du denn tun?
> einen Graphen zeichnen, also zu einer Funktion ca. 70.000 Werte ausrechnen und dann malen?
> 
> wo genau passiert das in paint, Zeile 63? da wird doch ne ganze Menge gemacht, hat das was damit zu tun?



Richtig, ich möchte ca. 70.000 Werte aus rechnen und dann einfach alle Punkte aneinander zeichnen.



> du brauchst jedenfalls eine Schleife, die über alle x-Werte läuft, und f() aufruft, dann hast du neben vielen x-Werten auch viele y und könntest sie direkt zeichnen, speichern oder was immer erforderlich ist,



Ja, so hab ich mir das vorgestellt aber genau da liegt mein Problem, ich weiß nicht wie ich das machen soll?!?!?!



> mit einem solchen Array ließe sich die Summe auch viel leicher berechnen als mit dem großen if/else-Berg



Absolut richtig aber zur Zeit macht mir das obrige Problem viel mehr Sorgen^^


----------



## SlaterB (28. Apr 2009)

wie gesagt hast du doch schon Code wie

```
double graphschrw = (xwe-xwa)/1000;
       double x= 0;
       int x1,x2,y1,y2;
       for(x=xwa;x<xwe;x+=graphschrw)
       {
       		x1=transx(x);
       		y1=transy(m*x+u);
       		x2=transx(x+graphschrw);
       		y2=transy(m*(x+graphschrw)*u);
       		if(y1>=ysa && y1<=yse && y2>=ysa && y2<=yse)
       		{
       			g.drawLine(x2,y2,x1,y1);	
       		}
       	
       }
```

was willst du nun groß anders?

```
double graphschrw = (xwe-xwa)/1000;
       double x= 0;
       int x1,x2,y1,y2;
       for(x=xwa;x<xwe;x+=graphschrw)
       {
       		x1=x;
       		y1=f(x1);

       		x2=x+graphschrw;
       		y2=f(x2);

   		g.drawLine(x2,y2,x1,y1);	
       }
```
schon ist f mit drin, dein Code war vorher aber viel schöner


----------



## peterpan7 (28. Apr 2009)

Stimmt, so müsste es gehen....

Ich muss die Werte aber auf jeden Fall mit den Methoden transx und transy aufrufen, also ungefähr so...


```
ouble graphschrw = (xwe-xwa)/1000;
       double x= 0;
       int x1,x2,y1,y2;
       for(x=xwa;x<xwe;x+=graphschrw)
       {
            x1=transx(x);
            y1=transy(f(x1));
 
            x2=transx(x+graphschrw);
            y2=transy(f(x2));
 
       		 g.drawLine(x2,y2,x1,y1);    
       }
       	
       }
```

...aber dann bekomm ich leider in den transx und transy Methoden 7 Fehler.

7 mal: class, interface, or enum expected int transx(double xw)

Sorry, ich will nicht nerven^^ aber ich bin so nah dran und versteh einfach nicht warum das so nicht funktioniert.


----------



## SlaterB (28. Apr 2009)

klingt als wäre die Methodendefinition außerhalb einer Klasse


----------



## peterpan7 (28. Apr 2009)

Ich habs...

..aus public *void* f(double x) habe ich public *double* f(double x) gemacht.

dann einfach in der Methode ein *return summe;* ergänzt


Die Berechnung sah dann wie folgt aus:

```
double graphschrw = (xwe-xwa)/1000;
       double x= 0;
       int x1,x2,y1,y2;
       for(x=xwa;x<xwe;x+=graphschrw)
       {

            y1 = transy(f(x));
            y2 = transy(f(x+graphschrw));
			x1 = transx(x);
      		x2 = transx(x+graphschrw);
       		
       		if(y1>=ysa && y1<=yse && y2>=ysa && y2<=yse)
       		{
       			g.drawLine(x2,y2,x1,y1);
       		}
```

Ich danke für deine Hilfe =)


----------

