Funktionsplotter

[Nika84]

Hi!
ich brauche Hilfe.Das ist mein ganze Code
Plotter.java

package pFunktionsPlotter;

import java.awt.*;
import java.awt.event.*;

public class Plotter extends Frame {
	public Plotter() {
		setTitle("Funktionsplotter");
		FktGraph p = new FktGraph(-5,5,-4,3);
		add(p);
		setSize(700, 700);
		setVisible(true);
		addWindowListener(new WindowAdapter() {
			public void windowClosing(WindowEvent e) {
				System.exit(0);
			}
		});
	}

	public static void main(String args[]) {
		new Plotter();
	}

}

FktGraph.java

package pFunktionsPlotter;

import java.awt.*;
import java.text.DecimalFormat;

public class FktGraph extends Panel {
	int maxX, maxY;
	double xa, xe, ya, ye;
	public FktGraph(double xa, double xe, double ya, double ye) {
		this.xa = xa;
		this.xe = xe;
		this.ya = ya;
		this.ye = ye;
	}
	double f(double x)
	{
		return 1/(x*x);
	}
	double g(double x)
	{
		return (-(x*x)-1);
	}
	int pixX(double x) {
		return (int) ((x - xa) / (xe - xa) * maxX);
	}
	int pixY(double y) {
		return (int) ((ye - y) / (ye - ya) * maxY);
	}
	double karX(int px) {
		return px * (xe - xa) / maxX + xa;
	}
	double karY(int py) {
		return ye - py * (ye - ya) / maxY;
	}
	int tickdistx(double w){ return (pixX(w)-pixX(0));} 
    int tickdisty(double w){ return (pixY(0)-pixY(w));} 
    DecimalFormat df = new DecimalFormat("#0.########");
 
    void zeichneAchsen(Graphics g) 
    {    	
        g.drawLine(0,pixY(0),maxX,pixY(0));         // x-Achse 
        g.drawLine(maxX-10,pixY(0)-5,maxX,pixY(0)); // Spitze 
        g.drawLine(maxX-10,pixY(0)+5,maxX,pixY(0)); 
        g.drawLine(pixX(0),maxY,pixX(0),0);         // y-Achse 
        g.drawLine(pixX(0)-5,10,pixX(0),0);         // Spitze 
        g.drawLine(pixX(0)+5,10,pixX(0),0); 
        
        // Ticks auf der x-Achse 
        double tick = 1; 
        double start = 0; 
        while (tickdistx(tick) > 81 || tickdistx(tick) <31 ) 
        { 
            if (tickdistx(tick) > 81) tick = tick/2; 
            if (tickdistx(tick) < 31) tick = tick*2;  
        } 
        start=0; 
        while (start-tick>xa)start = start-tick; 
        while (start < xe) 
        { 
            g.drawLine(pixX(start), pixY(0)-3,pixX(start),pixY(0) +  3); // Markierung senkrecht zur x-Achse 
            g.drawString(df.format(start),pixX(start),pixY(0) + 20);      // Zahlenwert mit einer Kommastelle 
            start = start + 2*tick; 
        } 
        // Ticks auf der y-Achse 
        tick = 1; 
        start = 0; 
        while (tickdisty(tick) > 81 || tickdisty(tick) < 31 ) 
        { 
            if (tickdisty(tick) > 81) tick = tick/2; 
            if (tickdisty(tick) < 31) tick = tick*2; 
        } 
        start=0; 
        while (start-tick>ya)start = start-tick; 
        while (start < ye) 
        { 
            g.drawLine(pixX(0)-3, pixY(start),pixX(0)+3,pixY(start)); 
            if(start!=0) g.drawString(df.format(start),pixX(0)+5,pixY(start)+5); 
            start = start + tick; 
        } 
        
    }  
	public void paint(Graphics g) {
		
		maxX = this.getBounds().width;
		maxY = this.getBounds().height;
		zeichneAchsen(g);
		int oldx = 0;
		int oldy = pixY(f(xa));
		int py;
		
		for (int px = 0; px < maxX; px = px + 1) {
			py = pixY(f(karX(px)));
			g.setColor(Color.blue);
			g.drawLine(oldx, oldy, px, py);
			oldx = px;
			oldy = py;
		}
		for (int px = 0; px < maxX; px = px + 1) {
			py = pixY(g(karX(px)));
			g.setColor(Color.blue);
			g.drawLine(oldx, oldy, px, py);
			oldx = px;
			oldy = py;
		}
				
	 } 
}

Wie kann ich Linie zwischen (0,-13) und (5,0) weg machen?

 

[SlaterB]

bloß nicht eine Zeile zuviel Text schreiben, was?

altes Thema war
http://www.java-forum.org/java-basics-anfaenger-themen/94694-funktionsplotter-polstellen.html

---------

was bisher vollkommen unahnbar war, zeigt sich nun mit deiner main-Methode:
du zeichnest zwei Funktionen hintereinandern, es geht gar nicht um Polstellen oder ähnlich komisches,
sondern zunächst einfach nur um den letzten Punkt der ersten Funktion und den ersten der neuen,
(edit: ok, stand in der schon geposteten Panel-Klasse, theoretisch wäre es denkbar, ohne vollständiges Programm darauf zu kommen..)

vor der ersten Schleife hast du eine Initialisierung des ersten Punktes (oldx/y), wenn du das vor der zweiten Schleife auch machst:

        oldx = 0;
        oldy = pixY(g(xa));

dann ist das Problem schon weg

deutlich eleganter ist natürlich, nicht noch mehr Code zu verdoppeln, sondern eine Untermethode
> void zeichneFuntion(boolean fOderG)
einzuführen, wenn diese dann korrekt eine Schleife umsetzt, mit Initialisierung des ersten Punktes am Anfang,
dann funktioniert sie auch gut für die zweite Funktion


-------

recht simpler Fehler, in Sekunden zu finden,
mit einer ordentlichen Frage und allen Informationen hättest du nicht Tage bis Wochen warten müssen

 

[Nika84]

Ok, wenn ich nur eine Funktion 1/(x-1)*(x+1) benutzen dann kommt senkrechte Striche (-1,0) und (1,0),
wie kann ich diese Striche weg machen.

 

[SlaterB]

im sauberen Falle gehört wie damals angesprochen wurde bzw. ganz leicht zu denken ist eine mathematische Funktionsuntersuchung nach Polstellen usw. zum Programm,
das würde den bisherigen einfachen Umfang natürlich verzwanzigfachen

bleiben nur Verlegenheitslösungen, die Werte anschauen und nach besonderen Stellen suchen
-31.952380952380715
-42.24999999999961
-61.90909090909012
-114.33333333333081
-690.9999999999139
174.00000000000506
77.88888888888982
50.42857142857179

sind die y-Werte in Reihenfolge,
also könnte man z.B. einbauen dass ein Sprung von unterhalb des dargestellten Bereichs (hier -4) auf überhalb (3) bzw. umgekehrt nicht gezeichnet wird,
die entsprechenden if-Befehle kannst du dir hoffentlich denken, sonst habe ich wirklich keine Lust dir das Programm zu programmieren

wenn man den Ausschnitt größer macht, dann sind diese Grenzen zu klein, dann muss man vielleicht doch auf feste Werte wechseln,

bei bestimmten Funktionen kann dieser Schritt auch komplett falsch sein, ist nunmal eine Vereinfachung,
bisschen mehr hilft dann, die weiteren Werte anzuschauen, -50, -60, +60, +50 ist offensichtlich was anderes als -70, -60, +60, +70,
je mehr man in die Richtung arbeitet, desto eher landet man bei der richtigen Polstellensuche, auch wenn der Weg natürlich noch sehr weit ist

--------

besonders handhabbar fällt mir gerade ein und deshalb erwähnenswert, mag Intervallhalbierung sein,
wenn man einen verdächtigen starken übergang hat, was nichtmal von + nach - sein muss, vergleiche

    double f(double x)
    {
        return 1 / (x - 1) * (x + 1) - 300;
    }
+
FktGraph p = new FktGraph(-5, 5, -700, 300);

,

alsp wenn man z.B. einen y-Unterschied von über 20 feststellt, dann kann man den Funktionswert mit der Hälfte zwischen dem alten und neuen x anschauen, liegt der zwischen den beiden zu zeichnenden Punkten, dann ist es wohl ok, sonst eher schlecht

das kann man eigentlich auch immer machen, das gefällt mir so gut, da poste ich auch den Code :

            double hy = pixY(f(karX(px - 0.5)));
            if ((hy >= oldy && hy <= py) || (hy <= oldy && hy >= py))
            {
                g.drawLine(oldx, oldy, px, py);
            }

die karX-Methode muss dann auf double umgestellt werden und das -0.5 geht nur wenn die Schleife mit +1 arbeitet,
was man aber wohl annehmen kann, immer einen Pixel voraus

------

zwei Zeilen Frage, 20 Zeilen und mehr Antwort, mehr als du je in allen deinen Postings und PMs zusammen hast,
hier läuft eindeutig was falsch
ich werde bei dem Verhältnis wohl nicht mehr antworten, nun aber vielleicht auch schon geklärt

 

[Nika84]

Danke für die Hilfe, kannst du mir bitte zeigen wohin genau muss ich die karX-Methode auf double umgestellt, habe ich so probiert aber dass geht nicht

public void paint(Graphics g) {
		
		maxX = this.getBounds().width;
		maxY = this.getBounds().height;
		zeichneAchsen(g);
		int oldx = 0;
		int oldy = pixY(f(xa));
		int py;
		
		for (int px = 0; px < maxX; px = px + 1) {
			double karX;
			double hy = pixY(f(karX(px - 0.5)));
			g.setColor(Color.blue);
			if ((hy >= oldy && hy <= py) || (hy <= oldy && hy >= py))
	        {
	            g.drawLine(oldx, oldy, px, py);
	        }
		}        
	 }

 

[SlaterB]

mit
> karX(px - 0.5)
wird ein double an die Methode übergeben,
die Fehlermeldung sagt dir sicherlich auch, dass ein double schlecht zum int-Parameter der Methode passt,

daraus ergibt sich für dich keinerlei Idee, was zu tun ist?
die Methode so ändern dass sie mit double zurechtkommt sagt dir rein gar nichts?